[deliverable/linux.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 <net/rtnetlink.h>

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

struct internal_dev {
	struct vport *vport;
};

static struct vport_ops ovs_internal_vport_ops;

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, NULL);
	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 struct rtnl_link_ops internal_dev_link_ops __read_mostly = {
	.kind = "openvswitch",
};

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;
	netdev->ethtool_ops = &internal_dev_ethtool_ops;
	netdev->rtnl_link_ops = &internal_dev_link_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_GSO_SOFTWARE | NETIF_F_GSO_ENCAP_ALL;

	netdev->vlan_features = netdev->features;
	netdev->hw_enc_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, NET_NAME_UNKNOWN,
					 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;

	if (unlikely(!(netdev->flags & IFF_UP))) {
		kfree_skb(skb);
		return 0;
	}

	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);
	skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

	netif_rx(skb);

	return len;
}

static 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;
}

int ovs_internal_dev_rtnl_link_register(void)
{
	int err;

	err = rtnl_link_register(&internal_dev_link_ops);
	if (err < 0)
		return err;

	err = ovs_vport_ops_register(&ovs_internal_vport_ops);
	if (err < 0)
		rtnl_link_unregister(&internal_dev_link_ops);

	return err;
}

void ovs_internal_dev_rtnl_link_unregister(void)
{
	ovs_vport_ops_unregister(&ovs_internal_vport_ops);
	rtnl_link_unregister(&internal_dev_link_ops);
}
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>
7fe99e2d JG	28	#include <net/xfrm.h>
5b9e7e16	29	#include <net/rtnetlink.h>
7fe99e2d	30
ccb1352e JG	31	#include "datapath.h"
	32	#include "vport-internal_dev.h"
	33	#include "vport-netdev.h"
	34
	35	struct internal_dev {
	36	struct vport *vport;
	37	};
	38
62b9c8d0 TG	39	static struct vport_ops ovs_internal_vport_ops;
62b9c8d0 TG	40
ccb1352e JG	41	static struct internal_dev internal_dev_priv(struct net_device netdev)
	42	{
	43	return netdev_priv(netdev);
	44	}
	45
	46	/* This function is only called by the kernel network layer.*/
	47	static struct rtnl_link_stats64 internal_dev_get_stats(struct net_device netdev,
	48	struct rtnl_link_stats64 *stats)
	49	{
	50	struct vport *vport = ovs_internal_dev_get_vport(netdev);
	51	struct ovs_vport_stats vport_stats;
	52
	53	ovs_vport_get_stats(vport, &vport_stats);
	54
	55	/* The tx and rx stats need to be swapped because the
	56	* switch and host OS have opposite perspectives. */
	57	stats->rx_packets = vport_stats.tx_packets;
	58	stats->tx_packets = vport_stats.rx_packets;
	59	stats->rx_bytes = vport_stats.tx_bytes;
	60	stats->tx_bytes = vport_stats.rx_bytes;
	61	stats->rx_errors = vport_stats.tx_errors;
	62	stats->tx_errors = vport_stats.rx_errors;
	63	stats->rx_dropped = vport_stats.tx_dropped;
	64	stats->tx_dropped = vport_stats.rx_dropped;
	65
	66	return stats;
	67	}
	68
ccb1352e JG	69	/* Called with rcu_read_lock_bh. */
	70	static int internal_dev_xmit(struct sk_buff skb, struct net_device netdev)
	71	{
	72	rcu_read_lock();
7d5437c7	73	ovs_vport_receive(internal_dev_priv(netdev)->vport, skb, NULL);
ccb1352e JG	74	rcu_read_unlock();
	75	return 0;
	76	}
	77
	78	static int internal_dev_open(struct net_device *netdev)
	79	{
	80	netif_start_queue(netdev);
	81	return 0;
	82	}
	83
	84	static int internal_dev_stop(struct net_device *netdev)
	85	{
	86	netif_stop_queue(netdev);
	87	return 0;
	88	}
	89
	90	static void internal_dev_getinfo(struct net_device *netdev,
	91	struct ethtool_drvinfo *info)
	92	{
7826d43f	93	strlcpy(info->driver, "openvswitch", sizeof(info->driver));
ccb1352e JG	94	}
	95
	96	static const struct ethtool_ops internal_dev_ethtool_ops = {
	97	.get_drvinfo = internal_dev_getinfo,
	98	.get_link = ethtool_op_get_link,
	99	};
	100
	101	static int internal_dev_change_mtu(struct net_device *netdev, int new_mtu)
	102	{
	103	if (new_mtu < 68)
	104	return -EINVAL;
	105
	106	netdev->mtu = new_mtu;
	107	return 0;
	108	}
	109
	110	static void internal_dev_destructor(struct net_device *dev)
	111	{
	112	struct vport *vport = ovs_internal_dev_get_vport(dev);
	113
	114	ovs_vport_free(vport);
	115	free_netdev(dev);
	116	}
	117
	118	static const struct net_device_ops internal_dev_netdev_ops = {
	119	.ndo_open = internal_dev_open,
	120	.ndo_stop = internal_dev_stop,
	121	.ndo_start_xmit = internal_dev_xmit,
9151991c	122	.ndo_set_mac_address = eth_mac_addr,
ccb1352e JG	123	.ndo_change_mtu = internal_dev_change_mtu,
	124	.ndo_get_stats64 = internal_dev_get_stats,
	125	};
	126
5b9e7e16 JP	127	static struct rtnl_link_ops internal_dev_link_ops __read_mostly = {
	128	.kind = "openvswitch",
	129	};
	130
ccb1352e JG	131	static void do_setup(struct net_device *netdev)
	132	{
	133	ether_setup(netdev);
	134
	135	netdev->netdev_ops = &internal_dev_netdev_ops;
	136
	137	netdev->priv_flags &= ~IFF_TX_SKB_SHARING;
9151991c	138	netdev->priv_flags \|= IFF_LIVE_ADDR_CHANGE;
ccb1352e	139	netdev->destructor = internal_dev_destructor;
7ad24ea4	140	netdev->ethtool_ops = &internal_dev_ethtool_ops;
5b9e7e16	141	netdev->rtnl_link_ops = &internal_dev_link_ops;
ccb1352e JG	142	netdev->tx_queue_len = 0;
	143
	144	netdev->features = NETIF_F_LLTX \| NETIF_F_SG \| NETIF_F_FRAGLIST \|
f6eec614 PS	145	NETIF_F_HIGHDMA \| NETIF_F_HW_CSUM \|
f6eec614 PS	146	NETIF_F_GSO_SOFTWARE \| NETIF_F_GSO_ENCAP_ALL;
ccb1352e JG	147
ccb1352e JG	148	netdev->vlan_features = netdev->features;
f6eec614	149	netdev->hw_enc_features = netdev->features;
f646968f	150	netdev->features \|= NETIF_F_HW_VLAN_CTAG_TX;
ccb1352e	151	netdev->hw_features = netdev->features & ~NETIF_F_LLTX;
f6eec614	152
7ce5d222	153	eth_hw_addr_random(netdev);
ccb1352e JG	154	}
	155
	156	static struct vport internal_dev_create(const struct vport_parms parms)
	157	{
	158	struct vport *vport;
	159	struct netdev_vport *netdev_vport;
	160	struct internal_dev *internal_dev;
	161	int err;
	162
	163	vport = ovs_vport_alloc(sizeof(struct netdev_vport),
	164	&ovs_internal_vport_ops, parms);
	165	if (IS_ERR(vport)) {
	166	err = PTR_ERR(vport);
	167	goto error;
	168	}
	169
	170	netdev_vport = netdev_vport_priv(vport);
	171
	172	netdev_vport->dev = alloc_netdev(sizeof(struct internal_dev),
c835a677 TG	173	parms->name, NET_NAME_UNKNOWN,
c835a677 TG	174	do_setup);
ccb1352e JG	175	if (!netdev_vport->dev) {
	176	err = -ENOMEM;
	177	goto error_free_vport;
	178	}
	179
46df7b81	180	dev_net_set(netdev_vport->dev, ovs_dp_get_net(vport->dp));
ccb1352e JG	181	internal_dev = internal_dev_priv(netdev_vport->dev);
	182	internal_dev->vport = vport;
	183
46df7b81 PS	184	/* Restrict bridge port to current netns. */
	185	if (vport->port_no == OVSP_LOCAL)
	186	netdev_vport->dev->features \|= NETIF_F_NETNS_LOCAL;
	187
8e4e1713	188	rtnl_lock();
ccb1352e JG	189	err = register_netdevice(netdev_vport->dev);
	190	if (err)
	191	goto error_free_netdev;
	192
	193	dev_set_promiscuity(netdev_vport->dev, 1);
8e4e1713	194	rtnl_unlock();
ccb1352e JG	195	netif_start_queue(netdev_vport->dev);
	196
	197	return vport;
	198
	199	error_free_netdev:
8e4e1713	200	rtnl_unlock();
ccb1352e JG	201	free_netdev(netdev_vport->dev);
	202	error_free_vport:
	203	ovs_vport_free(vport);
	204	error:
	205	return ERR_PTR(err);
	206	}
	207
	208	static void internal_dev_destroy(struct vport *vport)
	209	{
	210	struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
	211
	212	netif_stop_queue(netdev_vport->dev);
8e4e1713	213	rtnl_lock();
ccb1352e JG	214	dev_set_promiscuity(netdev_vport->dev, -1);
	215
	216	/* unregister_netdevice() waits for an RCU grace period. */
	217	unregister_netdevice(netdev_vport->dev);
8e4e1713 PS	218
8e4e1713 PS	219	rtnl_unlock();
ccb1352e JG	220	}
	221
	222	static int internal_dev_recv(struct vport vport, struct sk_buff skb)
	223	{
	224	struct net_device *netdev = netdev_vport_priv(vport)->dev;
	225	int len;
	226
e1f9c356 CL	227	if (unlikely(!(netdev->flags & IFF_UP))) {
	228	kfree_skb(skb);
	229	return 0;
	230	}
	231
ccb1352e	232	len = skb->len;
7fe99e2d JG	233
	234	skb_dst_drop(skb);
	235	nf_reset(skb);
	236	secpath_reset(skb);
	237
ccb1352e JG	238	skb->dev = netdev;
	239	skb->pkt_type = PACKET_HOST;
	240	skb->protocol = eth_type_trans(skb, netdev);
b34df5e8	241	skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
ccb1352e JG	242
	243	netif_rx(skb);
	244
	245	return len;
	246	}
	247
62b9c8d0	248	static struct vport_ops ovs_internal_vport_ops = {
ccb1352e JG	249	.type = OVS_VPORT_TYPE_INTERNAL,
	250	.create = internal_dev_create,
	251	.destroy = internal_dev_destroy,
	252	.get_name = ovs_netdev_get_name,
ccb1352e JG	253	.send = internal_dev_recv,
	254	};
	255
	256	int ovs_is_internal_dev(const struct net_device *netdev)
	257	{
	258	return netdev->netdev_ops == &internal_dev_netdev_ops;
	259	}
	260
	261	struct vport ovs_internal_dev_get_vport(struct net_device netdev)
	262	{
	263	if (!ovs_is_internal_dev(netdev))
	264	return NULL;
	265
	266	return internal_dev_priv(netdev)->vport;
	267	}
5b9e7e16 JP	268
	269	int ovs_internal_dev_rtnl_link_register(void)
	270	{
62b9c8d0 TG	271	int err;
	272
	273	err = rtnl_link_register(&internal_dev_link_ops);
	274	if (err < 0)
	275	return err;
	276
	277	err = ovs_vport_ops_register(&ovs_internal_vport_ops);
	278	if (err < 0)
	279	rtnl_link_unregister(&internal_dev_link_ops);
	280
	281	return err;
5b9e7e16 JP	282	}
	283
	284	void ovs_internal_dev_rtnl_link_unregister(void)
	285	{
62b9c8d0	286	ovs_vport_ops_unregister(&ovs_internal_vport_ops);
5b9e7e16 JP	287	rtnl_link_unregister(&internal_dev_link_ops);
5b9e7e16 JP	288	}