[linux-block.git] / net / core / lwtunnel.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * lwtunnel	Infrastructure for light weight tunnels like mpls
 *
 * Authors:	Roopa Prabhu, <roopa@cumulusnetworks.com>
 */

#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>

DEFINE_STATIC_KEY_FALSE(nf_hooks_lwtunnel_enabled);
EXPORT_SYMBOL_GPL(nf_hooks_lwtunnel_enabled);

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