[deliverable/linux.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>

#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_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(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(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(lwtunnel_encap_del_ops);

int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
			 struct nlattr *encap, unsigned int family,
			 const void *cfg, struct lwtunnel_state **lws)
{
	const struct lwtunnel_encap_ops *ops;
	int ret = -EINVAL;

	if (encap_type == LWTUNNEL_ENCAP_NONE ||
	    encap_type > LWTUNNEL_ENCAP_MAX)
		return ret;

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

		if (encap_type_str) {
			rcu_read_unlock();
			request_module("rtnl-lwt-%s", encap_type_str);
			rcu_read_lock();
			ops = rcu_dereference(lwtun_encaps[encap_type]);
		}
	}
#endif
	if (likely(ops && ops->build_state))
		ret = ops->build_state(dev, encap, family, cfg, lws);
	rcu_read_unlock();

	return ret;
}
EXPORT_SYMBOL(lwtunnel_build_state);

int lwtunnel_fill_encap(struct sk_buff *skb, struct lwtunnel_state *lwtstate)
{
	const struct lwtunnel_encap_ops *ops;
	struct nlattr *nest;
	int ret = -EINVAL;

	if (!lwtstate)
		return 0;

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

	ret = -EOPNOTSUPP;
	nest = nla_nest_start(skb, RTA_ENCAP);
	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, RTA_ENCAP_TYPE, 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(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(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(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(lwtunnel_output);

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(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>
499a2425	29
745041e2 RS	30	#ifdef CONFIG_MODULES
	31
	32	static const char *lwtunnel_encap_str(enum lwtunnel_encap_types encap_type)
	33	{
	34	/* Only lwt encaps implemented without using an interface for
	35	* the encap need to return a string here.
	36	*/
	37	switch (encap_type) {
	38	case LWTUNNEL_ENCAP_MPLS:
	39	return "MPLS";
	40	case LWTUNNEL_ENCAP_ILA:
	41	return "ILA";
	42	case LWTUNNEL_ENCAP_IP6:
	43	case LWTUNNEL_ENCAP_IP:
	44	case LWTUNNEL_ENCAP_NONE:
	45	case __LWTUNNEL_ENCAP_MAX:
	46	/* should not have got here */
	47	WARN_ON(1);
	48	break;
	49	}
	50	return NULL;
	51	}
	52
	53	#endif /* CONFIG_MODULES */
	54
499a2425 RP	55	struct lwtunnel_state *lwtunnel_state_alloc(int encap_len)
	56	{
	57	struct lwtunnel_state *lws;
	58
	59	lws = kzalloc(sizeof(*lws) + encap_len, GFP_ATOMIC);
	60
	61	return lws;
	62	}
	63	EXPORT_SYMBOL(lwtunnel_state_alloc);
	64
92a99bf3	65	static const struct lwtunnel_encap_ops __rcu *
499a2425 RP	66	lwtun_encaps[LWTUNNEL_ENCAP_MAX + 1] __read_mostly;
	67
	68	int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *ops,
	69	unsigned int num)
	70	{
	71	if (num > LWTUNNEL_ENCAP_MAX)
	72	return -ERANGE;
	73
	74	return !cmpxchg((const struct lwtunnel_encap_ops **)
	75	&lwtun_encaps[num],
	76	NULL, ops) ? 0 : -1;
	77	}
	78	EXPORT_SYMBOL(lwtunnel_encap_add_ops);
	79
	80	int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *ops,
	81	unsigned int encap_type)
	82	{
	83	int ret;
	84
	85	if (encap_type == LWTUNNEL_ENCAP_NONE \|\|
	86	encap_type > LWTUNNEL_ENCAP_MAX)
	87	return -ERANGE;
	88
	89	ret = (cmpxchg((const struct lwtunnel_encap_ops **)
	90	&lwtun_encaps[encap_type],
	91	ops, NULL) == ops) ? 0 : -1;
	92
	93	synchronize_net();
	94
	95	return ret;
	96	}
	97	EXPORT_SYMBOL(lwtunnel_encap_del_ops);
	98
	99	int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
127eb7cd TH	100	struct nlattr *encap, unsigned int family,
127eb7cd TH	101	const void cfg, struct lwtunnel_state *lws)
499a2425 RP	102	{
	103	const struct lwtunnel_encap_ops *ops;
	104	int ret = -EINVAL;
	105
	106	if (encap_type == LWTUNNEL_ENCAP_NONE \|\|
	107	encap_type > LWTUNNEL_ENCAP_MAX)
	108	return ret;
	109
	110	ret = -EOPNOTSUPP;
	111	rcu_read_lock();
	112	ops = rcu_dereference(lwtun_encaps[encap_type]);
745041e2 RS	113	#ifdef CONFIG_MODULES
	114	if (!ops) {
	115	const char *encap_type_str = lwtunnel_encap_str(encap_type);
	116
	117	if (encap_type_str) {
	118	rcu_read_unlock();
	119	request_module("rtnl-lwt-%s", encap_type_str);
	120	rcu_read_lock();
	121	ops = rcu_dereference(lwtun_encaps[encap_type]);
	122	}
	123	}
	124	#endif
499a2425	125	if (likely(ops && ops->build_state))
127eb7cd	126	ret = ops->build_state(dev, encap, family, cfg, lws);
499a2425 RP	127	rcu_read_unlock();
	128
	129	return ret;
	130	}
	131	EXPORT_SYMBOL(lwtunnel_build_state);
	132
	133	int lwtunnel_fill_encap(struct sk_buff skb, struct lwtunnel_state lwtstate)
	134	{
	135	const struct lwtunnel_encap_ops *ops;
	136	struct nlattr *nest;
	137	int ret = -EINVAL;
	138
	139	if (!lwtstate)
	140	return 0;
	141
	142	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	143	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	144	return 0;
	145
	146	ret = -EOPNOTSUPP;
	147	nest = nla_nest_start(skb, RTA_ENCAP);
	148	rcu_read_lock();
	149	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	150	if (likely(ops && ops->fill_encap))
	151	ret = ops->fill_encap(skb, lwtstate);
	152	rcu_read_unlock();
	153
	154	if (ret)
	155	goto nla_put_failure;
	156	nla_nest_end(skb, nest);
	157	ret = nla_put_u16(skb, RTA_ENCAP_TYPE, lwtstate->type);
	158	if (ret)
	159	goto nla_put_failure;
	160
	161	return 0;
	162
	163	nla_put_failure:
	164	nla_nest_cancel(skb, nest);
	165
	166	return (ret == -EOPNOTSUPP ? 0 : ret);
	167	}
	168	EXPORT_SYMBOL(lwtunnel_fill_encap);
	169
	170	int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
	171	{
	172	const struct lwtunnel_encap_ops *ops;
	173	int ret = 0;
	174
	175	if (!lwtstate)
	176	return 0;
	177
	178	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	179	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	180	return 0;
	181
	182	rcu_read_lock();
	183	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	184	if (likely(ops && ops->get_encap_size))
	185	ret = nla_total_size(ops->get_encap_size(lwtstate));
	186	rcu_read_unlock();
	187
	188	return ret;
	189	}
	190	EXPORT_SYMBOL(lwtunnel_get_encap_size);
191
192	int lwtunnel_cmp_encap(struct lwtunnel_state a, struct lwtunnel_state b)
193	{
194	const struct lwtunnel_encap_ops *ops;
195	int ret = 0;
196
197	if (!a && !b)
198	return 0;
199
200	if (!a \|\| !b)
201	return 1;
202
203	if (a->type != b->type)
204	return 1;
205
206	if (a->type == LWTUNNEL_ENCAP_NONE \|\|
207	a->type > LWTUNNEL_ENCAP_MAX)
208	return 0;
209
210	rcu_read_lock();
211	ops = rcu_dereference(lwtun_encaps[a->type]);
212	if (likely(ops && ops->cmp_encap))
213	ret = ops->cmp_encap(a, b);
214	rcu_read_unlock();
215
216	return ret;
217	}
218	EXPORT_SYMBOL(lwtunnel_cmp_encap);
ffce4196	219
ede2059d	220	int lwtunnel_output(struct net net, struct sock sk, struct sk_buff *skb)
ffce4196	221	{
61adedf3	222	struct dst_entry *dst = skb_dst(skb);
ffce4196	223	const struct lwtunnel_encap_ops *ops;
61adedf3	224	struct lwtunnel_state *lwtstate;
ffce4196 RP	225	int ret = -EINVAL;
ffce4196 RP	226
61adedf3	227	if (!dst)
ffce4196	228	goto drop;
61adedf3	229	lwtstate = dst->lwtstate;
ffce4196 RP	230
	231	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	232	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	233	return 0;
	234
	235	ret = -EOPNOTSUPP;
	236	rcu_read_lock();
	237	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	238	if (likely(ops && ops->output))
ede2059d	239	ret = ops->output(net, sk, skb);
ffce4196 RP	240	rcu_read_unlock();
	241
	242	if (ret == -EOPNOTSUPP)
	243	goto drop;
	244
	245	return ret;
	246
	247	drop:
e11f40b9	248	kfree_skb(skb);
ffce4196 RP	249
	250	return ret;
	251	}
ffce4196	252	EXPORT_SYMBOL(lwtunnel_output);
25368623	253
61adedf3	254	int lwtunnel_input(struct sk_buff *skb)
25368623	255	{
61adedf3	256	struct dst_entry *dst = skb_dst(skb);
25368623	257	const struct lwtunnel_encap_ops *ops;
61adedf3	258	struct lwtunnel_state *lwtstate;
25368623 TH	259	int ret = -EINVAL;
25368623 TH	260
61adedf3	261	if (!dst)
25368623	262	goto drop;
61adedf3	263	lwtstate = dst->lwtstate;
25368623 TH	264
	265	if (lwtstate->type == LWTUNNEL_ENCAP_NONE \|\|
	266	lwtstate->type > LWTUNNEL_ENCAP_MAX)
	267	return 0;
	268
	269	ret = -EOPNOTSUPP;
	270	rcu_read_lock();
	271	ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
	272	if (likely(ops && ops->input))
	273	ret = ops->input(skb);
	274	rcu_read_unlock();
	275
	276	if (ret == -EOPNOTSUPP)
	277	goto drop;
	278
	279	return ret;
	280
	281	drop:
	282	kfree_skb(skb);
	283
	284	return ret;
	285	}
25368623	286	EXPORT_SYMBOL(lwtunnel_input);