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

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

#include <linux/types.h>
#include <linux/slab.h>
#include <linux/netdevice.h>
#include <linux/fib_rules.h>
#include <linux/refcount.h>
#include <net/flow.h>
#include <net/rtnetlink.h>
#include <net/fib_notifier.h>

struct fib_kuid_range {
	kuid_t start;
	kuid_t end;
};

struct fib_rule {
	struct list_head	list;
	int			iifindex;
	int			oifindex;
	u32			mark;
	u32			mark_mask;
	u32			flags;
	u32			table;
	u8			action;
	u8			l3mdev;
	/* 2 bytes hole, try to use */
	u32			target;
	__be64			tun_id;
	struct fib_rule __rcu	*ctarget;
	struct net		*fr_net;

	refcount_t		refcnt;
	u32			pref;
	int			suppress_ifgroup;
	int			suppress_prefixlen;
	char			iifname[IFNAMSIZ];
	char			oifname[IFNAMSIZ];
	struct fib_kuid_range	uid_range;
	struct rcu_head		rcu;
};

struct fib_lookup_arg {
	void			*lookup_ptr;
	void			*result;
	struct fib_rule		*rule;
	u32			table;
	int			flags;
#define FIB_LOOKUP_NOREF		1
#define FIB_LOOKUP_IGNORE_LINKSTATE	2
};

struct fib_rules_ops {
	int			family;
	struct list_head	list;
	int			rule_size;
	int			addr_size;
	int			unresolved_rules;
	int			nr_goto_rules;
	unsigned int		fib_rules_seq;

	int			(*action)(struct fib_rule *,
					  struct flowi *, int,
					  struct fib_lookup_arg *);
	bool			(*suppress)(struct fib_rule *,
					    struct fib_lookup_arg *);
	int			(*match)(struct fib_rule *,
					 struct flowi *, int);
	int			(*configure)(struct fib_rule *,
					     struct sk_buff *,
					     struct fib_rule_hdr *,
					     struct nlattr **);
	int			(*delete)(struct fib_rule *);
	int			(*compare)(struct fib_rule *,
					   struct fib_rule_hdr *,
					   struct nlattr **);
	int			(*fill)(struct fib_rule *, struct sk_buff *,
					struct fib_rule_hdr *);
	size_t			(*nlmsg_payload)(struct fib_rule *);

	/* Called after modifications to the rules set, must flush
	 * the route cache if one exists. */
	void			(*flush_cache)(struct fib_rules_ops *ops);

	int			nlgroup;
	const struct nla_policy	*policy;
	struct list_head	rules_list;
	struct module		*owner;
	struct net		*fro_net;
	struct rcu_head		rcu;
};

struct fib_rule_notifier_info {
	struct fib_notifier_info info; /* must be first */
	struct fib_rule *rule;
};

#define FRA_GENERIC_POLICY \
	[FRA_IIFNAME]	= { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
	[FRA_OIFNAME]	= { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
	[FRA_PRIORITY]	= { .type = NLA_U32 }, \
	[FRA_FWMARK]	= { .type = NLA_U32 }, \
	[FRA_FWMASK]	= { .type = NLA_U32 }, \
	[FRA_TABLE]     = { .type = NLA_U32 }, \
	[FRA_SUPPRESS_PREFIXLEN] = { .type = NLA_U32 }, \
	[FRA_SUPPRESS_IFGROUP] = { .type = NLA_U32 }, \
	[FRA_GOTO]	= { .type = NLA_U32 }, \
	[FRA_L3MDEV]	= { .type = NLA_U8 }, \
	[FRA_UID_RANGE]	= { .len = sizeof(struct fib_rule_uid_range) }

static inline void fib_rule_get(struct fib_rule *rule)
{
	refcount_inc(&rule->refcnt);
}

static inline void fib_rule_put(struct fib_rule *rule)
{
	if (refcount_dec_and_test(&rule->refcnt))
		kfree_rcu(rule, rcu);
}

#ifdef CONFIG_NET_L3_MASTER_DEV
static inline u32 fib_rule_get_table(struct fib_rule *rule,
				     struct fib_lookup_arg *arg)
{
	return rule->l3mdev ? arg->table : rule->table;
}
#else
static inline u32 fib_rule_get_table(struct fib_rule *rule,
				     struct fib_lookup_arg *arg)
{
	return rule->table;
}
#endif

static inline u32 frh_get_table(struct fib_rule_hdr *frh, struct nlattr **nla)
{
	if (nla[FRA_TABLE])
		return nla_get_u32(nla[FRA_TABLE]);
	return frh->table;
}

struct fib_rules_ops *fib_rules_register(const struct fib_rules_ops *,
					 struct net *);
void fib_rules_unregister(struct fib_rules_ops *);

int fib_rules_lookup(struct fib_rules_ops *, struct flowi *, int flags,
		     struct fib_lookup_arg *);
int fib_default_rule_add(struct fib_rules_ops *, u32 pref, u32 table,
			 u32 flags);
bool fib_rule_matchall(const struct fib_rule *rule);
int fib_rules_dump(struct net *net, struct notifier_block *nb, int family);
unsigned int fib_rules_seq_read(struct net *net, int family);

int fib_nl_newrule(struct sk_buff *skb, struct nlmsghdr *nlh,
		   struct netlink_ext_ack *extack);
int fib_nl_delrule(struct sk_buff *skb, struct nlmsghdr *nlh,
		   struct netlink_ext_ack *extack);
#endif
Commit	Line	Data
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __NET_FIB_RULES_H
	3	#define __NET_FIB_RULES_H
	4
	5	#include <linux/types.h>
	6	#include <linux/slab.h>
	7	#include <linux/netdevice.h>
	8	#include <linux/fib_rules.h>
	9	#include <linux/refcount.h>
	10	#include <net/flow.h>
	11	#include <net/rtnetlink.h>
	12	#include <net/fib_notifier.h>
	13
	14	struct fib_kuid_range {
	15	kuid_t start;
	16	kuid_t end;
	17	};
	18
	19	struct fib_rule {
	20	struct list_head list;
	21	int iifindex;
	22	int oifindex;
	23	u32 mark;
	24	u32 mark_mask;
	25	u32 flags;
	26	u32 table;
	27	u8 action;
	28	u8 l3mdev;
	29	/* 2 bytes hole, try to use */
	30	u32 target;
	31	__be64 tun_id;
	32	struct fib_rule __rcu *ctarget;
	33	struct net *fr_net;
	34
	35	refcount_t refcnt;
	36	u32 pref;
	37	int suppress_ifgroup;
	38	int suppress_prefixlen;
	39	char iifname[IFNAMSIZ];
	40	char oifname[IFNAMSIZ];
	41	struct fib_kuid_range uid_range;
	42	struct rcu_head rcu;
	43	};
	44
	45	struct fib_lookup_arg {
	46	void *lookup_ptr;
	47	void *result;
	48	struct fib_rule *rule;
	49	u32 table;
	50	int flags;
	51	#define FIB_LOOKUP_NOREF 1
	52	#define FIB_LOOKUP_IGNORE_LINKSTATE 2
	53	};
	54
	55	struct fib_rules_ops {
	56	int family;
	57	struct list_head list;
	58	int rule_size;
	59	int addr_size;
	60	int unresolved_rules;
	61	int nr_goto_rules;
	62	unsigned int fib_rules_seq;
	63
	64	int (action)(struct fib_rule ,
	65	struct flowi *, int,
	66	struct fib_lookup_arg *);
	67	bool (suppress)(struct fib_rule ,
	68	struct fib_lookup_arg *);
	69	int (match)(struct fib_rule ,
	70	struct flowi *, int);
	71	int (configure)(struct fib_rule ,
	72	struct sk_buff *,
	73	struct fib_rule_hdr *,
	74	struct nlattr **);
	75	int (delete)(struct fib_rule );
	76	int (compare)(struct fib_rule ,
	77	struct fib_rule_hdr *,
	78	struct nlattr **);
	79	int (fill)(struct fib_rule , struct sk_buff *,
	80	struct fib_rule_hdr *);
	81	size_t (nlmsg_payload)(struct fib_rule );
	82
	83	/* Called after modifications to the rules set, must flush
	84	* the route cache if one exists. */
	85	void (flush_cache)(struct fib_rules_ops ops);
	86
	87	int nlgroup;
	88	const struct nla_policy *policy;
	89	struct list_head rules_list;
	90	struct module *owner;
	91	struct net *fro_net;
	92	struct rcu_head rcu;
	93	};
	94
	95	struct fib_rule_notifier_info {
	96	struct fib_notifier_info info; /* must be first */
	97	struct fib_rule *rule;
	98	};
	99
	100	#define FRA_GENERIC_POLICY \
	101	[FRA_IIFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
	102	[FRA_OIFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
	103	[FRA_PRIORITY] = { .type = NLA_U32 }, \
	104	[FRA_FWMARK] = { .type = NLA_U32 }, \
	105	[FRA_FWMASK] = { .type = NLA_U32 }, \
	106	[FRA_TABLE] = { .type = NLA_U32 }, \
	107	[FRA_SUPPRESS_PREFIXLEN] = { .type = NLA_U32 }, \
	108	[FRA_SUPPRESS_IFGROUP] = { .type = NLA_U32 }, \
	109	[FRA_GOTO] = { .type = NLA_U32 }, \
	110	[FRA_L3MDEV] = { .type = NLA_U8 }, \
	111	[FRA_UID_RANGE] = { .len = sizeof(struct fib_rule_uid_range) }
	112
	113	static inline void fib_rule_get(struct fib_rule *rule)
	114	{
	115	refcount_inc(&rule->refcnt);
	116	}
	117
	118	static inline void fib_rule_put(struct fib_rule *rule)
	119	{
	120	if (refcount_dec_and_test(&rule->refcnt))
	121	kfree_rcu(rule, rcu);
	122	}
	123
	124	#ifdef CONFIG_NET_L3_MASTER_DEV
	125	static inline u32 fib_rule_get_table(struct fib_rule *rule,
	126	struct fib_lookup_arg *arg)
	127	{
	128	return rule->l3mdev ? arg->table : rule->table;
	129	}
	130	#else
	131	static inline u32 fib_rule_get_table(struct fib_rule *rule,
	132	struct fib_lookup_arg *arg)
	133	{
	134	return rule->table;
	135	}
	136	#endif
	137
	138	static inline u32 frh_get_table(struct fib_rule_hdr frh, struct nlattr *nla)
	139	{
	140	if (nla[FRA_TABLE])
	141	return nla_get_u32(nla[FRA_TABLE]);
	142	return frh->table;
	143	}
	144
	145	struct fib_rules_ops fib_rules_register(const struct fib_rules_ops ,
	146	struct net *);
	147	void fib_rules_unregister(struct fib_rules_ops *);
	148
	149	int fib_rules_lookup(struct fib_rules_ops , struct flowi , int flags,
	150	struct fib_lookup_arg *);
	151	int fib_default_rule_add(struct fib_rules_ops *, u32 pref, u32 table,
	152	u32 flags);
	153	bool fib_rule_matchall(const struct fib_rule *rule);
	154	int fib_rules_dump(struct net net, struct notifier_block nb, int family);
	155	unsigned int fib_rules_seq_read(struct net *net, int family);
	156
	157	int fib_nl_newrule(struct sk_buff skb, struct nlmsghdr nlh,
	158	struct netlink_ext_ack *extack);
	159	int fib_nl_delrule(struct sk_buff skb, struct nlmsghdr nlh,
	160	struct netlink_ext_ack *extack);
	161	#endif