[mirror_ubuntu-bionic-kernel.git] / include / net / lwtunnel.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __NET_LWTUNNEL_H
#define __NET_LWTUNNEL_H 1

#include <linux/lwtunnel.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/types.h>
#include <net/route.h>

#define LWTUNNEL_HASH_BITS   7
#define LWTUNNEL_HASH_SIZE   (1 << LWTUNNEL_HASH_BITS)

/* lw tunnel state flags */
#define LWTUNNEL_STATE_OUTPUT_REDIRECT	BIT(0)
#define LWTUNNEL_STATE_INPUT_REDIRECT	BIT(1)
#define LWTUNNEL_STATE_XMIT_REDIRECT	BIT(2)

enum {
	LWTUNNEL_XMIT_DONE,
	LWTUNNEL_XMIT_CONTINUE,
};


struct lwtunnel_state {
	__u16		type;
	__u16		flags;
	__u16		headroom;
	atomic_t	refcnt;
	int		(*orig_output)(struct net *net, struct sock *sk, struct sk_buff *skb);
	int		(*orig_input)(struct sk_buff *);
	struct		rcu_head rcu;
	__u8            data[0];
};

struct lwtunnel_encap_ops {
	int (*build_state)(struct nlattr *encap,
			   unsigned int family, const void *cfg,
			   struct lwtunnel_state **ts,
			   struct netlink_ext_ack *extack);
	void (*destroy_state)(struct lwtunnel_state *lws);
	int (*output)(struct net *net, struct sock *sk, struct sk_buff *skb);
	int (*input)(struct sk_buff *skb);
	int (*fill_encap)(struct sk_buff *skb,
			  struct lwtunnel_state *lwtstate);
	int (*get_encap_size)(struct lwtunnel_state *lwtstate);
	int (*cmp_encap)(struct lwtunnel_state *a, struct lwtunnel_state *b);
	int (*xmit)(struct sk_buff *skb);

	struct module *owner;
};

#ifdef CONFIG_LWTUNNEL
void lwtstate_free(struct lwtunnel_state *lws);

static inline struct lwtunnel_state *
lwtstate_get(struct lwtunnel_state *lws)
{
	if (lws)
		atomic_inc(&lws->refcnt);

	return lws;
}

static inline void lwtstate_put(struct lwtunnel_state *lws)
{
	if (!lws)
		return;

	if (atomic_dec_and_test(&lws->refcnt))
		lwtstate_free(lws);
}

static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
{
	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_OUTPUT_REDIRECT))
		return true;

	return false;
}

static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
{
	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_INPUT_REDIRECT))
		return true;

	return false;
}

static inline bool lwtunnel_xmit_redirect(struct lwtunnel_state *lwtstate)
{
	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_XMIT_REDIRECT))
		return true;

	return false;
}

static inline unsigned int lwtunnel_headroom(struct lwtunnel_state *lwtstate,
					     unsigned int mtu)
{
	if ((lwtunnel_xmit_redirect(lwtstate) ||
	     lwtunnel_output_redirect(lwtstate)) && lwtstate->headroom < mtu)
		return lwtstate->headroom;

	return 0;
}

int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
			   unsigned int num);
int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
			   unsigned int num);
int lwtunnel_valid_encap_type(u16 encap_type,
			      struct netlink_ext_ack *extack);
int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int len,
				   struct netlink_ext_ack *extack);
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);
int lwtunnel_fill_encap(struct sk_buff *skb,
			struct lwtunnel_state *lwtstate);
int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate);
struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len);
int lwtunnel_cmp_encap(struct lwtunnel_state *a, struct lwtunnel_state *b);
int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb);
int lwtunnel_input(struct sk_buff *skb);
int lwtunnel_xmit(struct sk_buff *skb);

#else

static inline void lwtstate_free(struct lwtunnel_state *lws)
{
}

static inline struct lwtunnel_state *
lwtstate_get(struct lwtunnel_state *lws)
{
	return lws;
}

static inline void lwtstate_put(struct lwtunnel_state *lws)
{
}

static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
{
	return false;
}

static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
{
	return false;
}

static inline bool lwtunnel_xmit_redirect(struct lwtunnel_state *lwtstate)
{
	return false;
}

static inline unsigned int lwtunnel_headroom(struct lwtunnel_state *lwtstate,
					     unsigned int mtu)
{
	return 0;
}

static inline int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
					 unsigned int num)
{
	return -EOPNOTSUPP;

}

static inline int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
					 unsigned int num)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_valid_encap_type(u16 encap_type,
					    struct netlink_ext_ack *extack)
{
	NL_SET_ERR_MSG(extack, "CONFIG_LWTUNNEL is not enabled in this kernel");
	return -EOPNOTSUPP;
}
static inline int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int len,
						 struct netlink_ext_ack *extack)
{
	/* return 0 since we are not walking attr looking for
	 * RTA_ENCAP_TYPE attribute on nexthops.
	 */
	return 0;
}

static inline 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)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_fill_encap(struct sk_buff *skb,
				      struct lwtunnel_state *lwtstate)
{
	return 0;
}

static inline int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
{
	return 0;
}

static inline struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len)
{
	return NULL;
}

static inline int lwtunnel_cmp_encap(struct lwtunnel_state *a,
				     struct lwtunnel_state *b)
{
	return 0;
}

static inline int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_input(struct sk_buff *skb)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_xmit(struct sk_buff *skb)
{
	return -EOPNOTSUPP;
}

#endif /* CONFIG_LWTUNNEL */

#define MODULE_ALIAS_RTNL_LWT(encap_type) MODULE_ALIAS("rtnl-lwt-" __stringify(encap_type))

#endif /* __NET_LWTUNNEL_H */
Commit	Line	Data
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __NET_LWTUNNEL_H
	3	#define __NET_LWTUNNEL_H 1
	4
	5	#include <linux/lwtunnel.h>
	6	#include <linux/netdevice.h>
	7	#include <linux/skbuff.h>
	8	#include <linux/types.h>
	9	#include <net/route.h>
	10
	11	#define LWTUNNEL_HASH_BITS 7
	12	#define LWTUNNEL_HASH_SIZE (1 << LWTUNNEL_HASH_BITS)
	13
	14	/* lw tunnel state flags */
	15	#define LWTUNNEL_STATE_OUTPUT_REDIRECT BIT(0)
	16	#define LWTUNNEL_STATE_INPUT_REDIRECT BIT(1)
	17	#define LWTUNNEL_STATE_XMIT_REDIRECT BIT(2)
	18
	19	enum {
	20	LWTUNNEL_XMIT_DONE,
	21	LWTUNNEL_XMIT_CONTINUE,
	22	};
	23
	24
	25	struct lwtunnel_state {
	26	__u16 type;
	27	__u16 flags;
	28	__u16 headroom;
	29	atomic_t refcnt;
	30	int (orig_output)(struct net net, struct sock sk, struct sk_buff skb);
	31	int (orig_input)(struct sk_buff );
	32	struct rcu_head rcu;
	33	__u8 data[0];
	34	};
	35
	36	struct lwtunnel_encap_ops {
	37	int (build_state)(struct nlattr encap,
	38	unsigned int family, const void *cfg,
	39	struct lwtunnel_state **ts,
	40	struct netlink_ext_ack *extack);
	41	void (destroy_state)(struct lwtunnel_state lws);
	42	int (output)(struct net net, struct sock sk, struct sk_buff skb);
	43	int (input)(struct sk_buff skb);
	44	int (fill_encap)(struct sk_buff skb,
	45	struct lwtunnel_state *lwtstate);
	46	int (get_encap_size)(struct lwtunnel_state lwtstate);
	47	int (cmp_encap)(struct lwtunnel_state a, struct lwtunnel_state *b);
	48	int (xmit)(struct sk_buff skb);
	49
	50	struct module *owner;
	51	};
	52
	53	#ifdef CONFIG_LWTUNNEL
	54	void lwtstate_free(struct lwtunnel_state *lws);
	55
	56	static inline struct lwtunnel_state *
	57	lwtstate_get(struct lwtunnel_state *lws)
	58	{
	59	if (lws)
	60	atomic_inc(&lws->refcnt);
	61
	62	return lws;
	63	}
	64
	65	static inline void lwtstate_put(struct lwtunnel_state *lws)
	66	{
	67	if (!lws)
	68	return;
	69
	70	if (atomic_dec_and_test(&lws->refcnt))
	71	lwtstate_free(lws);
	72	}
	73
	74	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	75	{
	76	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_OUTPUT_REDIRECT))
	77	return true;
	78
	79	return false;
	80	}
	81
	82	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	83	{
	84	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_INPUT_REDIRECT))
	85	return true;
	86
	87	return false;
	88	}
	89
	90	static inline bool lwtunnel_xmit_redirect(struct lwtunnel_state *lwtstate)
	91	{
	92	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_XMIT_REDIRECT))
	93	return true;
	94
	95	return false;
	96	}
	97
	98	static inline unsigned int lwtunnel_headroom(struct lwtunnel_state *lwtstate,
	99	unsigned int mtu)
	100	{
	101	if ((lwtunnel_xmit_redirect(lwtstate) \|\|
	102	lwtunnel_output_redirect(lwtstate)) && lwtstate->headroom < mtu)
	103	return lwtstate->headroom;
	104
	105	return 0;
	106	}
	107
	108	int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	109	unsigned int num);
	110	int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	111	unsigned int num);
	112	int lwtunnel_valid_encap_type(u16 encap_type,
	113	struct netlink_ext_ack *extack);
	114	int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int len,
	115	struct netlink_ext_ack *extack);
	116	int lwtunnel_build_state(u16 encap_type,
	117	struct nlattr *encap,
	118	unsigned int family, const void *cfg,
	119	struct lwtunnel_state **lws,
	120	struct netlink_ext_ack *extack);
	121	int lwtunnel_fill_encap(struct sk_buff *skb,
	122	struct lwtunnel_state *lwtstate);
	123	int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate);
	124	struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len);
	125	int lwtunnel_cmp_encap(struct lwtunnel_state a, struct lwtunnel_state b);
	126	int lwtunnel_output(struct net net, struct sock sk, struct sk_buff *skb);
	127	int lwtunnel_input(struct sk_buff *skb);
	128	int lwtunnel_xmit(struct sk_buff *skb);
	129
	130	#else
	131
	132	static inline void lwtstate_free(struct lwtunnel_state *lws)
	133	{
	134	}
	135
	136	static inline struct lwtunnel_state *
	137	lwtstate_get(struct lwtunnel_state *lws)
	138	{
	139	return lws;
	140	}
	141
	142	static inline void lwtstate_put(struct lwtunnel_state *lws)
	143	{
	144	}
	145
	146	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	147	{
	148	return false;
	149	}
	150
	151	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	152	{
	153	return false;
	154	}
	155
	156	static inline bool lwtunnel_xmit_redirect(struct lwtunnel_state *lwtstate)
	157	{
	158	return false;
	159	}
	160
	161	static inline unsigned int lwtunnel_headroom(struct lwtunnel_state *lwtstate,
	162	unsigned int mtu)
	163	{
	164	return 0;
	165	}
	166
	167	static inline int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	168	unsigned int num)
	169	{
	170	return -EOPNOTSUPP;
	171
	172	}
	173
	174	static inline int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	175	unsigned int num)
	176	{
	177	return -EOPNOTSUPP;
	178	}
	179
	180	static inline int lwtunnel_valid_encap_type(u16 encap_type,
	181	struct netlink_ext_ack *extack)
	182	{
	183	NL_SET_ERR_MSG(extack, "CONFIG_LWTUNNEL is not enabled in this kernel");
	184	return -EOPNOTSUPP;
	185	}
	186	static inline int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int len,
	187	struct netlink_ext_ack *extack)
	188	{
	189	/* return 0 since we are not walking attr looking for
	190	* RTA_ENCAP_TYPE attribute on nexthops.
	191	*/
	192	return 0;
	193	}
	194
	195	static inline int lwtunnel_build_state(u16 encap_type,
	196	struct nlattr *encap,
	197	unsigned int family, const void *cfg,
	198	struct lwtunnel_state **lws,
	199	struct netlink_ext_ack *extack)
	200	{
	201	return -EOPNOTSUPP;
	202	}
	203
	204	static inline int lwtunnel_fill_encap(struct sk_buff *skb,
	205	struct lwtunnel_state *lwtstate)
	206	{
	207	return 0;
	208	}
	209
	210	static inline int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
	211	{
	212	return 0;
	213	}
	214
	215	static inline struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len)
	216	{
	217	return NULL;
	218	}
	219
	220	static inline int lwtunnel_cmp_encap(struct lwtunnel_state *a,
	221	struct lwtunnel_state *b)
	222	{
	223	return 0;
	224	}
	225
	226	static inline int lwtunnel_output(struct net net, struct sock sk, struct sk_buff *skb)
	227	{
	228	return -EOPNOTSUPP;
	229	}
	230
	231	static inline int lwtunnel_input(struct sk_buff *skb)
	232	{
	233	return -EOPNOTSUPP;
	234	}
	235
	236	static inline int lwtunnel_xmit(struct sk_buff *skb)
	237	{
	238	return -EOPNOTSUPP;
	239	}
	240
	241	#endif /* CONFIG_LWTUNNEL */
	242
	243	#define MODULE_ALIAS_RTNL_LWT(encap_type) MODULE_ALIAS("rtnl-lwt-" __stringify(encap_type))
	244
	245	#endif /* __NET_LWTUNNEL_H */