[thirdparty/kernel/linux.git] / include / net / l3mdev.h

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

#include <net/dst.h>
#include <net/fib_rules.h>

enum l3mdev_type {
	L3MDEV_TYPE_UNSPEC,
	L3MDEV_TYPE_VRF,
	__L3MDEV_TYPE_MAX
};

#define L3MDEV_TYPE_MAX (__L3MDEV_TYPE_MAX - 1)

typedef int (*lookup_by_table_id_t)(struct net *net, u32 table_d);

/**
 * struct l3mdev_ops - l3mdev operations
 *
 * @l3mdev_fib_table: Get FIB table id to use for lookups
 *
 * @l3mdev_l3_rcv:    Hook in L3 receive path
 *
 * @l3mdev_l3_out:    Hook in L3 output path
 *
 * @l3mdev_link_scope_lookup: IPv6 lookup for linklocal and mcast destinations
 */

struct l3mdev_ops {
	u32		(*l3mdev_fib_table)(const struct net_device *dev);
	struct sk_buff * (*l3mdev_l3_rcv)(struct net_device *dev,
					  struct sk_buff *skb, u16 proto);
	struct sk_buff * (*l3mdev_l3_out)(struct net_device *dev,
					  struct sock *sk, struct sk_buff *skb,
					  u16 proto);

	/* IPv6 ops */
	struct dst_entry * (*l3mdev_link_scope_lookup)(const struct net_device *dev,
						 struct flowi6 *fl6);
};

#ifdef CONFIG_NET_L3_MASTER_DEV

int l3mdev_table_lookup_register(enum l3mdev_type l3type,
				 lookup_by_table_id_t fn);

void l3mdev_table_lookup_unregister(enum l3mdev_type l3type,
				    lookup_by_table_id_t fn);

int l3mdev_ifindex_lookup_by_table_id(enum l3mdev_type l3type, struct net *net,
				      u32 table_id);

int l3mdev_fib_rule_match(struct net *net, struct flowi *fl,
			  struct fib_lookup_arg *arg);

void l3mdev_update_flow(struct net *net, struct flowi *fl);

int l3mdev_master_ifindex_rcu(const struct net_device *dev);
static inline int l3mdev_master_ifindex(struct net_device *dev)
{
	int ifindex;

	rcu_read_lock();
	ifindex = l3mdev_master_ifindex_rcu(dev);
	rcu_read_unlock();

	return ifindex;
}

static inline int l3mdev_master_ifindex_by_index(struct net *net, int ifindex)
{
	struct net_device *dev;
	int rc = 0;

	if (likely(ifindex)) {
		rcu_read_lock();

		dev = dev_get_by_index_rcu(net, ifindex);
		if (dev)
			rc = l3mdev_master_ifindex_rcu(dev);

		rcu_read_unlock();
	}

	return rc;
}

static inline
struct net_device *l3mdev_master_dev_rcu(const 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
	 */
	struct net_device *dev = (struct net_device *)_dev;
	struct net_device *master;

	if (!dev)
		return NULL;

	if (netif_is_l3_master(dev))
		master = dev;
	else if (netif_is_l3_slave(dev))
		master = netdev_master_upper_dev_get_rcu(dev);
	else
		master = NULL;

	return master;
}

int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex);
static inline
int l3mdev_master_upper_ifindex_by_index(struct net *net, int ifindex)
{
	rcu_read_lock();
	ifindex = l3mdev_master_upper_ifindex_by_index_rcu(net, ifindex);
	rcu_read_unlock();

	return ifindex;
}

u32 l3mdev_fib_table_rcu(const struct net_device *dev);
u32 l3mdev_fib_table_by_index(struct net *net, int ifindex);
static inline u32 l3mdev_fib_table(const struct net_device *dev)
{
	u32 tb_id;

	rcu_read_lock();
	tb_id = l3mdev_fib_table_rcu(dev);
	rcu_read_unlock();

	return tb_id;
}

static inline bool netif_index_is_l3_master(struct net *net, int ifindex)
{
	struct net_device *dev;
	bool rc = false;

	if (ifindex == 0)
		return false;

	rcu_read_lock();

	dev = dev_get_by_index_rcu(net, ifindex);
	if (dev)
		rc = netif_is_l3_master(dev);

	rcu_read_unlock();

	return rc;
}

struct dst_entry *l3mdev_link_scope_lookup(struct net *net, struct flowi6 *fl6);

static inline
struct sk_buff *l3mdev_l3_rcv(struct sk_buff *skb, u16 proto)
{
	struct net_device *master = NULL;

	if (netif_is_l3_slave(skb->dev))
		master = netdev_master_upper_dev_get_rcu(skb->dev);
	else if (netif_is_l3_master(skb->dev) ||
		 netif_has_l3_rx_handler(skb->dev))
		master = skb->dev;

	if (master && master->l3mdev_ops->l3mdev_l3_rcv)
		skb = master->l3mdev_ops->l3mdev_l3_rcv(master, skb, proto);

	return skb;
}

static inline
struct sk_buff *l3mdev_ip_rcv(struct sk_buff *skb)
{
	return l3mdev_l3_rcv(skb, AF_INET);
}

static inline
struct sk_buff *l3mdev_ip6_rcv(struct sk_buff *skb)
{
	return l3mdev_l3_rcv(skb, AF_INET6);
}

static inline
struct sk_buff *l3mdev_l3_out(struct sock *sk, struct sk_buff *skb, u16 proto)
{
	struct net_device *dev = skb_dst(skb)->dev;

	if (netif_is_l3_slave(dev)) {
		struct net_device *master;

		master = netdev_master_upper_dev_get_rcu(dev);
		if (master && master->l3mdev_ops->l3mdev_l3_out)
			skb = master->l3mdev_ops->l3mdev_l3_out(master, sk,
								skb, proto);
	}

	return skb;
}

static inline
struct sk_buff *l3mdev_ip_out(struct sock *sk, struct sk_buff *skb)
{
	return l3mdev_l3_out(sk, skb, AF_INET);
}

static inline
struct sk_buff *l3mdev_ip6_out(struct sock *sk, struct sk_buff *skb)
{
	return l3mdev_l3_out(sk, skb, AF_INET6);
}
#else

static inline int l3mdev_master_ifindex_rcu(const struct net_device *dev)
{
	return 0;
}
static inline int l3mdev_master_ifindex(struct net_device *dev)
{
	return 0;
}

static inline int l3mdev_master_ifindex_by_index(struct net *net, int ifindex)
{
	return 0;
}

static inline
int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex)
{
	return 0;
}
static inline
int l3mdev_master_upper_ifindex_by_index(struct net *net, int ifindex)
{
	return 0;
}

static inline
struct net_device *l3mdev_master_dev_rcu(const struct net_device *dev)
{
	return NULL;
}

static inline u32 l3mdev_fib_table_rcu(const struct net_device *dev)
{
	return 0;
}
static inline u32 l3mdev_fib_table(const struct net_device *dev)
{
	return 0;
}
static inline u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
{
	return 0;
}

static inline bool netif_index_is_l3_master(struct net *net, int ifindex)
{
	return false;
}

static inline
struct dst_entry *l3mdev_link_scope_lookup(struct net *net, struct flowi6 *fl6)
{
	return NULL;
}

static inline
struct sk_buff *l3mdev_ip_rcv(struct sk_buff *skb)
{
	return skb;
}

static inline
struct sk_buff *l3mdev_ip6_rcv(struct sk_buff *skb)
{
	return skb;
}

static inline
struct sk_buff *l3mdev_ip_out(struct sock *sk, struct sk_buff *skb)
{
	return skb;
}

static inline
struct sk_buff *l3mdev_ip6_out(struct sock *sk, struct sk_buff *skb)
{
	return skb;
}

static inline
int l3mdev_table_lookup_register(enum l3mdev_type l3type,
				 lookup_by_table_id_t fn)
{
	return -EOPNOTSUPP;
}

static inline
void l3mdev_table_lookup_unregister(enum l3mdev_type l3type,
				    lookup_by_table_id_t fn)
{
}

static inline
int l3mdev_ifindex_lookup_by_table_id(enum l3mdev_type l3type, struct net *net,
				      u32 table_id)
{
	return -ENODEV;
}

static inline
int l3mdev_fib_rule_match(struct net *net, struct flowi *fl,
			  struct fib_lookup_arg *arg)
{
	return 1;
}
static inline
void l3mdev_update_flow(struct net *net, struct flowi *fl)
{
}
#endif

#endif /* _NET_L3MDEV_H_ */
Commit	Line	Data
2874c5fd	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
1b69c6d0 DA	2	/*
	3	* include/net/l3mdev.h - L3 master device API
	4	* Copyright (c) 2015 Cumulus Networks
	5	* Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
1b69c6d0 DA	6	*/
	7	#ifndef _NET_L3MDEV_H_
	8	#define _NET_L3MDEV_H_
	9
a8e3e1a9	10	#include <net/dst.h>
96c63fa7 DA	11	#include <net/fib_rules.h>
96c63fa7 DA	12
49042c22 AM	13	enum l3mdev_type {
	14	L3MDEV_TYPE_UNSPEC,
	15	L3MDEV_TYPE_VRF,
	16	__L3MDEV_TYPE_MAX
	17	};
	18
	19	#define L3MDEV_TYPE_MAX (__L3MDEV_TYPE_MAX - 1)
	20
	21	typedef int (lookup_by_table_id_t)(struct net net, u32 table_d);
	22
1b69c6d0 DA	23	/**
	24	* struct l3mdev_ops - l3mdev operations
	25	*
	26	* @l3mdev_fib_table: Get FIB table id to use for lookups
	27	*
a8e3e1a9 DA	28	* @l3mdev_l3_rcv: Hook in L3 receive path
	29	*
	30	* @l3mdev_l3_out: Hook in L3 output path
	31	*
4c1feac5	32	* @l3mdev_link_scope_lookup: IPv6 lookup for linklocal and mcast destinations
1b69c6d0 DA	33	*/
	34
	35	struct l3mdev_ops {
	36	u32 (l3mdev_fib_table)(const struct net_device dev);
74b20582 DA	37	struct sk_buff * (l3mdev_l3_rcv)(struct net_device dev,
74b20582 DA	38	struct sk_buff *skb, u16 proto);
a8e3e1a9 DA	39	struct sk_buff * (l3mdev_l3_out)(struct net_device dev,
	40	struct sock sk, struct sk_buff skb,
	41	u16 proto);
ccf3c8c3	42
ccf3c8c3	43	/* IPv6 ops */
4c1feac5	44	struct dst_entry * (l3mdev_link_scope_lookup)(const struct net_device dev,
cd2a9e62	45	struct flowi6 *fl6);
1b69c6d0 DA	46	};
	47
	48	#ifdef CONFIG_NET_L3_MASTER_DEV
	49
49042c22 AM	50	int l3mdev_table_lookup_register(enum l3mdev_type l3type,
	51	lookup_by_table_id_t fn);
	52
	53	void l3mdev_table_lookup_unregister(enum l3mdev_type l3type,
	54	lookup_by_table_id_t fn);
	55
	56	int l3mdev_ifindex_lookup_by_table_id(enum l3mdev_type l3type, struct net *net,
	57	u32 table_id);
	58
96c63fa7 DA	59	int l3mdev_fib_rule_match(struct net net, struct flowi fl,
	60	struct fib_lookup_arg *arg);
	61
9ee0034b DA	62	void l3mdev_update_flow(struct net net, struct flowi fl);
9ee0034b DA	63
3f2fb9a8	64	int l3mdev_master_ifindex_rcu(const struct net_device *dev);
1b69c6d0 DA	65	static inline int l3mdev_master_ifindex(struct net_device *dev)
	66	{
	67	int ifindex;
	68
	69	rcu_read_lock();
	70	ifindex = l3mdev_master_ifindex_rcu(dev);
	71	rcu_read_unlock();
	72
	73	return ifindex;
	74	}
	75
1a852479 DA	76	static inline int l3mdev_master_ifindex_by_index(struct net *net, int ifindex)
	77	{
	78	struct net_device *dev;
	79	int rc = 0;
	80
	81	if (likely(ifindex)) {
	82	rcu_read_lock();
	83
	84	dev = dev_get_by_index_rcu(net, ifindex);
	85	if (dev)
	86	rc = l3mdev_master_ifindex_rcu(dev);
	87
	88	rcu_read_unlock();
	89	}
	90
	91	return rc;
	92	}
	93
afbac601	94	static inline
5f02ce24	95	struct net_device l3mdev_master_dev_rcu(const struct net_device _dev)
afbac601 DA	96	{
	97	/* netdev_master_upper_dev_get_rcu calls
	98	* list_first_or_null_rcu to walk the upper dev list.
	99	* list_first_or_null_rcu does not handle a const arg. We aren't
	100	* making changes, just want the master device from that list so
	101	* typecast to remove the const
	102	*/
	103	struct net_device dev = (struct net_device )_dev;
5f02ce24	104	struct net_device *master;
afbac601 DA	105
	106	if (!dev)
	107	return NULL;
	108
	109	if (netif_is_l3_master(dev))
	110	master = dev;
	111	else if (netif_is_l3_slave(dev))
	112	master = netdev_master_upper_dev_get_rcu(dev);
	113	else
	114	master = NULL;
	115
	116	return master;
	117	}
	118
6a6d6681 AB	119	int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex);
	120	static inline
	121	int l3mdev_master_upper_ifindex_by_index(struct net *net, int ifindex)
	122	{
	123	rcu_read_lock();
	124	ifindex = l3mdev_master_upper_ifindex_by_index_rcu(net, ifindex);
	125	rcu_read_unlock();
	126
	127	return ifindex;
	128	}
	129
1b69c6d0 DA	130	u32 l3mdev_fib_table_rcu(const struct net_device *dev);
	131	u32 l3mdev_fib_table_by_index(struct net *net, int ifindex);
	132	static inline u32 l3mdev_fib_table(const struct net_device *dev)
	133	{
	134	u32 tb_id;
	135
	136	rcu_read_lock();
	137	tb_id = l3mdev_fib_table_rcu(dev);
	138	rcu_read_unlock();
	139
	140	return tb_id;
	141	}
	142
6104e112 DA	143	static inline bool netif_index_is_l3_master(struct net *net, int ifindex)
	144	{
	145	struct net_device *dev;
	146	bool rc = false;
	147
	148	if (ifindex == 0)
	149	return false;
	150
	151	rcu_read_lock();
	152
	153	dev = dev_get_by_index_rcu(net, ifindex);
	154	if (dev)
	155	rc = netif_is_l3_master(dev);
	156
	157	rcu_read_unlock();
	158
	159	return rc;
	160	}
	161
4c1feac5	162	struct dst_entry l3mdev_link_scope_lookup(struct net net, struct flowi6 *fl6);
ccf3c8c3	163
74b20582 DA	164	static inline
	165	struct sk_buff l3mdev_l3_rcv(struct sk_buff skb, u16 proto)
	166	{
	167	struct net_device *master = NULL;
	168
	169	if (netif_is_l3_slave(skb->dev))
	170	master = netdev_master_upper_dev_get_rcu(skb->dev);
d5256083 DB	171	else if (netif_is_l3_master(skb->dev) \|\|
d5256083 DB	172	netif_has_l3_rx_handler(skb->dev))
74b20582 DA	173	master = skb->dev;
	174
	175	if (master && master->l3mdev_ops->l3mdev_l3_rcv)
	176	skb = master->l3mdev_ops->l3mdev_l3_rcv(master, skb, proto);
	177
	178	return skb;
	179	}
	180
	181	static inline
	182	struct sk_buff l3mdev_ip_rcv(struct sk_buff skb)
	183	{
	184	return l3mdev_l3_rcv(skb, AF_INET);
	185	}
	186
	187	static inline
	188	struct sk_buff l3mdev_ip6_rcv(struct sk_buff skb)
	189	{
	190	return l3mdev_l3_rcv(skb, AF_INET6);
	191	}
	192
a8e3e1a9 DA	193	static inline
	194	struct sk_buff l3mdev_l3_out(struct sock sk, struct sk_buff *skb, u16 proto)
	195	{
	196	struct net_device *dev = skb_dst(skb)->dev;
	197
	198	if (netif_is_l3_slave(dev)) {
	199	struct net_device *master;
	200
	201	master = netdev_master_upper_dev_get_rcu(dev);
	202	if (master && master->l3mdev_ops->l3mdev_l3_out)
	203	skb = master->l3mdev_ops->l3mdev_l3_out(master, sk,
	204	skb, proto);
	205	}
	206
	207	return skb;
	208	}
	209
	210	static inline
	211	struct sk_buff l3mdev_ip_out(struct sock sk, struct sk_buff *skb)
	212	{
	213	return l3mdev_l3_out(sk, skb, AF_INET);
	214	}
	215
	216	static inline
	217	struct sk_buff l3mdev_ip6_out(struct sock sk, struct sk_buff *skb)
	218	{
	219	return l3mdev_l3_out(sk, skb, AF_INET6);
	220	}
1b69c6d0 DA	221	#else
1b69c6d0 DA	222
3f2fb9a8	223	static inline int l3mdev_master_ifindex_rcu(const struct net_device *dev)
1b69c6d0 DA	224	{
	225	return 0;
	226	}
	227	static inline int l3mdev_master_ifindex(struct net_device *dev)
	228	{
	229	return 0;
	230	}
	231
1a852479 DA	232	static inline int l3mdev_master_ifindex_by_index(struct net *net, int ifindex)
	233	{
	234	return 0;
	235	}
	236
6a6d6681 AB	237	static inline
	238	int l3mdev_master_upper_ifindex_by_index_rcu(struct net *net, int ifindex)
	239	{
	240	return 0;
	241	}
	242	static inline
	243	int l3mdev_master_upper_ifindex_by_index(struct net *net, int ifindex)
	244	{
	245	return 0;
	246	}
	247
afbac601	248	static inline
5f02ce24	249	struct net_device l3mdev_master_dev_rcu(const struct net_device dev)
afbac601 DA	250	{
	251	return NULL;
	252	}
	253
1b69c6d0 DA	254	static inline u32 l3mdev_fib_table_rcu(const struct net_device *dev)
	255	{
	256	return 0;
	257	}
	258	static inline u32 l3mdev_fib_table(const struct net_device *dev)
	259	{
	260	return 0;
	261	}
	262	static inline u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
	263	{
	264	return 0;
	265	}
	266
6104e112 DA	267	static inline bool netif_index_is_l3_master(struct net *net, int ifindex)
	268	{
	269	return false;
	270	}
	271
ccf3c8c3	272	static inline
4c1feac5	273	struct dst_entry l3mdev_link_scope_lookup(struct net net, struct flowi6 *fl6)
ccf3c8c3 DA	274	{
	275	return NULL;
	276	}
74b20582 DA	277
	278	static inline
	279	struct sk_buff l3mdev_ip_rcv(struct sk_buff skb)
	280	{
	281	return skb;
	282	}
	283
	284	static inline
	285	struct sk_buff l3mdev_ip6_rcv(struct sk_buff skb)
	286	{
	287	return skb;
	288	}
96c63fa7	289
a8e3e1a9 DA	290	static inline
	291	struct sk_buff l3mdev_ip_out(struct sock sk, struct sk_buff *skb)
	292	{
	293	return skb;
	294	}
	295
	296	static inline
	297	struct sk_buff l3mdev_ip6_out(struct sock sk, struct sk_buff *skb)
	298	{
	299	return skb;
	300	}
	301
49042c22 AM	302	static inline
	303	int l3mdev_table_lookup_register(enum l3mdev_type l3type,
	304	lookup_by_table_id_t fn)
	305	{
	306	return -EOPNOTSUPP;
	307	}
	308
	309	static inline
	310	void l3mdev_table_lookup_unregister(enum l3mdev_type l3type,
	311	lookup_by_table_id_t fn)
	312	{
	313	}
	314
	315	static inline
	316	int l3mdev_ifindex_lookup_by_table_id(enum l3mdev_type l3type, struct net *net,
	317	u32 table_id)
	318	{
	319	return -ENODEV;
	320	}
	321
96c63fa7 DA	322	static inline
	323	int l3mdev_fib_rule_match(struct net net, struct flowi fl,
	324	struct fib_lookup_arg *arg)
	325	{
	326	return 1;
	327	}
9ee0034b DA	328	static inline
	329	void l3mdev_update_flow(struct net net, struct flowi fl)
	330	{
	331	}
1b69c6d0 DA	332	#endif
	333
	334	#endif /* _NET_L3MDEV_H_ */