[linux-2.6-block.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_master_upper_ifindex_by_index - get index of upper l3 master
 *					       device
 *	@net: network namespace for device index lookup
 *	@ifindex: targeted interface
 */
int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex)
{
	struct net_device *dev;

	dev = dev_get_by_index_rcu(net, ifindex);
	while (dev && !netif_is_l3_master(dev))
		dev = netdev_master_upper_dev_get(dev);

	return dev ? dev->ifindex : 0;
}
EXPORT_SYMBOL_GPL(l3mdev_master_upper_ifindex_by_index_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_link_scope_lookup - IPv6 route lookup based on flow for link
 *			     local and multicast addresses
 *	@net: network namespace for device index lookup
 *	@fl6: IPv6 flow struct for lookup
 */

struct dst_entry *l3mdev_link_scope_lookup(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_link_scope_lookup)
			dst = dev->l3mdev_ops->l3mdev_link_scope_lookup(dev, fl6);

		rcu_read_unlock();
	}

	return dst;
}
EXPORT_SYMBOL_GPL(l3mdev_link_scope_lookup);

/**
 *	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;
}

void l3mdev_update_flow(struct net *net, struct flowi *fl)
{
	struct net_device *dev;
	int ifindex;

	rcu_read_lock();

	if (fl->flowi_oif) {
		dev = dev_get_by_index_rcu(net, fl->flowi_oif);
		if (dev) {
			ifindex = l3mdev_master_ifindex_rcu(dev);
			if (ifindex) {
				fl->flowi_oif = ifindex;
				fl->flowi_flags |= FLOWI_FLAG_SKIP_NH_OIF;
				goto out;
			}
		}
	}

	if (fl->flowi_iif) {
		dev = dev_get_by_index_rcu(net, fl->flowi_iif);
		if (dev) {
			ifindex = l3mdev_master_ifindex_rcu(dev);
			if (ifindex) {
				fl->flowi_iif = ifindex;
				fl->flowi_flags |= FLOWI_FLAG_SKIP_NH_OIF;
			}
		}
	}

out:
	rcu_read_unlock();
}
EXPORT_SYMBOL_GPL(l3mdev_update_flow);
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
6a6d6681 AB	49	/**
	50	* l3mdev_master_upper_ifindex_by_index - get index of upper l3 master
	51	* device
	52	* @net: network namespace for device index lookup
	53	* @ifindex: targeted interface
	54	*/
	55	int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex)
	56	{
	57	struct net_device *dev;
	58
	59	dev = dev_get_by_index_rcu(net, ifindex);
	60	while (dev && !netif_is_l3_master(dev))
	61	dev = netdev_master_upper_dev_get(dev);
	62
	63	return dev ? dev->ifindex : 0;
	64	}
	65	EXPORT_SYMBOL_GPL(l3mdev_master_upper_ifindex_by_index_rcu);
	66
1b69c6d0 DA	67	/**
	68	* l3mdev_fib_table - get FIB table id associated with an L3
	69	* master interface
	70	* @dev: targeted interface
	71	*/
	72
	73	u32 l3mdev_fib_table_rcu(const struct net_device *dev)
	74	{
	75	u32 tb_id = 0;
	76
	77	if (!dev)
	78	return 0;
	79
	80	if (netif_is_l3_master(dev)) {
	81	if (dev->l3mdev_ops->l3mdev_fib_table)
	82	tb_id = dev->l3mdev_ops->l3mdev_fib_table(dev);
fee6d4c7	83	} else if (netif_is_l3_slave(dev)) {
1b69c6d0 DA	84	/* Users of netdev_master_upper_dev_get_rcu need non-const,
	85	* but current inet_*type functions take a const
	86	*/
	87	struct net_device _dev = (struct net_device ) dev;
	88	const struct net_device *master;
	89
	90	master = netdev_master_upper_dev_get_rcu(_dev);
fee6d4c7	91	if (master &&
1b69c6d0 DA	92	master->l3mdev_ops->l3mdev_fib_table)
	93	tb_id = master->l3mdev_ops->l3mdev_fib_table(master);
	94	}
	95
	96	return tb_id;
	97	}
	98	EXPORT_SYMBOL_GPL(l3mdev_fib_table_rcu);
	99
	100	u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
	101	{
	102	struct net_device *dev;
	103	u32 tb_id = 0;
	104
	105	if (!ifindex)
	106	return 0;
	107
	108	rcu_read_lock();
	109
	110	dev = dev_get_by_index_rcu(net, ifindex);
	111	if (dev)
	112	tb_id = l3mdev_fib_table_rcu(dev);
	113
	114	rcu_read_unlock();
	115
	116	return tb_id;
	117	}
	118	EXPORT_SYMBOL_GPL(l3mdev_fib_table_by_index);
4a65896f DA	119
4a65896f DA	120	/**
4c1feac5 DA	121	* l3mdev_link_scope_lookup - IPv6 route lookup based on flow for link
4c1feac5 DA	122	* local and multicast addresses
4a65896f DA	123	* @net: network namespace for device index lookup
	124	* @fl6: IPv6 flow struct for lookup
	125	*/
	126
4c1feac5 DA	127	struct dst_entry l3mdev_link_scope_lookup(struct net net,
4c1feac5 DA	128	struct flowi6 *fl6)
4a65896f DA	129	{
	130	struct dst_entry *dst = NULL;
	131	struct net_device *dev;
	132
1ff23bee DA	133	if (fl6->flowi6_oif) {
	134	rcu_read_lock();
	135
	136	dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
	137	if (dev && netif_is_l3_slave(dev))
	138	dev = netdev_master_upper_dev_get_rcu(dev);
	139
	140	if (dev && netif_is_l3_master(dev) &&
4c1feac5 DA	141	dev->l3mdev_ops->l3mdev_link_scope_lookup)
4c1feac5 DA	142	dst = dev->l3mdev_ops->l3mdev_link_scope_lookup(dev, fl6);
1ff23bee DA	143
1ff23bee DA	144	rcu_read_unlock();
4a65896f DA	145	}
	146
	147	return dst;
	148	}
4c1feac5	149	EXPORT_SYMBOL_GPL(l3mdev_link_scope_lookup);
4a65896f	150
96c63fa7 DA	151	/**
	152	* l3mdev_fib_rule_match - Determine if flowi references an
	153	* L3 master device
	154	* @net: network namespace for device index lookup
	155	* @fl: flow struct
	156	*/
	157
	158	int l3mdev_fib_rule_match(struct net net, struct flowi fl,
	159	struct fib_lookup_arg *arg)
	160	{
	161	struct net_device *dev;
	162	int rc = 0;
	163
	164	rcu_read_lock();
	165
	166	dev = dev_get_by_index_rcu(net, fl->flowi_oif);
	167	if (dev && netif_is_l3_master(dev) &&
	168	dev->l3mdev_ops->l3mdev_fib_table) {
	169	arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
	170	rc = 1;
	171	goto out;
	172	}
	173
	174	dev = dev_get_by_index_rcu(net, fl->flowi_iif);
	175	if (dev && netif_is_l3_master(dev) &&
	176	dev->l3mdev_ops->l3mdev_fib_table) {
	177	arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
	178	rc = 1;
	179	goto out;
	180	}
	181
	182	out:
	183	rcu_read_unlock();
	184
	185	return rc;
	186	}
9ee0034b DA	187
	188	void l3mdev_update_flow(struct net net, struct flowi fl)
	189	{
	190	struct net_device *dev;
	191	int ifindex;
	192
	193	rcu_read_lock();
	194
	195	if (fl->flowi_oif) {
	196	dev = dev_get_by_index_rcu(net, fl->flowi_oif);
	197	if (dev) {
	198	ifindex = l3mdev_master_ifindex_rcu(dev);
	199	if (ifindex) {
	200	fl->flowi_oif = ifindex;
	201	fl->flowi_flags \|= FLOWI_FLAG_SKIP_NH_OIF;
	202	goto out;
	203	}
	204	}
	205	}
	206
	207	if (fl->flowi_iif) {
	208	dev = dev_get_by_index_rcu(net, fl->flowi_iif);
	209	if (dev) {
	210	ifindex = l3mdev_master_ifindex_rcu(dev);
	211	if (ifindex) {
	212	fl->flowi_iif = ifindex;
	213	fl->flowi_flags \|= FLOWI_FLAG_SKIP_NH_OIF;
	214	}
	215	}
	216	}
	217
	218	out:
	219	rcu_read_unlock();
	220	}
	221	EXPORT_SYMBOL_GPL(l3mdev_update_flow);