[deliverable/linux.git] / net / l3mdev / l3mdev.c

/*
 * net/l3mdev/l3mdev.c - L3 master device implementation
 * Copyright (c) 2015 Cumulus Networks
 * Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.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 <linux/netdevice.h>
#include <net/fib_rules.h>
#include <net/l3mdev.h>

/**
 *	l3mdev_master_ifindex - get index of L3 master device
 *	@dev: targeted interface
 */

int l3mdev_master_ifindex_rcu(const struct net_device *dev)
{
	int ifindex = 0;

	if (!dev)
		return 0;

	if (netif_is_l3_master(dev)) {
		ifindex = dev->ifindex;
	} else if (netif_is_l3_slave(dev)) {
		struct net_device *master;
		struct net_device *_dev = (struct net_device *)dev;

		/* netdev_master_upper_dev_get_rcu calls
		 * list_first_or_null_rcu to walk the upper dev list.
		 * list_first_or_null_rcu does not handle a const arg. We aren't
		 * making changes, just want the master device from that list so
		 * typecast to remove the const
		 */
		master = netdev_master_upper_dev_get_rcu(_dev);
		if (master)
			ifindex = master->ifindex;
	}

	return ifindex;
}
EXPORT_SYMBOL_GPL(l3mdev_master_ifindex_rcu);

/**
 *	l3mdev_fib_table - get FIB table id associated with an L3
 *                             master interface
 *	@dev: targeted interface
 */

u32 l3mdev_fib_table_rcu(const struct net_device *dev)
{
	u32 tb_id = 0;

	if (!dev)
		return 0;

	if (netif_is_l3_master(dev)) {
		if (dev->l3mdev_ops->l3mdev_fib_table)
			tb_id = dev->l3mdev_ops->l3mdev_fib_table(dev);
	} else if (netif_is_l3_slave(dev)) {
		/* Users of netdev_master_upper_dev_get_rcu need non-const,
		 * but current inet_*type functions take a const
		 */
		struct net_device *_dev = (struct net_device *) dev;
		const struct net_device *master;

		master = netdev_master_upper_dev_get_rcu(_dev);
		if (master &&
		    master->l3mdev_ops->l3mdev_fib_table)
			tb_id = master->l3mdev_ops->l3mdev_fib_table(master);
	}

	return tb_id;
}
EXPORT_SYMBOL_GPL(l3mdev_fib_table_rcu);

u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
{
	struct net_device *dev;
	u32 tb_id = 0;

	if (!ifindex)
		return 0;

	rcu_read_lock();

	dev = dev_get_by_index_rcu(net, ifindex);
	if (dev)
		tb_id = l3mdev_fib_table_rcu(dev);

	rcu_read_unlock();

	return tb_id;
}
EXPORT_SYMBOL_GPL(l3mdev_fib_table_by_index);

/**
 *	l3mdev_get_rt6_dst - IPv6 route lookup based on flow. Returns
 *			     cached route for L3 master device if relevant
 *			     to flow
 *	@net: network namespace for device index lookup
 *	@fl6: IPv6 flow struct for lookup
 */

struct dst_entry *l3mdev_get_rt6_dst(struct net *net,
				     struct flowi6 *fl6)
{
	struct dst_entry *dst = NULL;
	struct net_device *dev;

	if (fl6->flowi6_oif) {
		rcu_read_lock();

		dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
		if (dev && netif_is_l3_slave(dev))
			dev = netdev_master_upper_dev_get_rcu(dev);

		if (dev && netif_is_l3_master(dev) &&
		    dev->l3mdev_ops->l3mdev_get_rt6_dst)
			dst = dev->l3mdev_ops->l3mdev_get_rt6_dst(dev, fl6);

		rcu_read_unlock();
	}

	return dst;
}
EXPORT_SYMBOL_GPL(l3mdev_get_rt6_dst);

/**
 *	l3mdev_get_saddr - get source address for a flow based on an interface
 *			   enslaved to an L3 master device
 *	@net: network namespace for device index lookup
 *	@ifindex: Interface index
 *	@fl4: IPv4 flow struct
 */

int l3mdev_get_saddr(struct net *net, int ifindex, struct flowi4 *fl4)
{
	struct net_device *dev;
	int rc = 0;

	if (ifindex) {
		rcu_read_lock();

		dev = dev_get_by_index_rcu(net, ifindex);
		if (dev && netif_is_l3_slave(dev))
			dev = netdev_master_upper_dev_get_rcu(dev);

		if (dev && netif_is_l3_master(dev) &&
		    dev->l3mdev_ops->l3mdev_get_saddr)
			rc = dev->l3mdev_ops->l3mdev_get_saddr(dev, fl4);

		rcu_read_unlock();
	}

	return rc;
}
EXPORT_SYMBOL_GPL(l3mdev_get_saddr);

int l3mdev_get_saddr6(struct net *net, const struct sock *sk,
		      struct flowi6 *fl6)
{
	struct net_device *dev;
	int rc = 0;

	if (fl6->flowi6_oif) {
		rcu_read_lock();

		dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
		if (dev && netif_is_l3_slave(dev))
			dev = netdev_master_upper_dev_get_rcu(dev);

		if (dev && netif_is_l3_master(dev) &&
		    dev->l3mdev_ops->l3mdev_get_saddr6)
			rc = dev->l3mdev_ops->l3mdev_get_saddr6(dev, sk, fl6);

		rcu_read_unlock();
	}

	return rc;
}
EXPORT_SYMBOL_GPL(l3mdev_get_saddr6);

/**
 *	l3mdev_fib_rule_match - Determine if flowi references an
 *				L3 master device
 *	@net: network namespace for device index lookup
 *	@fl:  flow struct
 */

int l3mdev_fib_rule_match(struct net *net, struct flowi *fl,
			  struct fib_lookup_arg *arg)
{
	struct net_device *dev;
	int rc = 0;

	rcu_read_lock();

	dev = dev_get_by_index_rcu(net, fl->flowi_oif);
	if (dev && netif_is_l3_master(dev) &&
	    dev->l3mdev_ops->l3mdev_fib_table) {
		arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
		rc = 1;
		goto out;
	}

	dev = dev_get_by_index_rcu(net, fl->flowi_iif);
	if (dev && netif_is_l3_master(dev) &&
	    dev->l3mdev_ops->l3mdev_fib_table) {
		arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
		rc = 1;
		goto out;
	}

out:
	rcu_read_unlock();

	return rc;
}
Commit	Line	Data
1b69c6d0 DA	1	/*
	2	* net/l3mdev/l3mdev.c - L3 master device implementation
	3	* Copyright (c) 2015 Cumulus Networks
	4	* Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*/
	11
	12	#include <linux/netdevice.h>
96c63fa7	13	#include <net/fib_rules.h>
1b69c6d0 DA	14	#include <net/l3mdev.h>
	15
	16	/**
	17	* l3mdev_master_ifindex - get index of L3 master device
	18	* @dev: targeted interface
	19	*/
	20
3f2fb9a8	21	int l3mdev_master_ifindex_rcu(const struct net_device *dev)
1b69c6d0 DA	22	{
	23	int ifindex = 0;
	24
	25	if (!dev)
	26	return 0;
	27
	28	if (netif_is_l3_master(dev)) {
	29	ifindex = dev->ifindex;
fee6d4c7	30	} else if (netif_is_l3_slave(dev)) {
1b69c6d0	31	struct net_device *master;
3f2fb9a8 DA	32	struct net_device _dev = (struct net_device )dev;
	33
	34	/* netdev_master_upper_dev_get_rcu calls
	35	* list_first_or_null_rcu to walk the upper dev list.
	36	* list_first_or_null_rcu does not handle a const arg. We aren't
	37	* making changes, just want the master device from that list so
	38	* typecast to remove the const
	39	*/
	40	master = netdev_master_upper_dev_get_rcu(_dev);
fee6d4c7	41	if (master)
1b69c6d0 DA	42	ifindex = master->ifindex;
	43	}
	44
	45	return ifindex;
	46	}
	47	EXPORT_SYMBOL_GPL(l3mdev_master_ifindex_rcu);
	48
	49	/**
	50	* l3mdev_fib_table - get FIB table id associated with an L3
	51	* master interface
	52	* @dev: targeted interface
	53	*/
	54
	55	u32 l3mdev_fib_table_rcu(const struct net_device *dev)
	56	{
	57	u32 tb_id = 0;
	58
	59	if (!dev)
	60	return 0;
	61
	62	if (netif_is_l3_master(dev)) {
	63	if (dev->l3mdev_ops->l3mdev_fib_table)
	64	tb_id = dev->l3mdev_ops->l3mdev_fib_table(dev);
fee6d4c7	65	} else if (netif_is_l3_slave(dev)) {
1b69c6d0 DA	66	/* Users of netdev_master_upper_dev_get_rcu need non-const,
	67	* but current inet_*type functions take a const
	68	*/
	69	struct net_device _dev = (struct net_device ) dev;
	70	const struct net_device *master;
	71
	72	master = netdev_master_upper_dev_get_rcu(_dev);
fee6d4c7	73	if (master &&
1b69c6d0 DA	74	master->l3mdev_ops->l3mdev_fib_table)
	75	tb_id = master->l3mdev_ops->l3mdev_fib_table(master);
	76	}
	77
	78	return tb_id;
	79	}
	80	EXPORT_SYMBOL_GPL(l3mdev_fib_table_rcu);
	81
	82	u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
	83	{
	84	struct net_device *dev;
	85	u32 tb_id = 0;
	86
	87	if (!ifindex)
	88	return 0;
	89
	90	rcu_read_lock();
	91
	92	dev = dev_get_by_index_rcu(net, ifindex);
	93	if (dev)
	94	tb_id = l3mdev_fib_table_rcu(dev);
	95
	96	rcu_read_unlock();
	97
	98	return tb_id;
	99	}
	100	EXPORT_SYMBOL_GPL(l3mdev_fib_table_by_index);
4a65896f DA	101
	102	/**
	103	* l3mdev_get_rt6_dst - IPv6 route lookup based on flow. Returns
	104	* cached route for L3 master device if relevant
	105	* to flow
	106	* @net: network namespace for device index lookup
	107	* @fl6: IPv6 flow struct for lookup
	108	*/
	109
	110	struct dst_entry l3mdev_get_rt6_dst(struct net net,
cd2a9e62	111	struct flowi6 *fl6)
4a65896f DA	112	{
	113	struct dst_entry *dst = NULL;
	114	struct net_device *dev;
	115
1ff23bee DA	116	if (fl6->flowi6_oif) {
	117	rcu_read_lock();
	118
	119	dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
	120	if (dev && netif_is_l3_slave(dev))
	121	dev = netdev_master_upper_dev_get_rcu(dev);
	122
	123	if (dev && netif_is_l3_master(dev) &&
4a65896f DA	124	dev->l3mdev_ops->l3mdev_get_rt6_dst)
4a65896f DA	125	dst = dev->l3mdev_ops->l3mdev_get_rt6_dst(dev, fl6);
1ff23bee DA	126
1ff23bee DA	127	rcu_read_unlock();
4a65896f DA	128	}
	129
	130	return dst;
	131	}
	132	EXPORT_SYMBOL_GPL(l3mdev_get_rt6_dst);
	133
	134	/**
	135	* l3mdev_get_saddr - get source address for a flow based on an interface
	136	* enslaved to an L3 master device
	137	* @net: network namespace for device index lookup
	138	* @ifindex: Interface index
	139	* @fl4: IPv4 flow struct
	140	*/
	141
	142	int l3mdev_get_saddr(struct net net, int ifindex, struct flowi4 fl4)
	143	{
	144	struct net_device *dev;
	145	int rc = 0;
	146
	147	if (ifindex) {
	148	rcu_read_lock();
	149
	150	dev = dev_get_by_index_rcu(net, ifindex);
1ff23bee DA	151	if (dev && netif_is_l3_slave(dev))
	152	dev = netdev_master_upper_dev_get_rcu(dev);
	153
4a65896f DA	154	if (dev && netif_is_l3_master(dev) &&
	155	dev->l3mdev_ops->l3mdev_get_saddr)
	156	rc = dev->l3mdev_ops->l3mdev_get_saddr(dev, fl4);
	157
	158	rcu_read_unlock();
	159	}
	160
	161	return rc;
	162	}
	163	EXPORT_SYMBOL_GPL(l3mdev_get_saddr);
96c63fa7	164
0d240e78 DA	165	int l3mdev_get_saddr6(struct net net, const struct sock sk,
	166	struct flowi6 *fl6)
	167	{
	168	struct net_device *dev;
	169	int rc = 0;
	170
	171	if (fl6->flowi6_oif) {
	172	rcu_read_lock();
	173
	174	dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
	175	if (dev && netif_is_l3_slave(dev))
	176	dev = netdev_master_upper_dev_get_rcu(dev);
	177
	178	if (dev && netif_is_l3_master(dev) &&
	179	dev->l3mdev_ops->l3mdev_get_saddr6)
	180	rc = dev->l3mdev_ops->l3mdev_get_saddr6(dev, sk, fl6);
	181
	182	rcu_read_unlock();
	183	}
	184
	185	return rc;
	186	}
	187	EXPORT_SYMBOL_GPL(l3mdev_get_saddr6);
	188
96c63fa7 DA	189	/**
	190	* l3mdev_fib_rule_match - Determine if flowi references an
	191	* L3 master device
	192	* @net: network namespace for device index lookup
	193	* @fl: flow struct
	194	*/
	195
	196	int l3mdev_fib_rule_match(struct net net, struct flowi fl,
	197	struct fib_lookup_arg *arg)
	198	{
	199	struct net_device *dev;
	200	int rc = 0;
	201
	202	rcu_read_lock();
	203
	204	dev = dev_get_by_index_rcu(net, fl->flowi_oif);
	205	if (dev && netif_is_l3_master(dev) &&
	206	dev->l3mdev_ops->l3mdev_fib_table) {
	207	arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
	208	rc = 1;
	209	goto out;
	210	}
	211
	212	dev = dev_get_by_index_rcu(net, fl->flowi_iif);
	213	if (dev && netif_is_l3_master(dev) &&
	214	dev->l3mdev_ops->l3mdev_fib_table) {
	215	arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
	216	rc = 1;
	217	goto out;
	218	}
	219
	220	out:
	221	rcu_read_unlock();
	222
	223	return rc;
	224	}