[linux-2.6-block.git] / drivers / net / vrf.c

/*
 * vrf.c: device driver to encapsulate a VRF space
 *
 * Copyright (c) 2015 Cumulus Networks. All rights reserved.
 * Copyright (c) 2015 Shrijeet Mukherjee <shm@cumulusnetworks.com>
 * Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
 *
 * Based on dummy, team and ipvlan drivers
 *
 * 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 <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ip.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/netfilter.h>
#include <linux/rtnetlink.h>
#include <net/rtnetlink.h>
#include <linux/u64_stats_sync.h>
#include <linux/hashtable.h>

#include <linux/inetdevice.h>
#include <net/arp.h>
#include <net/ip.h>
#include <net/ip_fib.h>
#include <net/ip6_route.h>
#include <net/rtnetlink.h>
#include <net/route.h>
#include <net/addrconf.h>
#include <net/l3mdev.h>

#define RT_FL_TOS(oldflp4) \
	((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))

#define DRV_NAME	"vrf"
#define DRV_VERSION	"1.0"

#define vrf_master_get_rcu(dev) \
	((struct net_device *)rcu_dereference(dev->rx_handler_data))

struct slave {
	struct list_head        list;
	struct net_device       *dev;
};

struct slave_queue {
	struct list_head        all_slaves;
};

struct net_vrf {
	struct slave_queue      queue;
	struct rtable           *rth;
	u32                     tb_id;
};

struct pcpu_dstats {
	u64			tx_pkts;
	u64			tx_bytes;
	u64			tx_drps;
	u64			rx_pkts;
	u64			rx_bytes;
	struct u64_stats_sync	syncp;
};

static struct dst_entry *vrf_ip_check(struct dst_entry *dst, u32 cookie)
{
	return dst;
}

static int vrf_ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	return ip_local_out(net, sk, skb);
}

static unsigned int vrf_v4_mtu(const struct dst_entry *dst)
{
	/* TO-DO: return max ethernet size? */
	return dst->dev->mtu;
}

static void vrf_dst_destroy(struct dst_entry *dst)
{
	/* our dst lives forever - or until the device is closed */
}

static unsigned int vrf_default_advmss(const struct dst_entry *dst)
{
	return 65535 - 40;
}

static struct dst_ops vrf_dst_ops = {
	.family		= AF_INET,
	.local_out	= vrf_ip_local_out,
	.check		= vrf_ip_check,
	.mtu		= vrf_v4_mtu,
	.destroy	= vrf_dst_destroy,
	.default_advmss	= vrf_default_advmss,
};

static bool is_ip_rx_frame(struct sk_buff *skb)
{
	switch (skb->protocol) {
	case htons(ETH_P_IP):
	case htons(ETH_P_IPV6):
		return true;
	}
	return false;
}

static void vrf_tx_error(struct net_device *vrf_dev, struct sk_buff *skb)
{
	vrf_dev->stats.tx_errors++;
	kfree_skb(skb);
}

/* note: already called with rcu_read_lock */
static rx_handler_result_t vrf_handle_frame(struct sk_buff **pskb)
{
	struct sk_buff *skb = *pskb;

	if (is_ip_rx_frame(skb)) {
		struct net_device *dev = vrf_master_get_rcu(skb->dev);
		struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);

		u64_stats_update_begin(&dstats->syncp);
		dstats->rx_pkts++;
		dstats->rx_bytes += skb->len;
		u64_stats_update_end(&dstats->syncp);

		skb->dev = dev;

		return RX_HANDLER_ANOTHER;
	}
	return RX_HANDLER_PASS;
}

static struct rtnl_link_stats64 *vrf_get_stats64(struct net_device *dev,
						 struct rtnl_link_stats64 *stats)
{
	int i;

	for_each_possible_cpu(i) {
		const struct pcpu_dstats *dstats;
		u64 tbytes, tpkts, tdrops, rbytes, rpkts;
		unsigned int start;

		dstats = per_cpu_ptr(dev->dstats, i);
		do {
			start = u64_stats_fetch_begin_irq(&dstats->syncp);
			tbytes = dstats->tx_bytes;
			tpkts = dstats->tx_pkts;
			tdrops = dstats->tx_drps;
			rbytes = dstats->rx_bytes;
			rpkts = dstats->rx_pkts;
		} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
		stats->tx_bytes += tbytes;
		stats->tx_packets += tpkts;
		stats->tx_dropped += tdrops;
		stats->rx_bytes += rbytes;
		stats->rx_packets += rpkts;
	}
	return stats;
}

static netdev_tx_t vrf_process_v6_outbound(struct sk_buff *skb,
					   struct net_device *dev)
{
	vrf_tx_error(dev, skb);
	return NET_XMIT_DROP;
}

static int vrf_send_v4_prep(struct sk_buff *skb, struct flowi4 *fl4,
			    struct net_device *vrf_dev)
{
	struct rtable *rt;
	int err = 1;

	rt = ip_route_output_flow(dev_net(vrf_dev), fl4, NULL);
	if (IS_ERR(rt))
		goto out;

	/* TO-DO: what about broadcast ? */
	if (rt->rt_type != RTN_UNICAST && rt->rt_type != RTN_LOCAL) {
		ip_rt_put(rt);
		goto out;
	}

	skb_dst_drop(skb);
	skb_dst_set(skb, &rt->dst);
	err = 0;
out:
	return err;
}

static netdev_tx_t vrf_process_v4_outbound(struct sk_buff *skb,
					   struct net_device *vrf_dev)
{
	struct iphdr *ip4h = ip_hdr(skb);
	int ret = NET_XMIT_DROP;
	struct flowi4 fl4 = {
		/* needed to match OIF rule */
		.flowi4_oif = vrf_dev->ifindex,
		.flowi4_iif = LOOPBACK_IFINDEX,
		.flowi4_tos = RT_TOS(ip4h->tos),
		.flowi4_flags = FLOWI_FLAG_ANYSRC | FLOWI_FLAG_L3MDEV_SRC |
				FLOWI_FLAG_SKIP_NH_OIF,
		.daddr = ip4h->daddr,
	};

	if (vrf_send_v4_prep(skb, &fl4, vrf_dev))
		goto err;

	if (!ip4h->saddr) {
		ip4h->saddr = inet_select_addr(skb_dst(skb)->dev, 0,
					       RT_SCOPE_LINK);
	}

	ret = ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
	if (unlikely(net_xmit_eval(ret)))
		vrf_dev->stats.tx_errors++;
	else
		ret = NET_XMIT_SUCCESS;

out:
	return ret;
err:
	vrf_tx_error(vrf_dev, skb);
	goto out;
}

static netdev_tx_t is_ip_tx_frame(struct sk_buff *skb, struct net_device *dev)
{
	/* strip the ethernet header added for pass through VRF device */
	__skb_pull(skb, skb_network_offset(skb));

	switch (skb->protocol) {
	case htons(ETH_P_IP):
		return vrf_process_v4_outbound(skb, dev);
	case htons(ETH_P_IPV6):
		return vrf_process_v6_outbound(skb, dev);
	default:
		vrf_tx_error(dev, skb);
		return NET_XMIT_DROP;
	}
}

static netdev_tx_t vrf_xmit(struct sk_buff *skb, struct net_device *dev)
{
	netdev_tx_t ret = is_ip_tx_frame(skb, dev);

	if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
		struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);

		u64_stats_update_begin(&dstats->syncp);
		dstats->tx_pkts++;
		dstats->tx_bytes += skb->len;
		u64_stats_update_end(&dstats->syncp);
	} else {
		this_cpu_inc(dev->dstats->tx_drps);
	}

	return ret;
}

/* modelled after ip_finish_output2 */
static int vrf_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	struct dst_entry *dst = skb_dst(skb);
	struct rtable *rt = (struct rtable *)dst;
	struct net_device *dev = dst->dev;
	unsigned int hh_len = LL_RESERVED_SPACE(dev);
	struct neighbour *neigh;
	u32 nexthop;
	int ret = -EINVAL;

	/* Be paranoid, rather than too clever. */
	if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
		struct sk_buff *skb2;

		skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
		if (!skb2) {
			ret = -ENOMEM;
			goto err;
		}
		if (skb->sk)
			skb_set_owner_w(skb2, skb->sk);

		consume_skb(skb);
		skb = skb2;
	}

	rcu_read_lock_bh();

	nexthop = (__force u32)rt_nexthop(rt, ip_hdr(skb)->daddr);
	neigh = __ipv4_neigh_lookup_noref(dev, nexthop);
	if (unlikely(!neigh))
		neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);
	if (!IS_ERR(neigh))
		ret = dst_neigh_output(dst, neigh, skb);

	rcu_read_unlock_bh();
err:
	if (unlikely(ret < 0))
		vrf_tx_error(skb->dev, skb);
	return ret;
}

static int vrf_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	struct net_device *dev = skb_dst(skb)->dev;

	IP_UPD_PO_STATS(net, IPSTATS_MIB_OUT, skb->len);

	skb->dev = dev;
	skb->protocol = htons(ETH_P_IP);

	return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
			    net, sk, skb, NULL, dev,
			    vrf_finish_output,
			    !(IPCB(skb)->flags & IPSKB_REROUTED));
}

static void vrf_rtable_destroy(struct net_vrf *vrf)
{
	struct dst_entry *dst = (struct dst_entry *)vrf->rth;

	dst_destroy(dst);
	vrf->rth = NULL;
}

static struct rtable *vrf_rtable_create(struct net_device *dev)
{
	struct net_vrf *vrf = netdev_priv(dev);
	struct rtable *rth;

	rth = dst_alloc(&vrf_dst_ops, dev, 2,
			DST_OBSOLETE_NONE,
			(DST_HOST | DST_NOPOLICY | DST_NOXFRM));
	if (rth) {
		rth->dst.output	= vrf_output;
		rth->rt_genid	= rt_genid_ipv4(dev_net(dev));
		rth->rt_flags	= 0;
		rth->rt_type	= RTN_UNICAST;
		rth->rt_is_input = 0;
		rth->rt_iif	= 0;
		rth->rt_pmtu	= 0;
		rth->rt_gateway	= 0;
		rth->rt_uses_gateway = 0;
		rth->rt_table_id = vrf->tb_id;
		INIT_LIST_HEAD(&rth->rt_uncached);
		rth->rt_uncached_list = NULL;
	}

	return rth;
}

/**************************** device handling ********************/

/* cycle interface to flush neighbor cache and move routes across tables */
static void cycle_netdev(struct net_device *dev)
{
	unsigned int flags = dev->flags;
	int ret;

	if (!netif_running(dev))
		return;

	ret = dev_change_flags(dev, flags & ~IFF_UP);
	if (ret >= 0)
		ret = dev_change_flags(dev, flags);

	if (ret < 0) {
		netdev_err(dev,
			   "Failed to cycle device %s; route tables might be wrong!\n",
			   dev->name);
	}
}

static struct slave *__vrf_find_slave_dev(struct slave_queue *queue,
					  struct net_device *dev)
{
	struct list_head *head = &queue->all_slaves;
	struct slave *slave;

	list_for_each_entry(slave, head, list) {
		if (slave->dev == dev)
			return slave;
	}

	return NULL;
}

/* inverse of __vrf_insert_slave */
static void __vrf_remove_slave(struct slave_queue *queue, struct slave *slave)
{
	list_del(&slave->list);
}

static void __vrf_insert_slave(struct slave_queue *queue, struct slave *slave)
{
	list_add(&slave->list, &queue->all_slaves);
}

static int do_vrf_add_slave(struct net_device *dev, struct net_device *port_dev)
{
	struct slave *slave = kzalloc(sizeof(*slave), GFP_KERNEL);
	struct net_vrf *vrf = netdev_priv(dev);
	struct slave_queue *queue = &vrf->queue;
	int ret = -ENOMEM;

	if (!slave)
		goto out_fail;

	slave->dev = port_dev;

	/* register the packet handler for slave ports */
	ret = netdev_rx_handler_register(port_dev, vrf_handle_frame, dev);
	if (ret) {
		netdev_err(port_dev,
			   "Device %s failed to register rx_handler\n",
			   port_dev->name);
		goto out_fail;
	}

	ret = netdev_master_upper_dev_link(port_dev, dev);
	if (ret < 0)
		goto out_unregister;

	port_dev->priv_flags |= IFF_L3MDEV_SLAVE;
	__vrf_insert_slave(queue, slave);
	cycle_netdev(port_dev);

	return 0;

out_unregister:
	netdev_rx_handler_unregister(port_dev);
out_fail:
	kfree(slave);
	return ret;
}

static int vrf_add_slave(struct net_device *dev, struct net_device *port_dev)
{
	if (netif_is_l3_master(port_dev) || netif_is_l3_slave(port_dev))
		return -EINVAL;

	return do_vrf_add_slave(dev, port_dev);
}

/* inverse of do_vrf_add_slave */
static int do_vrf_del_slave(struct net_device *dev, struct net_device *port_dev)
{
	struct net_vrf *vrf = netdev_priv(dev);
	struct slave_queue *queue = &vrf->queue;
	struct slave *slave;

	netdev_upper_dev_unlink(port_dev, dev);
	port_dev->priv_flags &= ~IFF_L3MDEV_SLAVE;

	netdev_rx_handler_unregister(port_dev);

	cycle_netdev(port_dev);

	slave = __vrf_find_slave_dev(queue, port_dev);
	if (slave)
		__vrf_remove_slave(queue, slave);

	kfree(slave);

	return 0;
}

static int vrf_del_slave(struct net_device *dev, struct net_device *port_dev)
{
	return do_vrf_del_slave(dev, port_dev);
}

static void vrf_dev_uninit(struct net_device *dev)
{
	struct net_vrf *vrf = netdev_priv(dev);
	struct slave_queue *queue = &vrf->queue;
	struct list_head *head = &queue->all_slaves;
	struct slave *slave, *next;

	vrf_rtable_destroy(vrf);

	list_for_each_entry_safe(slave, next, head, list)
		vrf_del_slave(dev, slave->dev);

	free_percpu(dev->dstats);
	dev->dstats = NULL;
}

static int vrf_dev_init(struct net_device *dev)
{
	struct net_vrf *vrf = netdev_priv(dev);

	INIT_LIST_HEAD(&vrf->queue.all_slaves);

	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
	if (!dev->dstats)
		goto out_nomem;

	/* create the default dst which points back to us */
	vrf->rth = vrf_rtable_create(dev);
	if (!vrf->rth)
		goto out_stats;

	dev->flags = IFF_MASTER | IFF_NOARP;

	return 0;

out_stats:
	free_percpu(dev->dstats);
	dev->dstats = NULL;
out_nomem:
	return -ENOMEM;
}

static const struct net_device_ops vrf_netdev_ops = {
	.ndo_init		= vrf_dev_init,
	.ndo_uninit		= vrf_dev_uninit,
	.ndo_start_xmit		= vrf_xmit,
	.ndo_get_stats64	= vrf_get_stats64,
	.ndo_add_slave		= vrf_add_slave,
	.ndo_del_slave		= vrf_del_slave,
};

static u32 vrf_fib_table(const struct net_device *dev)
{
	struct net_vrf *vrf = netdev_priv(dev);

	return vrf->tb_id;
}

static struct rtable *vrf_get_rtable(const struct net_device *dev,
				     const struct flowi4 *fl4)
{
	struct rtable *rth = NULL;

	if (!(fl4->flowi4_flags & FLOWI_FLAG_L3MDEV_SRC)) {
		struct net_vrf *vrf = netdev_priv(dev);

		rth = vrf->rth;
		atomic_inc(&rth->dst.__refcnt);
	}

	return rth;
}

/* called under rcu_read_lock */
static void vrf_get_saddr(struct net_device *dev, struct flowi4 *fl4)
{
	struct fib_result res = { .tclassid = 0 };
	struct net *net = dev_net(dev);
	u32 orig_tos = fl4->flowi4_tos;
	u8 flags = fl4->flowi4_flags;
	u8 scope = fl4->flowi4_scope;
	u8 tos = RT_FL_TOS(fl4);

	if (unlikely(!fl4->daddr))
		return;

	fl4->flowi4_flags |= FLOWI_FLAG_SKIP_NH_OIF;
	fl4->flowi4_iif = LOOPBACK_IFINDEX;
	fl4->flowi4_tos = tos & IPTOS_RT_MASK;
	fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
			     RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);

	if (!fib_lookup(net, fl4, &res, 0)) {
		if (res.type == RTN_LOCAL)
			fl4->saddr = res.fi->fib_prefsrc ? : fl4->daddr;
		else
			fib_select_path(net, &res, fl4, -1);
	}

	fl4->flowi4_flags = flags;
	fl4->flowi4_tos = orig_tos;
	fl4->flowi4_scope = scope;
}

static const struct l3mdev_ops vrf_l3mdev_ops = {
	.l3mdev_fib_table	= vrf_fib_table,
	.l3mdev_get_rtable	= vrf_get_rtable,
	.l3mdev_get_saddr	= vrf_get_saddr,
};

static void vrf_get_drvinfo(struct net_device *dev,
			    struct ethtool_drvinfo *info)
{
	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
}

static const struct ethtool_ops vrf_ethtool_ops = {
	.get_drvinfo	= vrf_get_drvinfo,
};

static void vrf_setup(struct net_device *dev)
{
	ether_setup(dev);

	/* Initialize the device structure. */
	dev->netdev_ops = &vrf_netdev_ops;
	dev->l3mdev_ops = &vrf_l3mdev_ops;
	dev->ethtool_ops = &vrf_ethtool_ops;
	dev->destructor = free_netdev;

	/* Fill in device structure with ethernet-generic values. */
	eth_hw_addr_random(dev);

	/* don't acquire vrf device's netif_tx_lock when transmitting */
	dev->features |= NETIF_F_LLTX;

	/* don't allow vrf devices to change network namespaces. */
	dev->features |= NETIF_F_NETNS_LOCAL;
}

static int vrf_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
	return 0;
}

static void vrf_dellink(struct net_device *dev, struct list_head *head)
{
	unregister_netdevice_queue(dev, head);
}

static int vrf_newlink(struct net *src_net, struct net_device *dev,
		       struct nlattr *tb[], struct nlattr *data[])
{
	struct net_vrf *vrf = netdev_priv(dev);
	int err;

	if (!data || !data[IFLA_VRF_TABLE])
		return -EINVAL;

	vrf->tb_id = nla_get_u32(data[IFLA_VRF_TABLE]);

	dev->priv_flags |= IFF_L3MDEV_MASTER;

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

	return 0;

out_fail:
	free_netdev(dev);
	return err;
}

static size_t vrf_nl_getsize(const struct net_device *dev)
{
	return nla_total_size(sizeof(u32));  /* IFLA_VRF_TABLE */
}

static int vrf_fillinfo(struct sk_buff *skb,
			const struct net_device *dev)
{
	struct net_vrf *vrf = netdev_priv(dev);

	return nla_put_u32(skb, IFLA_VRF_TABLE, vrf->tb_id);
}

static const struct nla_policy vrf_nl_policy[IFLA_VRF_MAX + 1] = {
	[IFLA_VRF_TABLE] = { .type = NLA_U32 },
};

static struct rtnl_link_ops vrf_link_ops __read_mostly = {
	.kind		= DRV_NAME,
	.priv_size	= sizeof(struct net_vrf),

	.get_size	= vrf_nl_getsize,
	.policy		= vrf_nl_policy,
	.validate	= vrf_validate,
	.fill_info	= vrf_fillinfo,

	.newlink	= vrf_newlink,
	.dellink	= vrf_dellink,
	.setup		= vrf_setup,
	.maxtype	= IFLA_VRF_MAX,
};

static int vrf_device_event(struct notifier_block *unused,
			    unsigned long event, void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);

	/* only care about unregister events to drop slave references */
	if (event == NETDEV_UNREGISTER) {
		struct net_device *vrf_dev;

		if (!netif_is_l3_slave(dev))
			goto out;

		vrf_dev = netdev_master_upper_dev_get(dev);
		vrf_del_slave(vrf_dev, dev);
	}
out:
	return NOTIFY_DONE;
}

static struct notifier_block vrf_notifier_block __read_mostly = {
	.notifier_call = vrf_device_event,
};

static int __init vrf_init_module(void)
{
	int rc;

	vrf_dst_ops.kmem_cachep =
		kmem_cache_create("vrf_ip_dst_cache",
				  sizeof(struct rtable), 0,
				  SLAB_HWCACHE_ALIGN,
				  NULL);

	if (!vrf_dst_ops.kmem_cachep)
		return -ENOMEM;

	register_netdevice_notifier(&vrf_notifier_block);

	rc = rtnl_link_register(&vrf_link_ops);
	if (rc < 0)
		goto error;

	return 0;

error:
	unregister_netdevice_notifier(&vrf_notifier_block);
	kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
	return rc;
}

static void __exit vrf_cleanup_module(void)
{
	rtnl_link_unregister(&vrf_link_ops);
	unregister_netdevice_notifier(&vrf_notifier_block);
	kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
}

module_init(vrf_init_module);
module_exit(vrf_cleanup_module);
MODULE_AUTHOR("Shrijeet Mukherjee, David Ahern");
MODULE_DESCRIPTION("Device driver to instantiate VRF domains");
MODULE_LICENSE("GPL");
MODULE_ALIAS_RTNL_LINK(DRV_NAME);
MODULE_VERSION(DRV_VERSION);
Commit	Line	Data
193125db DA	1	/*
	2	* vrf.c: device driver to encapsulate a VRF space
	3	*
	4	* Copyright (c) 2015 Cumulus Networks. All rights reserved.
	5	* Copyright (c) 2015 Shrijeet Mukherjee <shm@cumulusnetworks.com>
	6	* Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
	7	*
	8	* Based on dummy, team and ipvlan drivers
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*/
	15
	16	#include <linux/module.h>
	17	#include <linux/kernel.h>
	18	#include <linux/netdevice.h>
	19	#include <linux/etherdevice.h>
	20	#include <linux/ip.h>
	21	#include <linux/init.h>
	22	#include <linux/moduleparam.h>
	23	#include <linux/netfilter.h>
	24	#include <linux/rtnetlink.h>
	25	#include <net/rtnetlink.h>
	26	#include <linux/u64_stats_sync.h>
	27	#include <linux/hashtable.h>
	28
	29	#include <linux/inetdevice.h>
8f58336d	30	#include <net/arp.h>
193125db DA	31	#include <net/ip.h>
	32	#include <net/ip_fib.h>
	33	#include <net/ip6_route.h>
	34	#include <net/rtnetlink.h>
	35	#include <net/route.h>
	36	#include <net/addrconf.h>
ee15ee5d	37	#include <net/l3mdev.h>
193125db	38
8cbb512c DA	39	#define RT_FL_TOS(oldflp4) \
	40	((oldflp4)->flowi4_tos & (IPTOS_RT_MASK \| RTO_ONLINK))
	41
193125db DA	42	#define DRV_NAME "vrf"
	43	#define DRV_VERSION "1.0"
	44
193125db DA	45	#define vrf_master_get_rcu(dev) \
	46	((struct net_device *)rcu_dereference(dev->rx_handler_data))
	47
ec539514 DA	48	struct slave {
	49	struct list_head list;
	50	struct net_device *dev;
	51	};
	52
	53	struct slave_queue {
	54	struct list_head all_slaves;
	55	};
	56
	57	struct net_vrf {
	58	struct slave_queue queue;
	59	struct rtable *rth;
	60	u32 tb_id;
	61	};
	62
193125db DA	63	struct pcpu_dstats {
	64	u64 tx_pkts;
	65	u64 tx_bytes;
	66	u64 tx_drps;
	67	u64 rx_pkts;
	68	u64 rx_bytes;
	69	struct u64_stats_sync syncp;
	70	};
	71
	72	static struct dst_entry vrf_ip_check(struct dst_entry dst, u32 cookie)
	73	{
	74	return dst;
	75	}
	76
cf91a99d	77	static int vrf_ip_local_out(struct net net, struct sock sk, struct sk_buff *skb)
193125db	78	{
33224b16	79	return ip_local_out(net, sk, skb);
193125db DA	80	}
	81
	82	static unsigned int vrf_v4_mtu(const struct dst_entry *dst)
	83	{
	84	/* TO-DO: return max ethernet size? */
	85	return dst->dev->mtu;
	86	}
	87
	88	static void vrf_dst_destroy(struct dst_entry *dst)
	89	{
	90	/* our dst lives forever - or until the device is closed */
	91	}
	92
	93	static unsigned int vrf_default_advmss(const struct dst_entry *dst)
	94	{
	95	return 65535 - 40;
	96	}
	97
	98	static struct dst_ops vrf_dst_ops = {
	99	.family = AF_INET,
	100	.local_out = vrf_ip_local_out,
	101	.check = vrf_ip_check,
	102	.mtu = vrf_v4_mtu,
	103	.destroy = vrf_dst_destroy,
	104	.default_advmss = vrf_default_advmss,
	105	};
	106
	107	static bool is_ip_rx_frame(struct sk_buff *skb)
	108	{
	109	switch (skb->protocol) {
	110	case htons(ETH_P_IP):
	111	case htons(ETH_P_IPV6):
	112	return true;
	113	}
	114	return false;
	115	}
	116
57b8efa1 NA	117	static void vrf_tx_error(struct net_device vrf_dev, struct sk_buff skb)
	118	{
	119	vrf_dev->stats.tx_errors++;
	120	kfree_skb(skb);
	121	}
	122
193125db DA	123	/* note: already called with rcu_read_lock */
	124	static rx_handler_result_t vrf_handle_frame(struct sk_buff **pskb)
	125	{
	126	struct sk_buff skb = pskb;
	127
	128	if (is_ip_rx_frame(skb)) {
	129	struct net_device *dev = vrf_master_get_rcu(skb->dev);
	130	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
	131
	132	u64_stats_update_begin(&dstats->syncp);
	133	dstats->rx_pkts++;
	134	dstats->rx_bytes += skb->len;
	135	u64_stats_update_end(&dstats->syncp);
	136
	137	skb->dev = dev;
	138
	139	return RX_HANDLER_ANOTHER;
	140	}
	141	return RX_HANDLER_PASS;
	142	}
	143
	144	static struct rtnl_link_stats64 vrf_get_stats64(struct net_device dev,
	145	struct rtnl_link_stats64 *stats)
	146	{
	147	int i;
	148
	149	for_each_possible_cpu(i) {
	150	const struct pcpu_dstats *dstats;
	151	u64 tbytes, tpkts, tdrops, rbytes, rpkts;
	152	unsigned int start;
	153
	154	dstats = per_cpu_ptr(dev->dstats, i);
	155	do {
	156	start = u64_stats_fetch_begin_irq(&dstats->syncp);
	157	tbytes = dstats->tx_bytes;
	158	tpkts = dstats->tx_pkts;
	159	tdrops = dstats->tx_drps;
	160	rbytes = dstats->rx_bytes;
	161	rpkts = dstats->rx_pkts;
	162	} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
	163	stats->tx_bytes += tbytes;
	164	stats->tx_packets += tpkts;
	165	stats->tx_dropped += tdrops;
	166	stats->rx_bytes += rbytes;
	167	stats->rx_packets += rpkts;
	168	}
	169	return stats;
	170	}
	171
	172	static netdev_tx_t vrf_process_v6_outbound(struct sk_buff *skb,
	173	struct net_device *dev)
	174	{
57b8efa1 NA	175	vrf_tx_error(dev, skb);
57b8efa1 NA	176	return NET_XMIT_DROP;
193125db DA	177	}
	178
	179	static int vrf_send_v4_prep(struct sk_buff skb, struct flowi4 fl4,
	180	struct net_device *vrf_dev)
	181	{
	182	struct rtable *rt;
	183	int err = 1;
	184
	185	rt = ip_route_output_flow(dev_net(vrf_dev), fl4, NULL);
	186	if (IS_ERR(rt))
	187	goto out;
	188
	189	/* TO-DO: what about broadcast ? */
	190	if (rt->rt_type != RTN_UNICAST && rt->rt_type != RTN_LOCAL) {
	191	ip_rt_put(rt);
	192	goto out;
	193	}
	194
	195	skb_dst_drop(skb);
	196	skb_dst_set(skb, &rt->dst);
	197	err = 0;
	198	out:
	199	return err;
	200	}
	201
	202	static netdev_tx_t vrf_process_v4_outbound(struct sk_buff *skb,
	203	struct net_device *vrf_dev)
	204	{
	205	struct iphdr *ip4h = ip_hdr(skb);
	206	int ret = NET_XMIT_DROP;
	207	struct flowi4 fl4 = {
	208	/* needed to match OIF rule */
	209	.flowi4_oif = vrf_dev->ifindex,
	210	.flowi4_iif = LOOPBACK_IFINDEX,
	211	.flowi4_tos = RT_TOS(ip4h->tos),
6e2895a8	212	.flowi4_flags = FLOWI_FLAG_ANYSRC \| FLOWI_FLAG_L3MDEV_SRC \|
58189ca7	213	FLOWI_FLAG_SKIP_NH_OIF,
193125db DA	214	.daddr = ip4h->daddr,
	215	};
	216
	217	if (vrf_send_v4_prep(skb, &fl4, vrf_dev))
	218	goto err;
	219
	220	if (!ip4h->saddr) {
	221	ip4h->saddr = inet_select_addr(skb_dst(skb)->dev, 0,
	222	RT_SCOPE_LINK);
	223	}
	224
33224b16	225	ret = ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
193125db DA	226	if (unlikely(net_xmit_eval(ret)))
	227	vrf_dev->stats.tx_errors++;
	228	else
	229	ret = NET_XMIT_SUCCESS;
	230
	231	out:
	232	return ret;
	233	err:
57b8efa1	234	vrf_tx_error(vrf_dev, skb);
193125db DA	235	goto out;
	236	}
	237
	238	static netdev_tx_t is_ip_tx_frame(struct sk_buff skb, struct net_device dev)
	239	{
8f58336d DA	240	/* strip the ethernet header added for pass through VRF device */
	241	__skb_pull(skb, skb_network_offset(skb));
	242
193125db DA	243	switch (skb->protocol) {
	244	case htons(ETH_P_IP):
	245	return vrf_process_v4_outbound(skb, dev);
	246	case htons(ETH_P_IPV6):
	247	return vrf_process_v6_outbound(skb, dev);
	248	default:
57b8efa1	249	vrf_tx_error(dev, skb);
193125db DA	250	return NET_XMIT_DROP;
	251	}
	252	}
	253
	254	static netdev_tx_t vrf_xmit(struct sk_buff skb, struct net_device dev)
	255	{
	256	netdev_tx_t ret = is_ip_tx_frame(skb, dev);
	257
	258	if (likely(ret == NET_XMIT_SUCCESS \|\| ret == NET_XMIT_CN)) {
	259	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
	260
	261	u64_stats_update_begin(&dstats->syncp);
	262	dstats->tx_pkts++;
	263	dstats->tx_bytes += skb->len;
	264	u64_stats_update_end(&dstats->syncp);
	265	} else {
	266	this_cpu_inc(dev->dstats->tx_drps);
	267	}
	268
	269	return ret;
	270	}
	271
8f58336d	272	/* modelled after ip_finish_output2 */
0c4b51f0	273	static int vrf_finish_output(struct net net, struct sock sk, struct sk_buff *skb)
193125db	274	{
8f58336d DA	275	struct dst_entry *dst = skb_dst(skb);
	276	struct rtable rt = (struct rtable )dst;
	277	struct net_device *dev = dst->dev;
	278	unsigned int hh_len = LL_RESERVED_SPACE(dev);
	279	struct neighbour *neigh;
	280	u32 nexthop;
	281	int ret = -EINVAL;
	282
	283	/* Be paranoid, rather than too clever. */
	284	if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
	285	struct sk_buff *skb2;
	286
	287	skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
	288	if (!skb2) {
	289	ret = -ENOMEM;
	290	goto err;
	291	}
	292	if (skb->sk)
	293	skb_set_owner_w(skb2, skb->sk);
	294
	295	consume_skb(skb);
	296	skb = skb2;
	297	}
	298
	299	rcu_read_lock_bh();
	300
	301	nexthop = (__force u32)rt_nexthop(rt, ip_hdr(skb)->daddr);
	302	neigh = __ipv4_neigh_lookup_noref(dev, nexthop);
	303	if (unlikely(!neigh))
	304	neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);
	305	if (!IS_ERR(neigh))
	306	ret = dst_neigh_output(dst, neigh, skb);
	307
	308	rcu_read_unlock_bh();
	309	err:
	310	if (unlikely(ret < 0))
	311	vrf_tx_error(skb->dev, skb);
	312	return ret;
193125db DA	313	}
193125db DA	314
ede2059d	315	static int vrf_output(struct net net, struct sock sk, struct sk_buff *skb)
193125db DA	316	{
	317	struct net_device *dev = skb_dst(skb)->dev;
	318
29a26a56	319	IP_UPD_PO_STATS(net, IPSTATS_MIB_OUT, skb->len);
193125db DA	320
	321	skb->dev = dev;
	322	skb->protocol = htons(ETH_P_IP);
	323
29a26a56 EB	324	return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
29a26a56 EB	325	net, sk, skb, NULL, dev,
8f58336d	326	vrf_finish_output,
193125db DA	327	!(IPCB(skb)->flags & IPSKB_REROUTED));
	328	}
	329
	330	static void vrf_rtable_destroy(struct net_vrf *vrf)
	331	{
	332	struct dst_entry dst = (struct dst_entry )vrf->rth;
	333
3a4a27d3	334	dst_destroy(dst);
193125db DA	335	vrf->rth = NULL;
	336	}
	337
	338	static struct rtable vrf_rtable_create(struct net_device dev)
	339	{
b7503e0c	340	struct net_vrf *vrf = netdev_priv(dev);
193125db DA	341	struct rtable *rth;
	342
	343	rth = dst_alloc(&vrf_dst_ops, dev, 2,
	344	DST_OBSOLETE_NONE,
	345	(DST_HOST \| DST_NOPOLICY \| DST_NOXFRM));
	346	if (rth) {
	347	rth->dst.output = vrf_output;
	348	rth->rt_genid = rt_genid_ipv4(dev_net(dev));
	349	rth->rt_flags = 0;
	350	rth->rt_type = RTN_UNICAST;
	351	rth->rt_is_input = 0;
	352	rth->rt_iif = 0;
	353	rth->rt_pmtu = 0;
	354	rth->rt_gateway = 0;
	355	rth->rt_uses_gateway = 0;
b7503e0c	356	rth->rt_table_id = vrf->tb_id;
193125db DA	357	INIT_LIST_HEAD(&rth->rt_uncached);
193125db DA	358	rth->rt_uncached_list = NULL;
193125db DA	359	}
	360
	361	return rth;
	362	}
	363
	364	/************************** device handling ******************/
	365
	366	/* cycle interface to flush neighbor cache and move routes across tables */
	367	static void cycle_netdev(struct net_device *dev)
	368	{
	369	unsigned int flags = dev->flags;
	370	int ret;
	371
	372	if (!netif_running(dev))
	373	return;
	374
	375	ret = dev_change_flags(dev, flags & ~IFF_UP);
	376	if (ret >= 0)
	377	ret = dev_change_flags(dev, flags);
	378
	379	if (ret < 0) {
	380	netdev_err(dev,
	381	"Failed to cycle device %s; route tables might be wrong!\n",
	382	dev->name);
	383	}
	384	}
	385
	386	static struct slave __vrf_find_slave_dev(struct slave_queue queue,
	387	struct net_device *dev)
	388	{
	389	struct list_head *head = &queue->all_slaves;
	390	struct slave *slave;
	391
	392	list_for_each_entry(slave, head, list) {
	393	if (slave->dev == dev)
	394	return slave;
	395	}
	396
	397	return NULL;
	398	}
	399
	400	/* inverse of __vrf_insert_slave */
	401	static void __vrf_remove_slave(struct slave_queue queue, struct slave slave)
	402	{
193125db	403	list_del(&slave->list);
193125db DA	404	}
	405
	406	static void __vrf_insert_slave(struct slave_queue queue, struct slave slave)
	407	{
193125db	408	list_add(&slave->list, &queue->all_slaves);
193125db DA	409	}
	410
	411	static int do_vrf_add_slave(struct net_device dev, struct net_device port_dev)
	412	{
193125db	413	struct slave slave = kzalloc(sizeof(slave), GFP_KERNEL);
193125db DA	414	struct net_vrf *vrf = netdev_priv(dev);
	415	struct slave_queue *queue = &vrf->queue;
	416	int ret = -ENOMEM;
	417
93a7e7e8	418	if (!slave)
193125db DA	419	goto out_fail;
	420
	421	slave->dev = port_dev;
193125db	422
193125db DA	423	/* register the packet handler for slave ports */
	424	ret = netdev_rx_handler_register(port_dev, vrf_handle_frame, dev);
	425	if (ret) {
	426	netdev_err(port_dev,
	427	"Device %s failed to register rx_handler\n",
	428	port_dev->name);
15df5e71	429	goto out_fail;
193125db DA	430	}
	431
	432	ret = netdev_master_upper_dev_link(port_dev, dev);
	433	if (ret < 0)
	434	goto out_unregister;
	435
fee6d4c7	436	port_dev->priv_flags \|= IFF_L3MDEV_SLAVE;
15df5e71	437	__vrf_insert_slave(queue, slave);
193125db DA	438	cycle_netdev(port_dev);
	439
	440	return 0;
	441
	442	out_unregister:
	443	netdev_rx_handler_unregister(port_dev);
193125db	444	out_fail:
193125db DA	445	kfree(slave);
	446	return ret;
	447	}
	448
	449	static int vrf_add_slave(struct net_device dev, struct net_device port_dev)
	450	{
fee6d4c7	451	if (netif_is_l3_master(port_dev) \|\| netif_is_l3_slave(port_dev))
193125db DA	452	return -EINVAL;
	453
	454	return do_vrf_add_slave(dev, port_dev);
	455	}
	456
	457	/* inverse of do_vrf_add_slave */
	458	static int do_vrf_del_slave(struct net_device dev, struct net_device port_dev)
	459	{
193125db DA	460	struct net_vrf *vrf = netdev_priv(dev);
	461	struct slave_queue *queue = &vrf->queue;
	462	struct slave *slave;
	463
193125db	464	netdev_upper_dev_unlink(port_dev, dev);
fee6d4c7	465	port_dev->priv_flags &= ~IFF_L3MDEV_SLAVE;
193125db DA	466
	467	netdev_rx_handler_unregister(port_dev);
	468
193125db DA	469	cycle_netdev(port_dev);
	470
	471	slave = __vrf_find_slave_dev(queue, port_dev);
	472	if (slave)
	473	__vrf_remove_slave(queue, slave);
	474
	475	kfree(slave);
	476
	477	return 0;
	478	}
	479
	480	static int vrf_del_slave(struct net_device dev, struct net_device port_dev)
	481	{
193125db DA	482	return do_vrf_del_slave(dev, port_dev);
	483	}
	484
	485	static void vrf_dev_uninit(struct net_device *dev)
	486	{
	487	struct net_vrf *vrf = netdev_priv(dev);
	488	struct slave_queue *queue = &vrf->queue;
	489	struct list_head *head = &queue->all_slaves;
	490	struct slave slave, next;
	491
	492	vrf_rtable_destroy(vrf);
	493
	494	list_for_each_entry_safe(slave, next, head, list)
	495	vrf_del_slave(dev, slave->dev);
	496
3a4a27d3	497	free_percpu(dev->dstats);
193125db DA	498	dev->dstats = NULL;
	499	}
	500
	501	static int vrf_dev_init(struct net_device *dev)
	502	{
	503	struct net_vrf *vrf = netdev_priv(dev);
	504
	505	INIT_LIST_HEAD(&vrf->queue.all_slaves);
	506
	507	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
	508	if (!dev->dstats)
	509	goto out_nomem;
	510
	511	/* create the default dst which points back to us */
	512	vrf->rth = vrf_rtable_create(dev);
	513	if (!vrf->rth)
	514	goto out_stats;
	515
	516	dev->flags = IFF_MASTER \| IFF_NOARP;
	517
	518	return 0;
	519
	520	out_stats:
	521	free_percpu(dev->dstats);
	522	dev->dstats = NULL;
	523	out_nomem:
	524	return -ENOMEM;
	525	}
	526
	527	static const struct net_device_ops vrf_netdev_ops = {
	528	.ndo_init = vrf_dev_init,
	529	.ndo_uninit = vrf_dev_uninit,
	530	.ndo_start_xmit = vrf_xmit,
	531	.ndo_get_stats64 = vrf_get_stats64,
	532	.ndo_add_slave = vrf_add_slave,
	533	.ndo_del_slave = vrf_del_slave,
	534	};
	535
ee15ee5d DA	536	static u32 vrf_fib_table(const struct net_device *dev)
	537	{
	538	struct net_vrf *vrf = netdev_priv(dev);
	539
	540	return vrf->tb_id;
	541	}
	542
	543	static struct rtable vrf_get_rtable(const struct net_device dev,
	544	const struct flowi4 *fl4)
	545	{
	546	struct rtable *rth = NULL;
	547
6e2895a8	548	if (!(fl4->flowi4_flags & FLOWI_FLAG_L3MDEV_SRC)) {
ee15ee5d DA	549	struct net_vrf *vrf = netdev_priv(dev);
	550
	551	rth = vrf->rth;
	552	atomic_inc(&rth->dst.__refcnt);
	553	}
	554
	555	return rth;
	556	}
	557
8cbb512c DA	558	/* called under rcu_read_lock */
	559	static void vrf_get_saddr(struct net_device dev, struct flowi4 fl4)
	560	{
	561	struct fib_result res = { .tclassid = 0 };
	562	struct net *net = dev_net(dev);
	563	u32 orig_tos = fl4->flowi4_tos;
	564	u8 flags = fl4->flowi4_flags;
	565	u8 scope = fl4->flowi4_scope;
	566	u8 tos = RT_FL_TOS(fl4);
	567
	568	if (unlikely(!fl4->daddr))
	569	return;
	570
	571	fl4->flowi4_flags \|= FLOWI_FLAG_SKIP_NH_OIF;
	572	fl4->flowi4_iif = LOOPBACK_IFINDEX;
	573	fl4->flowi4_tos = tos & IPTOS_RT_MASK;
	574	fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
	575	RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
	576
	577	if (!fib_lookup(net, fl4, &res, 0)) {
	578	if (res.type == RTN_LOCAL)
	579	fl4->saddr = res.fi->fib_prefsrc ? : fl4->daddr;
	580	else
	581	fib_select_path(net, &res, fl4, -1);
	582	}
	583
	584	fl4->flowi4_flags = flags;
	585	fl4->flowi4_tos = orig_tos;
	586	fl4->flowi4_scope = scope;
	587	}
	588
ee15ee5d DA	589	static const struct l3mdev_ops vrf_l3mdev_ops = {
	590	.l3mdev_fib_table = vrf_fib_table,
	591	.l3mdev_get_rtable = vrf_get_rtable,
8cbb512c	592	.l3mdev_get_saddr = vrf_get_saddr,
ee15ee5d DA	593	};
ee15ee5d DA	594
193125db DA	595	static void vrf_get_drvinfo(struct net_device *dev,
	596	struct ethtool_drvinfo *info)
	597	{
	598	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	599	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
	600	}
	601
	602	static const struct ethtool_ops vrf_ethtool_ops = {
	603	.get_drvinfo = vrf_get_drvinfo,
	604	};
	605
	606	static void vrf_setup(struct net_device *dev)
	607	{
	608	ether_setup(dev);
	609
	610	/* Initialize the device structure. */
	611	dev->netdev_ops = &vrf_netdev_ops;
ee15ee5d	612	dev->l3mdev_ops = &vrf_l3mdev_ops;
193125db DA	613	dev->ethtool_ops = &vrf_ethtool_ops;
	614	dev->destructor = free_netdev;
	615
	616	/* Fill in device structure with ethernet-generic values. */
	617	eth_hw_addr_random(dev);
	618
	619	/* don't acquire vrf device's netif_tx_lock when transmitting */
	620	dev->features \|= NETIF_F_LLTX;
	621
	622	/* don't allow vrf devices to change network namespaces. */
	623	dev->features \|= NETIF_F_NETNS_LOCAL;
	624	}
	625
	626	static int vrf_validate(struct nlattr tb[], struct nlattr data[])
	627	{
	628	if (tb[IFLA_ADDRESS]) {
	629	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	630	return -EINVAL;
	631	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	632	return -EADDRNOTAVAIL;
	633	}
	634	return 0;
	635	}
	636
	637	static void vrf_dellink(struct net_device dev, struct list_head head)
	638	{
193125db DA	639	unregister_netdevice_queue(dev, head);
	640	}
	641
	642	static int vrf_newlink(struct net src_net, struct net_device dev,
	643	struct nlattr tb[], struct nlattr data[])
	644	{
	645	struct net_vrf *vrf = netdev_priv(dev);
193125db DA	646	int err;
	647
	648	if (!data \|\| !data[IFLA_VRF_TABLE])
	649	return -EINVAL;
	650
	651	vrf->tb_id = nla_get_u32(data[IFLA_VRF_TABLE]);
	652
007979ea	653	dev->priv_flags \|= IFF_L3MDEV_MASTER;
193125db	654
193125db DA	655	err = register_netdevice(dev);
	656	if (err < 0)
	657	goto out_fail;
	658
193125db DA	659	return 0;
	660
	661	out_fail:
193125db DA	662	free_netdev(dev);
	663	return err;
	664	}
	665
	666	static size_t vrf_nl_getsize(const struct net_device *dev)
	667	{
	668	return nla_total_size(sizeof(u32)); /* IFLA_VRF_TABLE */
	669	}
	670
	671	static int vrf_fillinfo(struct sk_buff *skb,
	672	const struct net_device *dev)
	673	{
	674	struct net_vrf *vrf = netdev_priv(dev);
	675
	676	return nla_put_u32(skb, IFLA_VRF_TABLE, vrf->tb_id);
	677	}
	678
	679	static const struct nla_policy vrf_nl_policy[IFLA_VRF_MAX + 1] = {
	680	[IFLA_VRF_TABLE] = { .type = NLA_U32 },
	681	};
	682
	683	static struct rtnl_link_ops vrf_link_ops __read_mostly = {
	684	.kind = DRV_NAME,
	685	.priv_size = sizeof(struct net_vrf),
	686
	687	.get_size = vrf_nl_getsize,
	688	.policy = vrf_nl_policy,
	689	.validate = vrf_validate,
	690	.fill_info = vrf_fillinfo,
	691
	692	.newlink = vrf_newlink,
	693	.dellink = vrf_dellink,
	694	.setup = vrf_setup,
	695	.maxtype = IFLA_VRF_MAX,
	696	};
	697
	698	static int vrf_device_event(struct notifier_block *unused,
	699	unsigned long event, void *ptr)
	700	{
	701	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
	702
	703	/* only care about unregister events to drop slave references */
	704	if (event == NETDEV_UNREGISTER) {
193125db DA	705	struct net_device *vrf_dev;
193125db DA	706
fee6d4c7	707	if (!netif_is_l3_slave(dev))
193125db DA	708	goto out;
193125db DA	709
58aa9087 NA	710	vrf_dev = netdev_master_upper_dev_get(dev);
58aa9087 NA	711	vrf_del_slave(vrf_dev, dev);
193125db DA	712	}
	713	out:
	714	return NOTIFY_DONE;
	715	}
	716
	717	static struct notifier_block vrf_notifier_block __read_mostly = {
	718	.notifier_call = vrf_device_event,
	719	};
	720
	721	static int __init vrf_init_module(void)
	722	{
	723	int rc;
	724
	725	vrf_dst_ops.kmem_cachep =
	726	kmem_cache_create("vrf_ip_dst_cache",
	727	sizeof(struct rtable), 0,
e367da02	728	SLAB_HWCACHE_ALIGN,
193125db DA	729	NULL);
	730
	731	if (!vrf_dst_ops.kmem_cachep)
	732	return -ENOMEM;
	733
	734	register_netdevice_notifier(&vrf_notifier_block);
	735
	736	rc = rtnl_link_register(&vrf_link_ops);
	737	if (rc < 0)
	738	goto error;
	739
	740	return 0;
	741
	742	error:
	743	unregister_netdevice_notifier(&vrf_notifier_block);
	744	kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
	745	return rc;
	746	}
	747
	748	static void __exit vrf_cleanup_module(void)
	749	{
	750	rtnl_link_unregister(&vrf_link_ops);
	751	unregister_netdevice_notifier(&vrf_notifier_block);
	752	kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
	753	}
	754
	755	module_init(vrf_init_module);
	756	module_exit(vrf_cleanup_module);
	757	MODULE_AUTHOR("Shrijeet Mukherjee, David Ahern");
	758	MODULE_DESCRIPTION("Device driver to instantiate VRF domains");
	759	MODULE_LICENSE("GPL");
	760	MODULE_ALIAS_RTNL_LINK(DRV_NAME);
	761	MODULE_VERSION(DRV_VERSION);