[linux-2.6-block.git] / include / net / fib_rules.h

#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 <net/flow.h>
#include <net/rtnetlink.h>

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;

	atomic_t		refcnt;
	u32			pref;
	int			suppress_ifgroup;
	int			suppress_prefixlen;
	char			iifname[IFNAMSIZ];
	char			oifname[IFNAMSIZ];
	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;

	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;
};

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

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

static inline void fib_rule_put(struct fib_rule *rule)
{
	if (atomic_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);

int fib_nl_newrule(struct sk_buff *skb, struct nlmsghdr *nlh);
int fib_nl_delrule(struct sk_buff *skb, struct nlmsghdr *nlh);
#endif
Commit	Line	Data
14c0b97d TG	1	#ifndef __NET_FIB_RULES_H
	2	#define __NET_FIB_RULES_H
	3
	4	#include <linux/types.h>
5a0e3ad6	5	#include <linux/slab.h>
14c0b97d TG	6	#include <linux/netdevice.h>
	7	#include <linux/fib_rules.h>
	8	#include <net/flow.h>
9d9e6a58	9	#include <net/rtnetlink.h>
14c0b97d	10
fd2c3ef7	11	struct fib_rule {
14c0b97d	12	struct list_head list;
491deb24	13	int iifindex;
1b038a5e	14	int oifindex;
b8964ed9 TG	15	u32 mark;
b8964ed9 TG	16	u32 mark_mask;
14c0b97d TG	17	u32 flags;
	18	u32 table;
	19	u8 action;
96c63fa7 DA	20	u8 l3mdev;
96c63fa7 DA	21	/* 2 bytes hole, try to use */
0947c9fe	22	u32 target;
e7030878	23	__be64 tun_id;
7a2b03c5	24	struct fib_rule __rcu *ctarget;
fba3679d ED	25	struct net *fr_net;
	26
	27	atomic_t refcnt;
	28	u32 pref;
	29	int suppress_ifgroup;
	30	int suppress_prefixlen;
491deb24	31	char iifname[IFNAMSIZ];
1b038a5e	32	char oifname[IFNAMSIZ];
14c0b97d TG	33	struct rcu_head rcu;
	34	};
	35
fd2c3ef7	36	struct fib_lookup_arg {
14c0b97d TG	37	void *lookup_ptr;
	38	void *result;
	39	struct fib_rule *rule;
96c63fa7	40	u32 table;
ebc0ffae	41	int flags;
0eeb075f AG	42	#define FIB_LOOKUP_NOREF 1
0eeb075f AG	43	#define FIB_LOOKUP_IGNORE_LINKSTATE 2
14c0b97d TG	44	};
14c0b97d TG	45
fd2c3ef7	46	struct fib_rules_ops {
14c0b97d TG	47	int family;
	48	struct list_head list;
	49	int rule_size;
e1701c68	50	int addr_size;
0947c9fe TG	51	int unresolved_rules;
0947c9fe TG	52	int nr_goto_rules;
14c0b97d TG	53
	54	int (action)(struct fib_rule ,
	55	struct flowi *, int,
	56	struct fib_lookup_arg *);
7764a45a ST	57	bool (suppress)(struct fib_rule ,
7764a45a ST	58	struct fib_lookup_arg *);
14c0b97d TG	59	int (match)(struct fib_rule ,
	60	struct flowi *, int);
	61	int (configure)(struct fib_rule ,
	62	struct sk_buff *,
14c0b97d TG	63	struct fib_rule_hdr *,
14c0b97d TG	64	struct nlattr **);
0ddcf43d	65	int (delete)(struct fib_rule );
14c0b97d TG	66	int (compare)(struct fib_rule ,
	67	struct fib_rule_hdr *,
	68	struct nlattr **);
	69	int (fill)(struct fib_rule , struct sk_buff *,
14c0b97d	70	struct fib_rule_hdr *);
339bf98f	71	size_t (nlmsg_payload)(struct fib_rule );
14c0b97d	72
73417f61 TG	73	/* Called after modifications to the rules set, must flush
73417f61 TG	74	* the route cache if one exists. */
ae299fc0	75	void (flush_cache)(struct fib_rules_ops ops);
73417f61	76
14c0b97d	77	int nlgroup;
ef7c79ed	78	const struct nla_policy *policy;
76c72d4f	79	struct list_head rules_list;
14c0b97d	80	struct module *owner;
03592383	81	struct net *fro_net;
e9c5158a	82	struct rcu_head rcu;
14c0b97d TG	83	};
14c0b97d TG	84
1f6c9557	85	#define FRA_GENERIC_POLICY \
491deb24	86	[FRA_IIFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
1b038a5e	87	[FRA_OIFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, \
1f6c9557 TG	88	[FRA_PRIORITY] = { .type = NLA_U32 }, \
	89	[FRA_FWMARK] = { .type = NLA_U32 }, \
	90	[FRA_FWMASK] = { .type = NLA_U32 }, \
0947c9fe	91	[FRA_TABLE] = { .type = NLA_U32 }, \
73f5698e	92	[FRA_SUPPRESS_PREFIXLEN] = { .type = NLA_U32 }, \
6ef94cfa	93	[FRA_SUPPRESS_IFGROUP] = { .type = NLA_U32 }, \
96c63fa7 DA	94	[FRA_GOTO] = { .type = NLA_U32 }, \
96c63fa7 DA	95	[FRA_L3MDEV] = { .type = NLA_U8 }
1f6c9557	96
14c0b97d TG	97	static inline void fib_rule_get(struct fib_rule *rule)
	98	{
	99	atomic_inc(&rule->refcnt);
	100	}
	101
14c0b97d TG	102	static inline void fib_rule_put(struct fib_rule *rule)
	103	{
	104	if (atomic_dec_and_test(&rule->refcnt))
efd7ef1c	105	kfree_rcu(rule, rcu);
14c0b97d TG	106	}
14c0b97d TG	107
96c63fa7 DA	108	#ifdef CONFIG_NET_L3_MASTER_DEV
	109	static inline u32 fib_rule_get_table(struct fib_rule *rule,
	110	struct fib_lookup_arg *arg)
	111	{
	112	return rule->l3mdev ? arg->table : rule->table;
	113	}
	114	#else
	115	static inline u32 fib_rule_get_table(struct fib_rule *rule,
	116	struct fib_lookup_arg *arg)
	117	{
	118	return rule->table;
	119	}
	120	#endif
	121
9e762a4a PM	122	static inline u32 frh_get_table(struct fib_rule_hdr frh, struct nlattr *nla)
	123	{
	124	if (nla[FRA_TABLE])
	125	return nla_get_u32(nla[FRA_TABLE]);
	126	return frh->table;
	127	}
	128
8de6879f JP	129	struct fib_rules_ops fib_rules_register(const struct fib_rules_ops ,
	130	struct net *);
	131	void fib_rules_unregister(struct fib_rules_ops *);
14c0b97d	132
8de6879f JP	133	int fib_rules_lookup(struct fib_rules_ops , struct flowi , int flags,
	134	struct fib_lookup_arg *);
	135	int fib_default_rule_add(struct fib_rules_ops *, u32 pref, u32 table,
	136	u32 flags);
96c63fa7 DA	137
	138	int fib_nl_newrule(struct sk_buff skb, struct nlmsghdr nlh);
	139	int fib_nl_delrule(struct sk_buff skb, struct nlmsghdr nlh);
14c0b97d	140	#endif