[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / openvswitch / vport-internal_dev.c

/*
 * Copyright (c) 2007-2012 Nicira, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 */

#include <linux/hardirq.h>
#include <linux/if_vlan.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/skbuff.h>

#include <net/dst.h>
#include <net/xfrm.h>

#include "datapath.h"
#include "vport-internal_dev.h"
#include "vport-netdev.h"

struct internal_dev {
	struct vport *vport;
};

static struct internal_dev *internal_dev_priv(struct net_device *netdev)
{
	return netdev_priv(netdev);
}

/* This function is only called by the kernel network layer.*/
static struct rtnl_link_stats64 *internal_dev_get_stats(struct net_device *netdev,
							struct rtnl_link_stats64 *stats)
{
	struct vport *vport = ovs_internal_dev_get_vport(netdev);
	struct ovs_vport_stats vport_stats;

	ovs_vport_get_stats(vport, &vport_stats);

	/* The tx and rx stats need to be swapped because the
	 * switch and host OS have opposite perspectives. */
	stats->rx_packets	= vport_stats.tx_packets;
	stats->tx_packets	= vport_stats.rx_packets;
	stats->rx_bytes		= vport_stats.tx_bytes;
	stats->tx_bytes		= vport_stats.rx_bytes;
	stats->rx_errors	= vport_stats.tx_errors;
	stats->tx_errors	= vport_stats.rx_errors;
	stats->rx_dropped	= vport_stats.tx_dropped;
	stats->tx_dropped	= vport_stats.rx_dropped;

	return stats;
}

/* Called with rcu_read_lock_bh. */
static int internal_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
{
	rcu_read_lock();
	ovs_vport_receive(internal_dev_priv(netdev)->vport, skb);
	rcu_read_unlock();
	return 0;
}

static int internal_dev_open(struct net_device *netdev)
{
	netif_start_queue(netdev);
	return 0;
}

static int internal_dev_stop(struct net_device *netdev)
{
	netif_stop_queue(netdev);
	return 0;
}

static void internal_dev_getinfo(struct net_device *netdev,
				 struct ethtool_drvinfo *info)
{
	strlcpy(info->driver, "openvswitch", sizeof(info->driver));
}

static const struct ethtool_ops internal_dev_ethtool_ops = {
	.get_drvinfo	= internal_dev_getinfo,
	.get_link	= ethtool_op_get_link,
};

static int internal_dev_change_mtu(struct net_device *netdev, int new_mtu)
{
	if (new_mtu < 68)
		return -EINVAL;

	netdev->mtu = new_mtu;
	return 0;
}

static void internal_dev_destructor(struct net_device *dev)
{
	struct vport *vport = ovs_internal_dev_get_vport(dev);

	ovs_vport_free(vport);
	free_netdev(dev);
}

static const struct net_device_ops internal_dev_netdev_ops = {
	.ndo_open = internal_dev_open,
	.ndo_stop = internal_dev_stop,
	.ndo_start_xmit = internal_dev_xmit,
	.ndo_set_mac_address = eth_mac_addr,
	.ndo_change_mtu = internal_dev_change_mtu,
	.ndo_get_stats64 = internal_dev_get_stats,
};

static void do_setup(struct net_device *netdev)
{
	ether_setup(netdev);

	netdev->netdev_ops = &internal_dev_netdev_ops;

	netdev->priv_flags &= ~IFF_TX_SKB_SHARING;
	netdev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
	netdev->destructor = internal_dev_destructor;
	SET_ETHTOOL_OPS(netdev, &internal_dev_ethtool_ops);
	netdev->tx_queue_len = 0;

	netdev->features = NETIF_F_LLTX | NETIF_F_SG | NETIF_F_FRAGLIST |
			   NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | NETIF_F_TSO;

	netdev->vlan_features = netdev->features;
	netdev->features |= NETIF_F_HW_VLAN_CTAG_TX;
	netdev->hw_features = netdev->features & ~NETIF_F_LLTX;
	eth_hw_addr_random(netdev);
}

static struct vport *internal_dev_create(const struct vport_parms *parms)
{
	struct vport *vport;
	struct netdev_vport *netdev_vport;
	struct internal_dev *internal_dev;
	int err;

	vport = ovs_vport_alloc(sizeof(struct netdev_vport),
				&ovs_internal_vport_ops, parms);
	if (IS_ERR(vport)) {
		err = PTR_ERR(vport);
		goto error;
	}

	netdev_vport = netdev_vport_priv(vport);

	netdev_vport->dev = alloc_netdev(sizeof(struct internal_dev),
					 parms->name, do_setup);
	if (!netdev_vport->dev) {
		err = -ENOMEM;
		goto error_free_vport;
	}

	dev_net_set(netdev_vport->dev, ovs_dp_get_net(vport->dp));
	internal_dev = internal_dev_priv(netdev_vport->dev);
	internal_dev->vport = vport;

	/* Restrict bridge port to current netns. */
	if (vport->port_no == OVSP_LOCAL)
		netdev_vport->dev->features |= NETIF_F_NETNS_LOCAL;

	rtnl_lock();
	err = register_netdevice(netdev_vport->dev);
	if (err)
		goto error_free_netdev;

	dev_set_promiscuity(netdev_vport->dev, 1);
	rtnl_unlock();
	netif_start_queue(netdev_vport->dev);

	return vport;

error_free_netdev:
	rtnl_unlock();
	free_netdev(netdev_vport->dev);
error_free_vport:
	ovs_vport_free(vport);
error:
	return ERR_PTR(err);
}

static void internal_dev_destroy(struct vport *vport)
{
	struct netdev_vport *netdev_vport = netdev_vport_priv(vport);

	netif_stop_queue(netdev_vport->dev);
	rtnl_lock();
	dev_set_promiscuity(netdev_vport->dev, -1);

	/* unregister_netdevice() waits for an RCU grace period. */
	unregister_netdevice(netdev_vport->dev);

	rtnl_unlock();
}

static int internal_dev_recv(struct vport *vport, struct sk_buff *skb)
{
	struct net_device *netdev = netdev_vport_priv(vport)->dev;
	int len;

	len = skb->len;

	skb_dst_drop(skb);
	nf_reset(skb);
	secpath_reset(skb);

	skb->dev = netdev;
	skb->pkt_type = PACKET_HOST;
	skb->protocol = eth_type_trans(skb, netdev);

	netif_rx(skb);

	return len;
}

const struct vport_ops ovs_internal_vport_ops = {
	.type		= OVS_VPORT_TYPE_INTERNAL,
	.create		= internal_dev_create,
	.destroy	= internal_dev_destroy,
	.get_name	= ovs_netdev_get_name,
	.send		= internal_dev_recv,
};

int ovs_is_internal_dev(const struct net_device *netdev)
{
	return netdev->netdev_ops == &internal_dev_netdev_ops;
}

struct vport *ovs_internal_dev_get_vport(struct net_device *netdev)
{
	if (!ovs_is_internal_dev(netdev))
		return NULL;

	return internal_dev_priv(netdev)->vport;
}
Commit	Line	Data
ccb1352e	1	/*
caf2ee14	2	* Copyright (c) 2007-2012 Nicira, Inc.
ccb1352e JG	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of version 2 of the GNU General Public
	6	* License as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	16	* 02110-1301, USA
	17	*/
	18
	19	#include <linux/hardirq.h>
	20	#include <linux/if_vlan.h>
	21	#include <linux/kernel.h>
	22	#include <linux/netdevice.h>
	23	#include <linux/etherdevice.h>
	24	#include <linux/ethtool.h>
	25	#include <linux/skbuff.h>
ccb1352e	26
7fe99e2d JG	27	#include <net/dst.h>
	28	#include <net/xfrm.h>
	29
ccb1352e JG	30	#include "datapath.h"
	31	#include "vport-internal_dev.h"
	32	#include "vport-netdev.h"
	33
	34	struct internal_dev {
	35	struct vport *vport;
	36	};
	37
	38	static struct internal_dev internal_dev_priv(struct net_device netdev)
	39	{
	40	return netdev_priv(netdev);
	41	}
	42
	43	/* This function is only called by the kernel network layer.*/
	44	static struct rtnl_link_stats64 internal_dev_get_stats(struct net_device netdev,
	45	struct rtnl_link_stats64 *stats)
	46	{
	47	struct vport *vport = ovs_internal_dev_get_vport(netdev);
	48	struct ovs_vport_stats vport_stats;
	49
	50	ovs_vport_get_stats(vport, &vport_stats);
	51
	52	/* The tx and rx stats need to be swapped because the
	53	* switch and host OS have opposite perspectives. */
	54	stats->rx_packets = vport_stats.tx_packets;
	55	stats->tx_packets = vport_stats.rx_packets;
	56	stats->rx_bytes = vport_stats.tx_bytes;
	57	stats->tx_bytes = vport_stats.rx_bytes;
	58	stats->rx_errors = vport_stats.tx_errors;
	59	stats->tx_errors = vport_stats.rx_errors;
	60	stats->rx_dropped = vport_stats.tx_dropped;
	61	stats->tx_dropped = vport_stats.rx_dropped;
	62
	63	return stats;
	64	}
	65
ccb1352e JG	66	/* Called with rcu_read_lock_bh. */
	67	static int internal_dev_xmit(struct sk_buff skb, struct net_device netdev)
	68	{
	69	rcu_read_lock();
	70	ovs_vport_receive(internal_dev_priv(netdev)->vport, skb);
	71	rcu_read_unlock();
	72	return 0;
	73	}
	74
	75	static int internal_dev_open(struct net_device *netdev)
	76	{
	77	netif_start_queue(netdev);
	78	return 0;
	79	}
	80
	81	static int internal_dev_stop(struct net_device *netdev)
	82	{
	83	netif_stop_queue(netdev);
	84	return 0;
	85	}
	86
	87	static void internal_dev_getinfo(struct net_device *netdev,
	88	struct ethtool_drvinfo *info)
	89	{
7826d43f	90	strlcpy(info->driver, "openvswitch", sizeof(info->driver));
ccb1352e JG	91	}
	92
	93	static const struct ethtool_ops internal_dev_ethtool_ops = {
	94	.get_drvinfo = internal_dev_getinfo,
	95	.get_link = ethtool_op_get_link,
	96	};
	97
	98	static int internal_dev_change_mtu(struct net_device *netdev, int new_mtu)
	99	{
	100	if (new_mtu < 68)
	101	return -EINVAL;
	102
	103	netdev->mtu = new_mtu;
	104	return 0;
	105	}
	106
	107	static void internal_dev_destructor(struct net_device *dev)
	108	{
	109	struct vport *vport = ovs_internal_dev_get_vport(dev);
	110
	111	ovs_vport_free(vport);
	112	free_netdev(dev);
	113	}
	114
	115	static const struct net_device_ops internal_dev_netdev_ops = {
	116	.ndo_open = internal_dev_open,
	117	.ndo_stop = internal_dev_stop,
	118	.ndo_start_xmit = internal_dev_xmit,
9151991c	119	.ndo_set_mac_address = eth_mac_addr,
ccb1352e JG	120	.ndo_change_mtu = internal_dev_change_mtu,
	121	.ndo_get_stats64 = internal_dev_get_stats,
	122	};
	123
	124	static void do_setup(struct net_device *netdev)
	125	{
	126	ether_setup(netdev);
	127
	128	netdev->netdev_ops = &internal_dev_netdev_ops;
	129
	130	netdev->priv_flags &= ~IFF_TX_SKB_SHARING;
9151991c	131	netdev->priv_flags \|= IFF_LIVE_ADDR_CHANGE;
ccb1352e JG	132	netdev->destructor = internal_dev_destructor;
	133	SET_ETHTOOL_OPS(netdev, &internal_dev_ethtool_ops);
	134	netdev->tx_queue_len = 0;
	135
	136	netdev->features = NETIF_F_LLTX \| NETIF_F_SG \| NETIF_F_FRAGLIST \|
46df7b81	137	NETIF_F_HIGHDMA \| NETIF_F_HW_CSUM \| NETIF_F_TSO;
ccb1352e JG	138
ccb1352e JG	139	netdev->vlan_features = netdev->features;
f646968f	140	netdev->features \|= NETIF_F_HW_VLAN_CTAG_TX;
ccb1352e	141	netdev->hw_features = netdev->features & ~NETIF_F_LLTX;
7ce5d222	142	eth_hw_addr_random(netdev);
ccb1352e JG	143	}
	144
	145	static struct vport internal_dev_create(const struct vport_parms parms)
	146	{
	147	struct vport *vport;
	148	struct netdev_vport *netdev_vport;
	149	struct internal_dev *internal_dev;
	150	int err;
	151
	152	vport = ovs_vport_alloc(sizeof(struct netdev_vport),
	153	&ovs_internal_vport_ops, parms);
	154	if (IS_ERR(vport)) {
	155	err = PTR_ERR(vport);
	156	goto error;
	157	}
	158
	159	netdev_vport = netdev_vport_priv(vport);
	160
	161	netdev_vport->dev = alloc_netdev(sizeof(struct internal_dev),
	162	parms->name, do_setup);
	163	if (!netdev_vport->dev) {
	164	err = -ENOMEM;
	165	goto error_free_vport;
	166	}
	167
46df7b81	168	dev_net_set(netdev_vport->dev, ovs_dp_get_net(vport->dp));
ccb1352e JG	169	internal_dev = internal_dev_priv(netdev_vport->dev);
	170	internal_dev->vport = vport;
	171
46df7b81 PS	172	/* Restrict bridge port to current netns. */
	173	if (vport->port_no == OVSP_LOCAL)
	174	netdev_vport->dev->features \|= NETIF_F_NETNS_LOCAL;
	175
8e4e1713	176	rtnl_lock();
ccb1352e JG	177	err = register_netdevice(netdev_vport->dev);
	178	if (err)
	179	goto error_free_netdev;
	180
	181	dev_set_promiscuity(netdev_vport->dev, 1);
8e4e1713	182	rtnl_unlock();
ccb1352e JG	183	netif_start_queue(netdev_vport->dev);
	184
	185	return vport;
	186
	187	error_free_netdev:
8e4e1713	188	rtnl_unlock();
ccb1352e JG	189	free_netdev(netdev_vport->dev);
	190	error_free_vport:
	191	ovs_vport_free(vport);
	192	error:
	193	return ERR_PTR(err);
	194	}
	195
	196	static void internal_dev_destroy(struct vport *vport)
	197	{
	198	struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
	199
	200	netif_stop_queue(netdev_vport->dev);
8e4e1713	201	rtnl_lock();
ccb1352e JG	202	dev_set_promiscuity(netdev_vport->dev, -1);
	203
	204	/* unregister_netdevice() waits for an RCU grace period. */
	205	unregister_netdevice(netdev_vport->dev);
8e4e1713 PS	206
8e4e1713 PS	207	rtnl_unlock();
ccb1352e JG	208	}
	209
	210	static int internal_dev_recv(struct vport vport, struct sk_buff skb)
	211	{
	212	struct net_device *netdev = netdev_vport_priv(vport)->dev;
	213	int len;
	214
	215	len = skb->len;
7fe99e2d JG	216
	217	skb_dst_drop(skb);
	218	nf_reset(skb);
	219	secpath_reset(skb);
	220
ccb1352e JG	221	skb->dev = netdev;
	222	skb->pkt_type = PACKET_HOST;
	223	skb->protocol = eth_type_trans(skb, netdev);
	224
	225	netif_rx(skb);
	226
	227	return len;
	228	}
	229
	230	const struct vport_ops ovs_internal_vport_ops = {
	231	.type = OVS_VPORT_TYPE_INTERNAL,
	232	.create = internal_dev_create,
	233	.destroy = internal_dev_destroy,
	234	.get_name = ovs_netdev_get_name,
ccb1352e JG	235	.send = internal_dev_recv,
	236	};
	237
	238	int ovs_is_internal_dev(const struct net_device *netdev)
	239	{
	240	return netdev->netdev_ops == &internal_dev_netdev_ops;
	241	}
	242
	243	struct vport ovs_internal_dev_get_vport(struct net_device netdev)
	244	{
	245	if (!ovs_is_internal_dev(netdev))
	246	return NULL;
	247
	248	return internal_dev_priv(netdev)->vport;
	249	}