[linux-2.6-block.git] / net / l3mdev / l3mdev.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * net/l3mdev/l3mdev.c - L3 master device implementation
 * Copyright (c) 2015 Cumulus Networks
 * Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
 */

#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
 *	This function does not hold refcnt on the returned dst.
 *	Caller must hold rcu_read_lock().
 */

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

	WARN_ON_ONCE(!rcu_read_lock_held());
	if (fl6->flowi6_oif) {
		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);
	}

	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
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
1b69c6d0 DA	2	/*
	3	* net/l3mdev/l3mdev.c - L3 master device implementation
	4	* Copyright (c) 2015 Cumulus Networks
	5	* Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
1b69c6d0 DA	6	*/
	7
	8	#include <linux/netdevice.h>
96c63fa7	9	#include <net/fib_rules.h>
1b69c6d0 DA	10	#include <net/l3mdev.h>
	11
	12	/**
	13	* l3mdev_master_ifindex - get index of L3 master device
	14	* @dev: targeted interface
	15	*/
	16
3f2fb9a8	17	int l3mdev_master_ifindex_rcu(const struct net_device *dev)
1b69c6d0 DA	18	{
	19	int ifindex = 0;
	20
	21	if (!dev)
	22	return 0;
	23
	24	if (netif_is_l3_master(dev)) {
	25	ifindex = dev->ifindex;
fee6d4c7	26	} else if (netif_is_l3_slave(dev)) {
1b69c6d0	27	struct net_device *master;
3f2fb9a8 DA	28	struct net_device _dev = (struct net_device )dev;
	29
	30	/* netdev_master_upper_dev_get_rcu calls
	31	* list_first_or_null_rcu to walk the upper dev list.
	32	* list_first_or_null_rcu does not handle a const arg. We aren't
	33	* making changes, just want the master device from that list so
	34	* typecast to remove the const
	35	*/
	36	master = netdev_master_upper_dev_get_rcu(_dev);
fee6d4c7	37	if (master)
1b69c6d0 DA	38	ifindex = master->ifindex;
	39	}
	40
	41	return ifindex;
	42	}
	43	EXPORT_SYMBOL_GPL(l3mdev_master_ifindex_rcu);
	44
6a6d6681 AB	45	/**
	46	* l3mdev_master_upper_ifindex_by_index - get index of upper l3 master
	47	* device
	48	* @net: network namespace for device index lookup
	49	* @ifindex: targeted interface
	50	*/
	51	int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex)
	52	{
	53	struct net_device *dev;
	54
	55	dev = dev_get_by_index_rcu(net, ifindex);
	56	while (dev && !netif_is_l3_master(dev))
	57	dev = netdev_master_upper_dev_get(dev);
	58
	59	return dev ? dev->ifindex : 0;
	60	}
	61	EXPORT_SYMBOL_GPL(l3mdev_master_upper_ifindex_by_index_rcu);
	62
1b69c6d0 DA	63	/**
	64	* l3mdev_fib_table - get FIB table id associated with an L3
	65	* master interface
	66	* @dev: targeted interface
	67	*/
	68
	69	u32 l3mdev_fib_table_rcu(const struct net_device *dev)
	70	{
	71	u32 tb_id = 0;
	72
	73	if (!dev)
	74	return 0;
	75
	76	if (netif_is_l3_master(dev)) {
	77	if (dev->l3mdev_ops->l3mdev_fib_table)
	78	tb_id = dev->l3mdev_ops->l3mdev_fib_table(dev);
fee6d4c7	79	} else if (netif_is_l3_slave(dev)) {
1b69c6d0 DA	80	/* Users of netdev_master_upper_dev_get_rcu need non-const,
	81	* but current inet_*type functions take a const
	82	*/
	83	struct net_device _dev = (struct net_device ) dev;
	84	const struct net_device *master;
	85
	86	master = netdev_master_upper_dev_get_rcu(_dev);
fee6d4c7	87	if (master &&
1b69c6d0 DA	88	master->l3mdev_ops->l3mdev_fib_table)
	89	tb_id = master->l3mdev_ops->l3mdev_fib_table(master);
	90	}
	91
	92	return tb_id;
	93	}
	94	EXPORT_SYMBOL_GPL(l3mdev_fib_table_rcu);
	95
	96	u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
	97	{
	98	struct net_device *dev;
	99	u32 tb_id = 0;
	100
	101	if (!ifindex)
	102	return 0;
	103
	104	rcu_read_lock();
	105
	106	dev = dev_get_by_index_rcu(net, ifindex);
	107	if (dev)
	108	tb_id = l3mdev_fib_table_rcu(dev);
	109
	110	rcu_read_unlock();
	111
	112	return tb_id;
	113	}
	114	EXPORT_SYMBOL_GPL(l3mdev_fib_table_by_index);
4a65896f DA	115
4a65896f DA	116	/**
4c1feac5 DA	117	* l3mdev_link_scope_lookup - IPv6 route lookup based on flow for link
4c1feac5 DA	118	* local and multicast addresses
4a65896f DA	119	* @net: network namespace for device index lookup
4a65896f DA	120	* @fl6: IPv6 flow struct for lookup
7d9e5f42 WW	121	* This function does not hold refcnt on the returned dst.
7d9e5f42 WW	122	* Caller must hold rcu_read_lock().
4a65896f DA	123	*/
4a65896f DA	124
4c1feac5 DA	125	struct dst_entry l3mdev_link_scope_lookup(struct net net,
4c1feac5 DA	126	struct flowi6 *fl6)
4a65896f DA	127	{
	128	struct dst_entry *dst = NULL;
	129	struct net_device *dev;
	130
7d9e5f42	131	WARN_ON_ONCE(!rcu_read_lock_held());
1ff23bee	132	if (fl6->flowi6_oif) {
1ff23bee DA	133	dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
	134	if (dev && netif_is_l3_slave(dev))
	135	dev = netdev_master_upper_dev_get_rcu(dev);
	136
	137	if (dev && netif_is_l3_master(dev) &&
4c1feac5 DA	138	dev->l3mdev_ops->l3mdev_link_scope_lookup)
4c1feac5 DA	139	dst = dev->l3mdev_ops->l3mdev_link_scope_lookup(dev, fl6);
4a65896f DA	140	}
	141
	142	return dst;
	143	}
4c1feac5	144	EXPORT_SYMBOL_GPL(l3mdev_link_scope_lookup);
4a65896f	145
96c63fa7 DA	146	/**
	147	* l3mdev_fib_rule_match - Determine if flowi references an
	148	* L3 master device
	149	* @net: network namespace for device index lookup
	150	* @fl: flow struct
	151	*/
	152
	153	int l3mdev_fib_rule_match(struct net net, struct flowi fl,
	154	struct fib_lookup_arg *arg)
	155	{
	156	struct net_device *dev;
	157	int rc = 0;
	158
	159	rcu_read_lock();
	160
	161	dev = dev_get_by_index_rcu(net, fl->flowi_oif);
	162	if (dev && netif_is_l3_master(dev) &&
	163	dev->l3mdev_ops->l3mdev_fib_table) {
	164	arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
	165	rc = 1;
	166	goto out;
	167	}
	168
	169	dev = dev_get_by_index_rcu(net, fl->flowi_iif);
	170	if (dev && netif_is_l3_master(dev) &&
	171	dev->l3mdev_ops->l3mdev_fib_table) {
	172	arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
	173	rc = 1;
	174	goto out;
	175	}
	176
	177	out:
	178	rcu_read_unlock();
	179
	180	return rc;
	181	}
9ee0034b DA	182
	183	void l3mdev_update_flow(struct net net, struct flowi fl)
	184	{
	185	struct net_device *dev;
	186	int ifindex;
	187
	188	rcu_read_lock();
	189
	190	if (fl->flowi_oif) {
	191	dev = dev_get_by_index_rcu(net, fl->flowi_oif);
	192	if (dev) {
	193	ifindex = l3mdev_master_ifindex_rcu(dev);
	194	if (ifindex) {
	195	fl->flowi_oif = ifindex;
	196	fl->flowi_flags \|= FLOWI_FLAG_SKIP_NH_OIF;
	197	goto out;
	198	}
	199	}
	200	}
	201
	202	if (fl->flowi_iif) {
	203	dev = dev_get_by_index_rcu(net, fl->flowi_iif);
	204	if (dev) {
	205	ifindex = l3mdev_master_ifindex_rcu(dev);
	206	if (ifindex) {
	207	fl->flowi_iif = ifindex;
	208	fl->flowi_flags \|= FLOWI_FLAG_SKIP_NH_OIF;
	209	}
	210	}
	211	}
	212
	213	out:
	214	rcu_read_unlock();
	215	}
	216	EXPORT_SYMBOL_GPL(l3mdev_update_flow);