2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* INET An implementation of the TCP/IP protocol suite for the LINUX
|
|
|
|
* operating system. INET is implemented using the BSD Socket
|
|
|
|
* interface as the means of communication with the user level.
|
|
|
|
*
|
|
|
|
* Definitions for the Forwarding Information Base.
|
|
|
|
*
|
|
|
|
* Authors: A.N.Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _NET_IP_FIB_H
|
|
|
|
#define _NET_IP_FIB_H
|
|
|
|
|
|
|
|
#include <net/flow.h>
|
|
|
|
#include <linux/seq_file.h>
|
2012-07-17 11:19:00 +00:00
|
|
|
#include <linux/rcupdate.h>
|
2006-08-04 10:39:22 +00:00
|
|
|
#include <net/fib_rules.h>
|
2012-06-11 07:01:52 +00:00
|
|
|
#include <net/inetpeer.h>
|
2012-07-31 05:45:30 +00:00
|
|
|
#include <linux/percpu.h>
|
2016-09-26 10:52:29 +00:00
|
|
|
#include <linux/notifier.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-18 01:14:52 +00:00
|
|
|
struct fib_config {
|
|
|
|
u8 fc_dst_len;
|
|
|
|
u8 fc_tos;
|
|
|
|
u8 fc_protocol;
|
|
|
|
u8 fc_scope;
|
|
|
|
u8 fc_type;
|
2006-10-19 03:26:36 +00:00
|
|
|
/* 3 bytes unused */
|
2006-08-18 01:14:52 +00:00
|
|
|
u32 fc_table;
|
2006-09-27 05:15:46 +00:00
|
|
|
__be32 fc_dst;
|
|
|
|
__be32 fc_gw;
|
2006-08-18 01:14:52 +00:00
|
|
|
int fc_oif;
|
|
|
|
u32 fc_flags;
|
|
|
|
u32 fc_priority;
|
2006-09-27 05:15:46 +00:00
|
|
|
__be32 fc_prefsrc;
|
2006-08-18 01:14:52 +00:00
|
|
|
struct nlattr *fc_mx;
|
|
|
|
struct rtnexthop *fc_mp;
|
|
|
|
int fc_mx_len;
|
|
|
|
int fc_mp_len;
|
|
|
|
u32 fc_flow;
|
|
|
|
u32 fc_nlflags;
|
|
|
|
struct nl_info fc_nlinfo;
|
2015-07-21 08:43:47 +00:00
|
|
|
struct nlattr *fc_encap;
|
|
|
|
u16 fc_encap_type;
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct fib_info;
|
2012-07-17 19:20:47 +00:00
|
|
|
struct rtable;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-17 11:19:00 +00:00
|
|
|
struct fib_nh_exception {
|
|
|
|
struct fib_nh_exception __rcu *fnhe_next;
|
2013-05-27 20:46:33 +00:00
|
|
|
int fnhe_genid;
|
2012-07-17 11:19:00 +00:00
|
|
|
__be32 fnhe_daddr;
|
|
|
|
u32 fnhe_pmtu;
|
2012-07-18 10:15:35 +00:00
|
|
|
__be32 fnhe_gw;
|
2012-07-17 11:19:00 +00:00
|
|
|
unsigned long fnhe_expires;
|
2013-06-27 07:27:05 +00:00
|
|
|
struct rtable __rcu *fnhe_rth_input;
|
|
|
|
struct rtable __rcu *fnhe_rth_output;
|
2012-07-17 11:19:00 +00:00
|
|
|
unsigned long fnhe_stamp;
|
2016-02-18 13:21:19 +00:00
|
|
|
struct rcu_head rcu;
|
2012-07-17 11:19:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct fnhe_hash_bucket {
|
|
|
|
struct fib_nh_exception __rcu *chain;
|
|
|
|
};
|
|
|
|
|
2014-09-04 15:21:31 +00:00
|
|
|
#define FNHE_HASH_SHIFT 11
|
|
|
|
#define FNHE_HASH_SIZE (1 << FNHE_HASH_SHIFT)
|
2012-07-17 11:19:00 +00:00
|
|
|
#define FNHE_RECLAIM_DEPTH 5
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fib_nh {
|
|
|
|
struct net_device *nh_dev;
|
|
|
|
struct hlist_node nh_hash;
|
|
|
|
struct fib_info *nh_parent;
|
2012-04-15 05:58:06 +00:00
|
|
|
unsigned int nh_flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char nh_scope;
|
|
|
|
#ifdef CONFIG_IP_ROUTE_MULTIPATH
|
|
|
|
int nh_weight;
|
2015-09-30 08:12:21 +00:00
|
|
|
atomic_t nh_upper_bound;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2011-01-14 12:36:42 +00:00
|
|
|
#ifdef CONFIG_IP_ROUTE_CLASSID
|
2005-04-16 22:20:36 +00:00
|
|
|
__u32 nh_tclassid;
|
|
|
|
#endif
|
|
|
|
int nh_oif;
|
2006-09-27 05:13:54 +00:00
|
|
|
__be32 nh_gw;
|
2011-03-08 04:54:48 +00:00
|
|
|
__be32 nh_saddr;
|
2011-03-25 00:42:21 +00:00
|
|
|
int nh_saddr_genid;
|
2012-07-31 05:45:30 +00:00
|
|
|
struct rtable __rcu * __percpu *nh_pcpu_rth_output;
|
2012-07-31 01:08:23 +00:00
|
|
|
struct rtable __rcu *nh_rth_input;
|
2014-09-04 05:21:56 +00:00
|
|
|
struct fnhe_hash_bucket __rcu *nh_exceptions;
|
2015-07-21 08:43:47 +00:00
|
|
|
struct lwtunnel_state *nh_lwtstate;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This structure contains data shared by many of routes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct fib_info {
|
|
|
|
struct hlist_node fib_hash;
|
|
|
|
struct hlist_node fib_lhash;
|
2008-02-01 02:49:32 +00:00
|
|
|
struct net *fib_net;
|
2005-04-16 22:20:36 +00:00
|
|
|
int fib_treeref;
|
|
|
|
atomic_t fib_clntref;
|
2012-04-15 05:58:06 +00:00
|
|
|
unsigned int fib_flags;
|
2011-03-25 01:06:47 +00:00
|
|
|
unsigned char fib_dead;
|
|
|
|
unsigned char fib_protocol;
|
|
|
|
unsigned char fib_scope;
|
2012-10-04 01:25:26 +00:00
|
|
|
unsigned char fib_type;
|
2006-09-27 05:14:15 +00:00
|
|
|
__be32 fib_prefsrc;
|
2016-09-04 22:20:20 +00:00
|
|
|
u32 fib_tb_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 fib_priority;
|
2011-01-28 22:01:25 +00:00
|
|
|
u32 *fib_metrics;
|
2005-04-16 22:20:36 +00:00
|
|
|
#define fib_mtu fib_metrics[RTAX_MTU-1]
|
|
|
|
#define fib_window fib_metrics[RTAX_WINDOW-1]
|
|
|
|
#define fib_rtt fib_metrics[RTAX_RTT-1]
|
|
|
|
#define fib_advmss fib_metrics[RTAX_ADVMSS-1]
|
|
|
|
int fib_nhs;
|
|
|
|
#ifdef CONFIG_IP_ROUTE_MULTIPATH
|
2015-09-30 08:12:21 +00:00
|
|
|
int fib_weight;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2016-09-26 10:52:30 +00:00
|
|
|
unsigned int fib_offload_cnt;
|
2010-10-05 10:41:36 +00:00
|
|
|
struct rcu_head rcu;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fib_nh fib_nh[0];
|
|
|
|
#define fib_dev fib_nh[0].nh_dev
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTIPLE_TABLES
|
|
|
|
struct fib_rule;
|
|
|
|
#endif
|
|
|
|
|
2011-02-01 00:10:03 +00:00
|
|
|
struct fib_table;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fib_result {
|
|
|
|
unsigned char prefixlen;
|
|
|
|
unsigned char nh_sel;
|
|
|
|
unsigned char type;
|
|
|
|
unsigned char scope;
|
2012-07-13 15:21:29 +00:00
|
|
|
u32 tclassid;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fib_info *fi;
|
2011-02-01 00:10:03 +00:00
|
|
|
struct fib_table *table;
|
2015-02-25 23:31:31 +00:00
|
|
|
struct hlist_head *fa_head;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2005-06-20 20:36:39 +00:00
|
|
|
struct fib_result_nl {
|
2006-09-27 05:19:36 +00:00
|
|
|
__be32 fl_addr; /* To be looked up*/
|
2006-11-09 23:21:41 +00:00
|
|
|
u32 fl_mark;
|
2005-06-20 20:36:39 +00:00
|
|
|
unsigned char fl_tos;
|
|
|
|
unsigned char fl_scope;
|
|
|
|
unsigned char tb_id_in;
|
|
|
|
|
|
|
|
unsigned char tb_id; /* Results */
|
|
|
|
unsigned char prefixlen;
|
|
|
|
unsigned char nh_sel;
|
|
|
|
unsigned char type;
|
|
|
|
unsigned char scope;
|
|
|
|
int err;
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_IP_ROUTE_MULTIPATH
|
|
|
|
#define FIB_RES_NH(res) ((res).fi->fib_nh[(res).nh_sel])
|
|
|
|
#else /* CONFIG_IP_ROUTE_MULTIPATH */
|
|
|
|
#define FIB_RES_NH(res) ((res).fi->fib_nh[0])
|
2013-03-13 00:24:15 +00:00
|
|
|
#endif /* CONFIG_IP_ROUTE_MULTIPATH */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-03-13 00:24:15 +00:00
|
|
|
#ifdef CONFIG_IP_MULTIPLE_TABLES
|
2008-01-10 11:23:38 +00:00
|
|
|
#define FIB_TABLE_HASHSZ 256
|
2013-03-13 00:24:15 +00:00
|
|
|
#else
|
|
|
|
#define FIB_TABLE_HASHSZ 2
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-09-21 17:22:42 +00:00
|
|
|
__be32 fib_info_update_nh_saddr(struct net *net, struct fib_nh *nh);
|
2011-03-25 00:42:21 +00:00
|
|
|
|
2016-09-26 10:52:30 +00:00
|
|
|
static inline void fib_info_offload_inc(struct fib_info *fi)
|
|
|
|
{
|
|
|
|
fi->fib_offload_cnt++;
|
|
|
|
fi->fib_flags |= RTNH_F_OFFLOAD;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void fib_info_offload_dec(struct fib_info *fi)
|
|
|
|
{
|
|
|
|
if (--fi->fib_offload_cnt == 0)
|
|
|
|
fi->fib_flags &= ~RTNH_F_OFFLOAD;
|
|
|
|
}
|
|
|
|
|
2011-03-25 00:42:21 +00:00
|
|
|
#define FIB_RES_SADDR(net, res) \
|
|
|
|
((FIB_RES_NH(res).nh_saddr_genid == \
|
|
|
|
atomic_read(&(net)->ipv4.dev_addr_genid)) ? \
|
|
|
|
FIB_RES_NH(res).nh_saddr : \
|
|
|
|
fib_info_update_nh_saddr((net), &FIB_RES_NH(res)))
|
2005-04-16 22:20:36 +00:00
|
|
|
#define FIB_RES_GW(res) (FIB_RES_NH(res).nh_gw)
|
|
|
|
#define FIB_RES_DEV(res) (FIB_RES_NH(res).nh_dev)
|
|
|
|
#define FIB_RES_OIF(res) (FIB_RES_NH(res).nh_oif)
|
|
|
|
|
2011-03-25 00:42:21 +00:00
|
|
|
#define FIB_RES_PREFSRC(net, res) ((res).fi->fib_prefsrc ? : \
|
|
|
|
FIB_RES_SADDR(net, res))
|
2011-03-08 04:54:48 +00:00
|
|
|
|
2016-09-26 10:52:29 +00:00
|
|
|
struct fib_notifier_info {
|
|
|
|
struct net *net;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fib_entry_notifier_info {
|
|
|
|
struct fib_notifier_info info; /* must be first */
|
|
|
|
u32 dst;
|
|
|
|
int dst_len;
|
|
|
|
struct fib_info *fi;
|
|
|
|
u8 tos;
|
|
|
|
u8 type;
|
|
|
|
u32 tb_id;
|
|
|
|
};
|
|
|
|
|
2017-03-16 08:08:13 +00:00
|
|
|
struct fib_rule_notifier_info {
|
|
|
|
struct fib_notifier_info info; /* must be first */
|
|
|
|
struct fib_rule *rule;
|
|
|
|
};
|
|
|
|
|
2017-02-08 10:16:39 +00:00
|
|
|
struct fib_nh_notifier_info {
|
|
|
|
struct fib_notifier_info info; /* must be first */
|
|
|
|
struct fib_nh *fib_nh;
|
|
|
|
};
|
|
|
|
|
2016-09-26 10:52:29 +00:00
|
|
|
enum fib_event_type {
|
2017-02-09 09:28:41 +00:00
|
|
|
FIB_EVENT_ENTRY_REPLACE,
|
|
|
|
FIB_EVENT_ENTRY_APPEND,
|
2016-09-26 10:52:29 +00:00
|
|
|
FIB_EVENT_ENTRY_ADD,
|
|
|
|
FIB_EVENT_ENTRY_DEL,
|
|
|
|
FIB_EVENT_RULE_ADD,
|
|
|
|
FIB_EVENT_RULE_DEL,
|
2017-02-08 10:16:39 +00:00
|
|
|
FIB_EVENT_NH_ADD,
|
|
|
|
FIB_EVENT_NH_DEL,
|
2016-09-26 10:52:29 +00:00
|
|
|
};
|
|
|
|
|
2016-12-03 15:45:07 +00:00
|
|
|
int register_fib_notifier(struct notifier_block *nb,
|
|
|
|
void (*cb)(struct notifier_block *nb));
|
2016-09-26 10:52:29 +00:00
|
|
|
int unregister_fib_notifier(struct notifier_block *nb);
|
2017-03-10 07:56:18 +00:00
|
|
|
int call_fib_notifier(struct notifier_block *nb, struct net *net,
|
|
|
|
enum fib_event_type event_type,
|
|
|
|
struct fib_notifier_info *info);
|
2016-09-26 10:52:29 +00:00
|
|
|
int call_fib_notifiers(struct net *net, enum fib_event_type event_type,
|
|
|
|
struct fib_notifier_info *info);
|
|
|
|
|
2017-03-10 07:56:19 +00:00
|
|
|
void fib_notify(struct net *net, struct notifier_block *nb);
|
2017-03-10 07:56:18 +00:00
|
|
|
#ifdef CONFIG_IP_MULTIPLE_TABLES
|
2017-03-10 07:56:19 +00:00
|
|
|
void fib_rules_notify(struct net *net, struct notifier_block *nb);
|
2017-03-10 07:56:18 +00:00
|
|
|
#else
|
2017-03-10 07:56:19 +00:00
|
|
|
static inline void fib_rules_notify(struct net *net, struct notifier_block *nb)
|
2017-03-10 07:56:18 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct fib_table {
|
2012-06-11 07:01:52 +00:00
|
|
|
struct hlist_node tb_hlist;
|
|
|
|
u32 tb_id;
|
|
|
|
int tb_num_default;
|
2015-03-04 23:02:44 +00:00
|
|
|
struct rcu_head rcu;
|
2015-03-06 21:47:00 +00:00
|
|
|
unsigned long *tb_data;
|
|
|
|
unsigned long __data[0];
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2013-09-21 17:22:42 +00:00
|
|
|
int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
|
|
|
|
struct fib_result *res, int fib_flags);
|
2017-05-21 16:12:02 +00:00
|
|
|
int fib_table_insert(struct net *, struct fib_table *, struct fib_config *,
|
|
|
|
struct netlink_ext_ack *extack);
|
2016-09-26 10:52:29 +00:00
|
|
|
int fib_table_delete(struct net *, struct fib_table *, struct fib_config *);
|
2013-09-21 17:22:42 +00:00
|
|
|
int fib_table_dump(struct fib_table *table, struct sk_buff *skb,
|
|
|
|
struct netlink_callback *cb);
|
2016-09-26 10:52:29 +00:00
|
|
|
int fib_table_flush(struct net *net, struct fib_table *table);
|
2015-03-06 21:47:00 +00:00
|
|
|
struct fib_table *fib_trie_unmerge(struct fib_table *main_tb);
|
2016-11-15 10:46:06 +00:00
|
|
|
void fib_table_flush_external(struct fib_table *table);
|
2013-09-21 17:22:42 +00:00
|
|
|
void fib_free_table(struct fib_table *tb);
|
2010-10-28 02:00:43 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifndef CONFIG_IP_MULTIPLE_TABLES
|
|
|
|
|
2014-12-02 18:58:21 +00:00
|
|
|
#define TABLE_LOCAL_INDEX (RT_TABLE_LOCAL & (FIB_TABLE_HASHSZ - 1))
|
|
|
|
#define TABLE_MAIN_INDEX (RT_TABLE_MAIN & (FIB_TABLE_HASHSZ - 1))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-01-10 11:24:11 +00:00
|
|
|
static inline struct fib_table *fib_get_table(struct net *net, u32 id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2015-03-04 23:02:44 +00:00
|
|
|
struct hlist_node *tb_hlist;
|
2008-01-10 11:23:38 +00:00
|
|
|
struct hlist_head *ptr;
|
|
|
|
|
|
|
|
ptr = id == RT_TABLE_LOCAL ?
|
2008-01-10 11:28:24 +00:00
|
|
|
&net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
|
|
|
|
&net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
|
2015-03-04 23:02:44 +00:00
|
|
|
|
|
|
|
tb_hlist = rcu_dereference_rtnl(hlist_first_rcu(ptr));
|
|
|
|
|
|
|
|
return hlist_entry(tb_hlist, struct fib_table, tb_hlist);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-01-10 11:24:11 +00:00
|
|
|
static inline struct fib_table *fib_new_table(struct net *net, u32 id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-10 11:24:11 +00:00
|
|
|
return fib_get_table(net, id);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-03-12 00:54:08 +00:00
|
|
|
static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
|
2015-06-23 17:45:37 +00:00
|
|
|
struct fib_result *res, unsigned int flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2015-03-04 23:02:44 +00:00
|
|
|
struct fib_table *tb;
|
2015-03-06 21:47:00 +00:00
|
|
|
int err = -ENETUNREACH;
|
2014-12-31 18:56:24 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2015-03-06 21:47:00 +00:00
|
|
|
tb = fib_get_table(net, RT_TABLE_MAIN);
|
2015-09-17 14:01:32 +00:00
|
|
|
if (tb)
|
|
|
|
err = fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF);
|
|
|
|
|
|
|
|
if (err == -EAGAIN)
|
|
|
|
err = -ENETUNREACH;
|
2008-01-10 11:23:38 +00:00
|
|
|
|
2014-12-31 18:56:24 +00:00
|
|
|
rcu_read_unlock();
|
2008-01-10 11:23:38 +00:00
|
|
|
|
2014-12-31 18:56:24 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
ipv4: fib_rules: Check if rule is a default rule
Currently, when non-default (custom) FIB rules are used, devices capable
of layer 3 offloading flush their tables and let the kernel do the
forwarding instead.
When these devices' drivers are loaded they register to the FIB
notification chain, which lets them know about the existence of any
custom FIB rules. This is done by sending a RULE_ADD notification based
on the value of 'net->ipv4.fib_has_custom_rules'.
This approach is problematic when VRF offload is taken into account, as
upon the creation of the first VRF netdev, a l3mdev rule is programmed
to direct skbs to the VRF's table.
Instead of merely reading the above value and sending a single RULE_ADD
notification, we should iterate over all the FIB rules and send a
detailed notification for each, thereby allowing offloading drivers to
sanitize the rules they don't support and potentially flush their
tables.
While l3mdev rules are uniquely marked, the default rules are not.
Therefore, when they are being notified they might invoke offloading
drivers to unnecessarily flush their tables.
Solve this by adding an helper to check if a FIB rule is a default rule.
Namely, its selector should match all packets and its action should
point to the local, main or default tables.
As noted by David Ahern, uniquely marking the default rules is
insufficient. When using VRFs, it's common to avoid false hits by moving
the rule for the local table to just before the main table:
Default configuration:
$ ip rule show
0: from all lookup local
32766: from all lookup main
32767: from all lookup default
Common configuration with VRFs:
$ ip rule show
1000: from all lookup [l3mdev-table]
32765: from all lookup local
32766: from all lookup main
32767: from all lookup default
Signed-off-by: Ido Schimmel <idosch@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: David Ahern <dsa@cumulusnetworks.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-03-16 08:08:12 +00:00
|
|
|
static inline bool fib4_rule_default(const struct fib_rule *rule)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#else /* CONFIG_IP_MULTIPLE_TABLES */
|
2013-09-21 17:22:42 +00:00
|
|
|
int __net_init fib4_rules_init(struct net *net);
|
|
|
|
void __net_exit fib4_rules_exit(struct net *net);
|
2007-11-07 07:34:04 +00:00
|
|
|
|
2013-09-21 17:22:42 +00:00
|
|
|
struct fib_table *fib_new_table(struct net *net, u32 id);
|
|
|
|
struct fib_table *fib_get_table(struct net *net, u32 id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-06-23 17:45:37 +00:00
|
|
|
int __fib_lookup(struct net *net, struct flowi4 *flp,
|
|
|
|
struct fib_result *res, unsigned int flags);
|
2012-07-06 05:13:13 +00:00
|
|
|
|
|
|
|
static inline int fib_lookup(struct net *net, struct flowi4 *flp,
|
2015-06-23 17:45:37 +00:00
|
|
|
struct fib_result *res, unsigned int flags)
|
2012-07-06 05:13:13 +00:00
|
|
|
{
|
2015-03-04 23:02:44 +00:00
|
|
|
struct fib_table *tb;
|
2015-09-17 14:01:32 +00:00
|
|
|
int err = -ENETUNREACH;
|
2015-03-04 23:02:44 +00:00
|
|
|
|
2015-06-23 17:45:37 +00:00
|
|
|
flags |= FIB_LOOKUP_NOREF;
|
2015-03-04 23:02:44 +00:00
|
|
|
if (net->ipv4.fib_has_custom_rules)
|
2015-06-23 17:45:37 +00:00
|
|
|
return __fib_lookup(net, flp, res, flags);
|
2015-03-04 23:02:44 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
res->tclassid = 0;
|
|
|
|
|
2015-09-17 14:01:32 +00:00
|
|
|
tb = rcu_dereference_rtnl(net->ipv4.fib_main);
|
|
|
|
if (tb)
|
|
|
|
err = fib_table_lookup(tb, flp, res, flags);
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tb = rcu_dereference_rtnl(net->ipv4.fib_default);
|
|
|
|
if (tb)
|
|
|
|
err = fib_table_lookup(tb, flp, res, flags);
|
2015-03-04 23:02:44 +00:00
|
|
|
|
2015-09-17 14:01:32 +00:00
|
|
|
out:
|
|
|
|
if (err == -EAGAIN)
|
|
|
|
err = -ENETUNREACH;
|
2015-03-04 23:02:44 +00:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return err;
|
2012-07-06 05:13:13 +00:00
|
|
|
}
|
|
|
|
|
ipv4: fib_rules: Check if rule is a default rule
Currently, when non-default (custom) FIB rules are used, devices capable
of layer 3 offloading flush their tables and let the kernel do the
forwarding instead.
When these devices' drivers are loaded they register to the FIB
notification chain, which lets them know about the existence of any
custom FIB rules. This is done by sending a RULE_ADD notification based
on the value of 'net->ipv4.fib_has_custom_rules'.
This approach is problematic when VRF offload is taken into account, as
upon the creation of the first VRF netdev, a l3mdev rule is programmed
to direct skbs to the VRF's table.
Instead of merely reading the above value and sending a single RULE_ADD
notification, we should iterate over all the FIB rules and send a
detailed notification for each, thereby allowing offloading drivers to
sanitize the rules they don't support and potentially flush their
tables.
While l3mdev rules are uniquely marked, the default rules are not.
Therefore, when they are being notified they might invoke offloading
drivers to unnecessarily flush their tables.
Solve this by adding an helper to check if a FIB rule is a default rule.
Namely, its selector should match all packets and its action should
point to the local, main or default tables.
As noted by David Ahern, uniquely marking the default rules is
insufficient. When using VRFs, it's common to avoid false hits by moving
the rule for the local table to just before the main table:
Default configuration:
$ ip rule show
0: from all lookup local
32766: from all lookup main
32767: from all lookup default
Common configuration with VRFs:
$ ip rule show
1000: from all lookup [l3mdev-table]
32765: from all lookup local
32766: from all lookup main
32767: from all lookup default
Signed-off-by: Ido Schimmel <idosch@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: David Ahern <dsa@cumulusnetworks.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-03-16 08:08:12 +00:00
|
|
|
bool fib4_rule_default(const struct fib_rule *rule);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* CONFIG_IP_MULTIPLE_TABLES */
|
|
|
|
|
|
|
|
/* Exported by fib_frontend.c */
|
2007-06-05 19:38:30 +00:00
|
|
|
extern const struct nla_policy rtm_ipv4_policy[];
|
2013-09-21 17:22:42 +00:00
|
|
|
void ip_fib_init(void);
|
|
|
|
__be32 fib_compute_spec_dst(struct sk_buff *skb);
|
|
|
|
int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
|
|
|
|
u8 tos, int oif, struct net_device *dev,
|
|
|
|
struct in_device *idev, u32 *itag);
|
2012-06-29 08:32:45 +00:00
|
|
|
#ifdef CONFIG_IP_ROUTE_CLASSID
|
2012-07-06 05:13:13 +00:00
|
|
|
static inline int fib_num_tclassid_users(struct net *net)
|
|
|
|
{
|
|
|
|
return net->ipv4.fib_num_tclassid_users;
|
|
|
|
}
|
2012-06-29 08:32:45 +00:00
|
|
|
#else
|
2012-07-06 05:13:13 +00:00
|
|
|
static inline int fib_num_tclassid_users(struct net *net)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2012-06-29 08:32:45 +00:00
|
|
|
#endif
|
2015-03-06 21:47:00 +00:00
|
|
|
int fib_unmerge(struct net *net);
|
2005-12-27 04:43:12 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Exported by fib_semantics.c */
|
2013-09-21 17:22:42 +00:00
|
|
|
int ip_fib_check_default(__be32 gw, struct net_device *dev);
|
2015-10-30 08:23:33 +00:00
|
|
|
int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force);
|
2016-09-04 22:20:20 +00:00
|
|
|
int fib_sync_down_addr(struct net_device *dev, __be32 local);
|
2015-06-23 17:45:36 +00:00
|
|
|
int fib_sync_up(struct net_device *dev, unsigned int nh_flags);
|
2015-09-30 08:12:21 +00:00
|
|
|
|
2017-03-16 13:28:00 +00:00
|
|
|
#ifdef CONFIG_IP_ROUTE_MULTIPATH
|
|
|
|
int fib_multipath_hash(const struct fib_info *fi, const struct flowi4 *fl4,
|
|
|
|
const struct sk_buff *skb);
|
|
|
|
#endif
|
2015-09-30 08:12:21 +00:00
|
|
|
void fib_select_multipath(struct fib_result *res, int hash);
|
2015-10-05 15:51:25 +00:00
|
|
|
void fib_select_path(struct net *net, struct fib_result *res,
|
2017-03-16 13:28:00 +00:00
|
|
|
struct flowi4 *fl4, const struct sk_buff *skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-02-01 23:30:56 +00:00
|
|
|
/* Exported by fib_trie.c */
|
2013-09-21 17:22:42 +00:00
|
|
|
void fib_trie_init(void);
|
2015-03-06 21:47:00 +00:00
|
|
|
struct fib_table *fib_trie_table(u32 id, struct fib_table *alias);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-02-17 06:04:57 +00:00
|
|
|
static inline void fib_combine_itag(u32 *itag, const struct fib_result *res)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-01-14 12:36:42 +00:00
|
|
|
#ifdef CONFIG_IP_ROUTE_CLASSID
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_IP_MULTIPLE_TABLES
|
|
|
|
u32 rtag;
|
|
|
|
#endif
|
|
|
|
*itag = FIB_RES_NH(*res).nh_tclassid<<16;
|
|
|
|
#ifdef CONFIG_IP_MULTIPLE_TABLES
|
2012-07-13 15:21:29 +00:00
|
|
|
rtag = res->tclassid;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (*itag == 0)
|
|
|
|
*itag = (rtag<<16);
|
|
|
|
*itag |= (rtag>>16);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-09-21 17:22:42 +00:00
|
|
|
void free_fib_info(struct fib_info *fi);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-12-03 15:44:59 +00:00
|
|
|
static inline void fib_info_hold(struct fib_info *fi)
|
|
|
|
{
|
|
|
|
atomic_inc(&fi->fib_clntref);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline void fib_info_put(struct fib_info *fi)
|
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&fi->fib_clntref))
|
|
|
|
free_fib_info(fi);
|
|
|
|
}
|
|
|
|
|
2005-08-16 05:18:02 +00:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2013-09-21 17:22:42 +00:00
|
|
|
int __net_init fib_proc_init(struct net *net);
|
|
|
|
void __net_exit fib_proc_exit(struct net *net);
|
2008-02-05 10:54:16 +00:00
|
|
|
#else
|
|
|
|
static inline int fib_proc_init(struct net *net)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline void fib_proc_exit(struct net *net)
|
|
|
|
{
|
|
|
|
}
|
2005-08-16 05:18:02 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* _NET_FIB_H */
|