[mirror_ubuntu-jammy-kernel.git] / net / core / lwtunnel.c

/*
 * lwtunnel	Infrastructure for light weight tunnels like mpls
 *
 * Authors:	Roopa Prabhu, <roopa@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/capability.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/lwtunnel.h>
#include <linux/in.h>
#include <linux/init.h>
#include <linux/err.h>

#include <net/lwtunnel.h>
#include <net/rtnetlink.h>
#include <net/ip6_fib.h>
#include <net/rtnh.h>

#ifdef CONFIG_MODULES

static const char *lwtunnel_encap_str(enum lwtunnel_encap_types encap_type)
{
	/* Only lwt encaps implemented without using an interface for
	 * the encap need to return a string here.
	 */
	switch (encap_type) {
	case LWTUNNEL_ENCAP_MPLS:
		return "MPLS";
	case LWTUNNEL_ENCAP_ILA:
		return "ILA";
	case LWTUNNEL_ENCAP_SEG6:
		return "SEG6";
	case LWTUNNEL_ENCAP_BPF:
		return "BPF";
	case LWTUNNEL_ENCAP_SEG6_LOCAL:
		return "SEG6LOCAL";
	case LWTUNNEL_ENCAP_IP6:
	case LWTUNNEL_ENCAP_IP:
	case LWTUNNEL_ENCAP_NONE:
	case __LWTUNNEL_ENCAP_MAX:
		/* should not have got here */
		WARN_ON(1);
		break;
	}
	return NULL;
}

#endif /* CONFIG_MODULES */

struct lwtunnel_state *lwtunnel_state_alloc(int encap_len)
{
	struct lwtunnel_state *lws;

	lws = kzalloc(sizeof(*lws) + encap_len, GFP_ATOMIC);

	return lws;
}
EXPORT_SYMBOL_GPL(lwtunnel_state_alloc);

static const struct lwtunnel_encap_ops __rcu *
		lwtun_encaps[LWTUNNEL_ENCAP_MAX + 1] __read_mostly;

int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *ops,
			   unsigned int num)
{
	if (num > LWTUNNEL_ENCAP_MAX)
		return -ERANGE;

	return !cmpxchg((const struct lwtunnel_encap_ops **)
			&lwtun_encaps[num],
			NULL, ops) ? 0 : -1;
}
EXPORT_SYMBOL_GPL(lwtunnel_encap_add_ops);

int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *ops,
			   unsigned int encap_type)
{
	int ret;

	if (encap_type == LWTUNNEL_ENCAP_NONE ||
	    encap_type > LWTUNNEL_ENCAP_MAX)
		return -ERANGE;

	ret = (cmpxchg((const struct lwtunnel_encap_ops **)
		       &lwtun_encaps[encap_type],
		       ops, NULL) == ops) ? 0 : -1;

	synchronize_net();

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_encap_del_ops);

int lwtunnel_build_state(u16 encap_type,
			 struct nlattr *encap, unsigned int family,
			 const void *cfg, struct lwtunnel_state **lws,
			 struct netlink_ext_ack *extack)
{
	const struct lwtunnel_encap_ops *ops;
	bool found = false;
	int ret = -EINVAL;

	if (encap_type == LWTUNNEL_ENCAP_NONE ||
	    encap_type > LWTUNNEL_ENCAP_MAX) {
		NL_SET_ERR_MSG_ATTR(extack, encap,
				    "Unknown LWT encapsulation type");
		return ret;
	}

	ret = -EOPNOTSUPP;
	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[encap_type]);
	if (likely(ops && ops->build_state && try_module_get(ops->owner)))
		found = true;
	rcu_read_unlock();

	if (found) {
		ret = ops->build_state(encap, family, cfg, lws, extack);
		if (ret)
			module_put(ops->owner);
	} else {
		/* don't rely on -EOPNOTSUPP to detect match as build_state
		 * handlers could return it
		 */
		NL_SET_ERR_MSG_ATTR(extack, encap,
				    "LWT encapsulation type not supported");
	}

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_build_state);

int lwtunnel_valid_encap_type(u16 encap_type, struct netlink_ext_ack *extack)
{
	const struct lwtunnel_encap_ops *ops;
	int ret = -EINVAL;

	if (encap_type == LWTUNNEL_ENCAP_NONE ||
	    encap_type > LWTUNNEL_ENCAP_MAX) {
		NL_SET_ERR_MSG(extack, "Unknown lwt encapsulation type");
		return ret;
	}

	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[encap_type]);
	rcu_read_unlock();
#ifdef CONFIG_MODULES
	if (!ops) {
		const char *encap_type_str = lwtunnel_encap_str(encap_type);

		if (encap_type_str) {
			__rtnl_unlock();
			request_module("rtnl-lwt-%s", encap_type_str);
			rtnl_lock();

			rcu_read_lock();
			ops = rcu_dereference(lwtun_encaps[encap_type]);
			rcu_read_unlock();
		}
	}
#endif
	ret = ops ? 0 : -EOPNOTSUPP;
	if (ret < 0)
		NL_SET_ERR_MSG(extack, "lwt encapsulation type not supported");

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_valid_encap_type);

int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int remaining,
				   struct netlink_ext_ack *extack)
{
	struct rtnexthop *rtnh = (struct rtnexthop *)attr;
	struct nlattr *nla_entype;
	struct nlattr *attrs;
	u16 encap_type;
	int attrlen;

	while (rtnh_ok(rtnh, remaining)) {
		attrlen = rtnh_attrlen(rtnh);
		if (attrlen > 0) {
			attrs = rtnh_attrs(rtnh);
			nla_entype = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);

			if (nla_entype) {
				encap_type = nla_get_u16(nla_entype);

				if (lwtunnel_valid_encap_type(encap_type,
							      extack) != 0)
					return -EOPNOTSUPP;
			}
		}
		rtnh = rtnh_next(rtnh, &remaining);
	}

	return 0;
}
EXPORT_SYMBOL_GPL(lwtunnel_valid_encap_type_attr);

void lwtstate_free(struct lwtunnel_state *lws)
{
	const struct lwtunnel_encap_ops *ops = lwtun_encaps[lws->type];

	if (ops->destroy_state) {
		ops->destroy_state(lws);
		kfree_rcu(lws, rcu);
	} else {
		kfree(lws);
	}
	module_put(ops->owner);
}
EXPORT_SYMBOL_GPL(lwtstate_free);

int lwtunnel_fill_encap(struct sk_buff *skb, struct lwtunnel_state *lwtstate,
			int encap_attr, int encap_type_attr)
{
	const struct lwtunnel_encap_ops *ops;
	struct nlattr *nest;
	int ret;

	if (!lwtstate)
		return 0;

	if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
	    lwtstate->type > LWTUNNEL_ENCAP_MAX)
		return 0;

	nest = nla_nest_start(skb, encap_attr);
	if (!nest)
		return -EMSGSIZE;

	ret = -EOPNOTSUPP;
	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	if (likely(ops && ops->fill_encap))
		ret = ops->fill_encap(skb, lwtstate);
	rcu_read_unlock();

	if (ret)
		goto nla_put_failure;
	nla_nest_end(skb, nest);
	ret = nla_put_u16(skb, encap_type_attr, lwtstate->type);
	if (ret)
		goto nla_put_failure;

	return 0;

nla_put_failure:
	nla_nest_cancel(skb, nest);

	return (ret == -EOPNOTSUPP ? 0 : ret);
}
EXPORT_SYMBOL_GPL(lwtunnel_fill_encap);

int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
{
	const struct lwtunnel_encap_ops *ops;
	int ret = 0;

	if (!lwtstate)
		return 0;

	if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
	    lwtstate->type > LWTUNNEL_ENCAP_MAX)
		return 0;

	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	if (likely(ops && ops->get_encap_size))
		ret = nla_total_size(ops->get_encap_size(lwtstate));
	rcu_read_unlock();

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_get_encap_size);

int lwtunnel_cmp_encap(struct lwtunnel_state *a, struct lwtunnel_state *b)
{
	const struct lwtunnel_encap_ops *ops;
	int ret = 0;

	if (!a && !b)
		return 0;

	if (!a || !b)
		return 1;

	if (a->type != b->type)
		return 1;

	if (a->type == LWTUNNEL_ENCAP_NONE ||
	    a->type > LWTUNNEL_ENCAP_MAX)
		return 0;

	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[a->type]);
	if (likely(ops && ops->cmp_encap))
		ret = ops->cmp_encap(a, b);
	rcu_read_unlock();

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_cmp_encap);

int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	struct dst_entry *dst = skb_dst(skb);
	const struct lwtunnel_encap_ops *ops;
	struct lwtunnel_state *lwtstate;
	int ret = -EINVAL;

	if (!dst)
		goto drop;
	lwtstate = dst->lwtstate;

	if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
	    lwtstate->type > LWTUNNEL_ENCAP_MAX)
		return 0;

	ret = -EOPNOTSUPP;
	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	if (likely(ops && ops->output))
		ret = ops->output(net, sk, skb);
	rcu_read_unlock();

	if (ret == -EOPNOTSUPP)
		goto drop;

	return ret;

drop:
	kfree_skb(skb);

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_output);

int lwtunnel_xmit(struct sk_buff *skb)
{
	struct dst_entry *dst = skb_dst(skb);
	const struct lwtunnel_encap_ops *ops;
	struct lwtunnel_state *lwtstate;
	int ret = -EINVAL;

	if (!dst)
		goto drop;

	lwtstate = dst->lwtstate;

	if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
	    lwtstate->type > LWTUNNEL_ENCAP_MAX)
		return 0;

	ret = -EOPNOTSUPP;
	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	if (likely(ops && ops->xmit))
		ret = ops->xmit(skb);
	rcu_read_unlock();

	if (ret == -EOPNOTSUPP)
		goto drop;

	return ret;

drop:
	kfree_skb(skb);

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_xmit);

int lwtunnel_input(struct sk_buff *skb)
{
	struct dst_entry *dst = skb_dst(skb);
	const struct lwtunnel_encap_ops *ops;
	struct lwtunnel_state *lwtstate;
	int ret = -EINVAL;

	if (!dst)
		goto drop;
	lwtstate = dst->lwtstate;

	if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
	    lwtstate->type > LWTUNNEL_ENCAP_MAX)
		return 0;

	ret = -EOPNOTSUPP;
	rcu_read_lock();
	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	if (likely(ops && ops->input))
		ret = ops->input(skb);
	rcu_read_unlock();

	if (ret == -EOPNOTSUPP)
		goto drop;

	return ret;

drop:
	kfree_skb(skb);

	return ret;
}
EXPORT_SYMBOL_GPL(lwtunnel_input);
Commit	Line	Data
499a2425 RP	1	/*
	2	* lwtunnel Infrastructure for light weight tunnels like mpls
	3	*
	4	* Authors: Roopa Prabhu, <roopa@cumulusnetworks.com>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*
	11	*/
	12
	13	#include <linux/capability.h>
	14	#include <linux/module.h>
	15	#include <linux/types.h>
	16	#include <linux/kernel.h>
	17	#include <linux/slab.h>
	18	#include <linux/uaccess.h>
	19	#include <linux/skbuff.h>
	20	#include <linux/netdevice.h>
	21	#include <linux/lwtunnel.h>
	22	#include <linux/in.h>
	23	#include <linux/init.h>
	24	#include <linux/err.h>
	25
	26	#include <net/lwtunnel.h>
	27	#include <net/rtnetlink.h>
ffce4196	28	#include <net/ip6_fib.h>
3c618c1d	29	#include <net/rtnh.h>
499a2425	30
745041e2 RS	31	#ifdef CONFIG_MODULES
	32
	33	static const char *lwtunnel_encap_str(enum lwtunnel_encap_types encap_type)
	34	{
	35	/* Only lwt encaps implemented without using an interface for
	36	* the encap need to return a string here.
	37	*/
	38	switch (encap_type) {
	39	case LWTUNNEL_ENCAP_MPLS:
	40	return "MPLS";
	41	case LWTUNNEL_ENCAP_ILA:
	42	return "ILA";
6c8702c6 DL	43	case LWTUNNEL_ENCAP_SEG6:
6c8702c6 DL	44	return "SEG6";
3a0af8fd TG	45	case LWTUNNEL_ENCAP_BPF:
3a0af8fd TG	46	return "BPF";
d1df6fd8 DL	47	case LWTUNNEL_ENCAP_SEG6_LOCAL:
d1df6fd8 DL	48	return "SEG6LOCAL";
745041e2 RS	49	case LWTUNNEL_ENCAP_IP6:
	50	case LWTUNNEL_ENCAP_IP:
	51	case LWTUNNEL_ENCAP_NONE:
	52	case __LWTUNNEL_ENCAP_MAX:
	53	/* should not have got here */
	54	WARN_ON(1);
	55	break;
	56	}
	57	return NULL;
	58	}
	59
	60	#endif /* CONFIG_MODULES */
	61
499a2425 RP	62	struct lwtunnel_state *lwtunnel_state_alloc(int encap_len)
	63	{
	64	struct lwtunnel_state *lws;
	65
	66	lws = kzalloc(sizeof(*lws) + encap_len, GFP_ATOMIC);
	67
	68	return lws;
	69	}
08bd10ff	70	EXPORT_SYMBOL_GPL(lwtunnel_state_alloc);
499a2425	71
92a99bf3	72	static const struct lwtunnel_encap_ops __rcu *
499a2425 RP	73	lwtun_encaps[LWTUNNEL_ENCAP_MAX + 1] __read_mostly;
	74
	75	int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *ops,
	76	unsigned int num)
	77	{
	78	if (num > LWTUNNEL_ENCAP_MAX)
	79	return -ERANGE;
	80
	81	return !cmpxchg((const struct lwtunnel_encap_ops **)
	82	&lwtun_encaps[num],
	83	NULL, ops) ? 0 : -1;
	84	}
08bd10ff	85	EXPORT_SYMBOL_GPL(lwtunnel_encap_add_ops);
499a2425 RP	86
	87	int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *ops,
	88	unsigned int encap_type)
	89	{
	90	int ret;
	91
	92	if (encap_type == LWTUNNEL_ENCAP_NONE \|\|
	93	encap_type > LWTUNNEL_ENCAP_MAX)
	94	return -ERANGE;
	95
	96	ret = (cmpxchg((const struct lwtunnel_encap_ops **)
	97	&lwtun_encaps[encap_type],
	98	ops, NULL) == ops) ? 0 : -1;
	99
	100	synchronize_net();
	101
	102	return ret;
	103	}
08bd10ff	104	EXPORT_SYMBOL_GPL(lwtunnel_encap_del_ops);
499a2425	105
30357d7d	106	int lwtunnel_build_state(u16 encap_type,
127eb7cd	107	struct nlattr *encap, unsigned int family,
9ae28727 DA	108	const void cfg, struct lwtunnel_state *lws,
9ae28727 DA	109	struct netlink_ext_ack *extack)
499a2425 RP	110	{
499a2425 RP	111	const struct lwtunnel_encap_ops *ops;
9ae28727	112	bool found = false;
499a2425 RP	113	int ret = -EINVAL;
	114
	115	if (encap_type == LWTUNNEL_ENCAP_NONE \|\|
9ae28727 DA	116	encap_type > LWTUNNEL_ENCAP_MAX) {
	117	NL_SET_ERR_MSG_ATTR(extack, encap,
	118	"Unknown LWT encapsulation type");
499a2425	119	return ret;
9ae28727	120	}
499a2425 RP	121
	122	ret = -EOPNOTSUPP;
	123	rcu_read_lock();
	124	ops = rcu_dereference(lwtun_encaps[encap_type]);
3d25eabb	125	if (likely(ops && ops->build_state && try_module_get(ops->owner)))
9ae28727	126	found = true;
3d25eabb	127	rcu_read_unlock();
	128
	129	if (found) {
9ae28727	130	ret = ops->build_state(encap, family, cfg, lws, extack);
85c81401 RS	131	if (ret)
85c81401 RS	132	module_put(ops->owner);
3d25eabb	133	} else {
	134	/* don't rely on -EOPNOTSUPP to detect match as build_state
	135	* handlers could return it
	136	*/
9ae28727 DA	137	NL_SET_ERR_MSG_ATTR(extack, encap,
	138	"LWT encapsulation type not supported");
	139	}
	140
9ed59592 DA	141	return ret;
9ed59592 DA	142	}
08bd10ff	143	EXPORT_SYMBOL_GPL(lwtunnel_build_state);
9ed59592	144
c255bd68	145	int lwtunnel_valid_encap_type(u16 encap_type, struct netlink_ext_ack *extack)
9ed59592 DA	146	{
	147	const struct lwtunnel_encap_ops *ops;
	148	int ret = -EINVAL;
	149
	150	if (encap_type == LWTUNNEL_ENCAP_NONE \|\|
c255bd68 DA	151	encap_type > LWTUNNEL_ENCAP_MAX) {
c255bd68 DA	152	NL_SET_ERR_MSG(extack, "Unknown lwt encapsulation type");
9ed59592	153	return ret;
c255bd68	154	}
9ed59592 DA	155
	156	rcu_read_lock();
	157	ops = rcu_dereference(lwtun_encaps[encap_type]);
	158	rcu_read_unlock();
745041e2 RS	159	#ifdef CONFIG_MODULES
	160	if (!ops) {
	161	const char *encap_type_str = lwtunnel_encap_str(encap_type);
	162
	163	if (encap_type_str) {
9ed59592	164	__rtnl_unlock();
745041e2	165	request_module("rtnl-lwt-%s", encap_type_str);
9ed59592 DA	166	rtnl_lock();
9ed59592 DA	167
745041e2 RS	168	rcu_read_lock();
745041e2 RS	169	ops = rcu_dereference(lwtun_encaps[encap_type]);
9ed59592	170	rcu_read_unlock();
745041e2 RS	171	}
	172	}
	173	#endif
c255bd68 DA	174	ret = ops ? 0 : -EOPNOTSUPP;
	175	if (ret < 0)
	176	NL_SET_ERR_MSG(extack, "lwt encapsulation type not supported");
	177
	178	return ret;
9ed59592	179	}
08bd10ff	180	EXPORT_SYMBOL_GPL(lwtunnel_valid_encap_type);
499a2425	181
c255bd68 DA	182	int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int remaining,
c255bd68 DA	183	struct netlink_ext_ack *extack)
9ed59592 DA	184	{
	185	struct rtnexthop rtnh = (struct rtnexthop )attr;
	186	struct nlattr *nla_entype;
	187	struct nlattr *attrs;
9ed59592 DA	188	u16 encap_type;
	189	int attrlen;
	190
	191	while (rtnh_ok(rtnh, remaining)) {
	192	attrlen = rtnh_attrlen(rtnh);
	193	if (attrlen > 0) {
	194	attrs = rtnh_attrs(rtnh);
9ed59592 DA	195	nla_entype = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
	196
	197	if (nla_entype) {
	198	encap_type = nla_get_u16(nla_entype);
	199
c255bd68 DA	200	if (lwtunnel_valid_encap_type(encap_type,
c255bd68 DA	201	extack) != 0)
9ed59592 DA	202	return -EOPNOTSUPP;
	203	}
	204	}
	205	rtnh = rtnh_next(rtnh, &remaining);
	206	}
	207
	208	return 0;
499a2425	209	}
08bd10ff	210	EXPORT_SYMBOL_GPL(lwtunnel_valid_encap_type_attr);
499a2425	211
1104d9ba TH	212	void lwtstate_free(struct lwtunnel_state *lws)
	213	{
	214	const struct lwtunnel_encap_ops *ops = lwtun_encaps[lws->type];
	215
	216	if (ops->destroy_state) {
	217	ops->destroy_state(lws);
	218	kfree_rcu(lws, rcu);
	219	} else {
	220	kfree(lws);
	221	}
85c81401	222	module_put(ops->owner);
1104d9ba	223	}
08bd10ff	224	EXPORT_SYMBOL_GPL(lwtstate_free);
1104d9ba	225
ffa8ce54 DA	226	int lwtunnel_fill_encap(struct sk_buff skb, struct lwtunnel_state lwtstate,
ffa8ce54 DA	227	int encap_attr, int encap_type_attr)
499a2425 RP	228	{
	229	const struct lwtunnel_encap_ops *ops;
	230	struct nlattr *nest;
39f37095	231	int ret;
499a2425 RP	232
	233	if (!lwtstate)
	234	return 0;
	235
	236	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	237	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	238	return 0;
	239
ffa8ce54	240	nest = nla_nest_start(skb, encap_attr);
a50fe0ff	241	if (!nest)
39f37095 DC	242	return -EMSGSIZE;
	243
	244	ret = -EOPNOTSUPP;
499a2425 RP	245	rcu_read_lock();
	246	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	247	if (likely(ops && ops->fill_encap))
	248	ret = ops->fill_encap(skb, lwtstate);
	249	rcu_read_unlock();
	250
	251	if (ret)
	252	goto nla_put_failure;
	253	nla_nest_end(skb, nest);
ffa8ce54	254	ret = nla_put_u16(skb, encap_type_attr, lwtstate->type);
499a2425 RP	255	if (ret)
	256	goto nla_put_failure;
	257
	258	return 0;
	259
	260	nla_put_failure:
	261	nla_nest_cancel(skb, nest);
	262
	263	return (ret == -EOPNOTSUPP ? 0 : ret);
	264	}
08bd10ff	265	EXPORT_SYMBOL_GPL(lwtunnel_fill_encap);
499a2425 RP	266
	267	int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
	268	{
	269	const struct lwtunnel_encap_ops *ops;
	270	int ret = 0;
	271
	272	if (!lwtstate)
	273	return 0;
	274
	275	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	276	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	277	return 0;
	278
	279	rcu_read_lock();
	280	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	281	if (likely(ops && ops->get_encap_size))
	282	ret = nla_total_size(ops->get_encap_size(lwtstate));
	283	rcu_read_unlock();
	284
	285	return ret;
	286	}
08bd10ff	287	EXPORT_SYMBOL_GPL(lwtunnel_get_encap_size);
499a2425 RP	288
	289	int lwtunnel_cmp_encap(struct lwtunnel_state a, struct lwtunnel_state b)
	290	{
	291	const struct lwtunnel_encap_ops *ops;
	292	int ret = 0;
	293
	294	if (!a && !b)
	295	return 0;
	296
	297	if (!a \|\| !b)
	298	return 1;
	299
	300	if (a->type != b->type)
	301	return 1;
	302
	303	if (a->type == LWTUNNEL_ENCAP_NONE \|\|
	304	a->type > LWTUNNEL_ENCAP_MAX)
	305	return 0;
	306
	307	rcu_read_lock();
	308	ops = rcu_dereference(lwtun_encaps[a->type]);
	309	if (likely(ops && ops->cmp_encap))
	310	ret = ops->cmp_encap(a, b);
	311	rcu_read_unlock();
	312
	313	return ret;
	314	}
08bd10ff	315	EXPORT_SYMBOL_GPL(lwtunnel_cmp_encap);
ffce4196	316
ede2059d	317	int lwtunnel_output(struct net net, struct sock sk, struct sk_buff *skb)
ffce4196	318	{
61adedf3	319	struct dst_entry *dst = skb_dst(skb);
ffce4196	320	const struct lwtunnel_encap_ops *ops;
61adedf3	321	struct lwtunnel_state *lwtstate;
ffce4196 RP	322	int ret = -EINVAL;
ffce4196 RP	323
61adedf3	324	if (!dst)
ffce4196	325	goto drop;
61adedf3	326	lwtstate = dst->lwtstate;
ffce4196 RP	327
	328	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	329	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	330	return 0;
	331
	332	ret = -EOPNOTSUPP;
	333	rcu_read_lock();
	334	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	335	if (likely(ops && ops->output))
ede2059d	336	ret = ops->output(net, sk, skb);
ffce4196 RP	337	rcu_read_unlock();
	338
	339	if (ret == -EOPNOTSUPP)
	340	goto drop;
	341
	342	return ret;
	343
	344	drop:
e11f40b9	345	kfree_skb(skb);
ffce4196 RP	346
	347	return ret;
	348	}
08bd10ff	349	EXPORT_SYMBOL_GPL(lwtunnel_output);
25368623	350
14972cbd RP	351	int lwtunnel_xmit(struct sk_buff *skb)
	352	{
	353	struct dst_entry *dst = skb_dst(skb);
	354	const struct lwtunnel_encap_ops *ops;
	355	struct lwtunnel_state *lwtstate;
	356	int ret = -EINVAL;
	357
	358	if (!dst)
	359	goto drop;
	360
	361	lwtstate = dst->lwtstate;
	362
	363	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	364	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	365	return 0;
	366
	367	ret = -EOPNOTSUPP;
	368	rcu_read_lock();
	369	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	370	if (likely(ops && ops->xmit))
	371	ret = ops->xmit(skb);
	372	rcu_read_unlock();
	373
	374	if (ret == -EOPNOTSUPP)
	375	goto drop;
	376
	377	return ret;
	378
	379	drop:
	380	kfree_skb(skb);
	381
	382	return ret;
	383	}
08bd10ff	384	EXPORT_SYMBOL_GPL(lwtunnel_xmit);
14972cbd	385
61adedf3	386	int lwtunnel_input(struct sk_buff *skb)
25368623	387	{
61adedf3	388	struct dst_entry *dst = skb_dst(skb);
25368623	389	const struct lwtunnel_encap_ops *ops;
61adedf3	390	struct lwtunnel_state *lwtstate;
25368623 TH	391	int ret = -EINVAL;
25368623 TH	392
61adedf3	393	if (!dst)
25368623	394	goto drop;
61adedf3	395	lwtstate = dst->lwtstate;
25368623 TH	396
	397	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	398	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	399	return 0;
	400
	401	ret = -EOPNOTSUPP;
	402	rcu_read_lock();
	403	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	404	if (likely(ops && ops->input))
	405	ret = ops->input(skb);
	406	rcu_read_unlock();
	407
	408	if (ret == -EOPNOTSUPP)
	409	goto drop;
	410
	411	return ret;
	412
	413	drop:
	414	kfree_skb(skb);
	415
	416	return ret;
	417	}
08bd10ff	418	EXPORT_SYMBOL_GPL(lwtunnel_input);