xref: /openbmc/linux/include/net/ip_fib.h (revision ba61bb17)
1 /*
2  * INET		An implementation of the TCP/IP protocol suite for the LINUX
3  *		operating system.  INET  is implemented using the  BSD Socket
4  *		interface as the means of communication with the user level.
5  *
6  *		Definitions for the Forwarding Information Base.
7  *
8  * Authors:	A.N.Kuznetsov, <kuznet@ms2.inr.ac.ru>
9  *
10  *		This program is free software; you can redistribute it and/or
11  *		modify it under the terms of the GNU General Public License
12  *		as published by the Free Software Foundation; either version
13  *		2 of the License, or (at your option) any later version.
14  */
15 
16 #ifndef _NET_IP_FIB_H
17 #define _NET_IP_FIB_H
18 
19 #include <net/flow.h>
20 #include <linux/seq_file.h>
21 #include <linux/rcupdate.h>
22 #include <net/fib_notifier.h>
23 #include <net/fib_rules.h>
24 #include <net/inetpeer.h>
25 #include <linux/percpu.h>
26 #include <linux/notifier.h>
27 #include <linux/refcount.h>
28 
29 struct fib_config {
30 	u8			fc_dst_len;
31 	u8			fc_tos;
32 	u8			fc_protocol;
33 	u8			fc_scope;
34 	u8			fc_type;
35 	/* 3 bytes unused */
36 	u32			fc_table;
37 	__be32			fc_dst;
38 	__be32			fc_gw;
39 	int			fc_oif;
40 	u32			fc_flags;
41 	u32			fc_priority;
42 	__be32			fc_prefsrc;
43 	struct nlattr		*fc_mx;
44 	struct rtnexthop	*fc_mp;
45 	int			fc_mx_len;
46 	int			fc_mp_len;
47 	u32			fc_flow;
48 	u32			fc_nlflags;
49 	struct nl_info		fc_nlinfo;
50 	struct nlattr		*fc_encap;
51 	u16			fc_encap_type;
52 };
53 
54 struct fib_info;
55 struct rtable;
56 
57 struct fib_nh_exception {
58 	struct fib_nh_exception __rcu	*fnhe_next;
59 	int				fnhe_genid;
60 	__be32				fnhe_daddr;
61 	u32				fnhe_pmtu;
62 	bool				fnhe_mtu_locked;
63 	__be32				fnhe_gw;
64 	unsigned long			fnhe_expires;
65 	struct rtable __rcu		*fnhe_rth_input;
66 	struct rtable __rcu		*fnhe_rth_output;
67 	unsigned long			fnhe_stamp;
68 	struct rcu_head			rcu;
69 };
70 
71 struct fnhe_hash_bucket {
72 	struct fib_nh_exception __rcu	*chain;
73 };
74 
75 #define FNHE_HASH_SHIFT		11
76 #define FNHE_HASH_SIZE		(1 << FNHE_HASH_SHIFT)
77 #define FNHE_RECLAIM_DEPTH	5
78 
79 struct fib_nh {
80 	struct net_device	*nh_dev;
81 	struct hlist_node	nh_hash;
82 	struct fib_info		*nh_parent;
83 	unsigned int		nh_flags;
84 	unsigned char		nh_scope;
85 #ifdef CONFIG_IP_ROUTE_MULTIPATH
86 	int			nh_weight;
87 	atomic_t		nh_upper_bound;
88 #endif
89 #ifdef CONFIG_IP_ROUTE_CLASSID
90 	__u32			nh_tclassid;
91 #endif
92 	int			nh_oif;
93 	__be32			nh_gw;
94 	__be32			nh_saddr;
95 	int			nh_saddr_genid;
96 	struct rtable __rcu * __percpu *nh_pcpu_rth_output;
97 	struct rtable __rcu	*nh_rth_input;
98 	struct fnhe_hash_bucket	__rcu *nh_exceptions;
99 	struct lwtunnel_state	*nh_lwtstate;
100 };
101 
102 /*
103  * This structure contains data shared by many of routes.
104  */
105 
106 struct fib_info {
107 	struct hlist_node	fib_hash;
108 	struct hlist_node	fib_lhash;
109 	struct net		*fib_net;
110 	int			fib_treeref;
111 	refcount_t		fib_clntref;
112 	unsigned int		fib_flags;
113 	unsigned char		fib_dead;
114 	unsigned char		fib_protocol;
115 	unsigned char		fib_scope;
116 	unsigned char		fib_type;
117 	__be32			fib_prefsrc;
118 	u32			fib_tb_id;
119 	u32			fib_priority;
120 	struct dst_metrics	*fib_metrics;
121 #define fib_mtu fib_metrics->metrics[RTAX_MTU-1]
122 #define fib_window fib_metrics->metrics[RTAX_WINDOW-1]
123 #define fib_rtt fib_metrics->metrics[RTAX_RTT-1]
124 #define fib_advmss fib_metrics->metrics[RTAX_ADVMSS-1]
125 	int			fib_nhs;
126 	struct rcu_head		rcu;
127 	struct fib_nh		fib_nh[0];
128 #define fib_dev		fib_nh[0].nh_dev
129 };
130 
131 
132 #ifdef CONFIG_IP_MULTIPLE_TABLES
133 struct fib_rule;
134 #endif
135 
136 struct fib_table;
137 struct fib_result {
138 	__be32		prefix;
139 	unsigned char	prefixlen;
140 	unsigned char	nh_sel;
141 	unsigned char	type;
142 	unsigned char	scope;
143 	u32		tclassid;
144 	struct fib_info *fi;
145 	struct fib_table *table;
146 	struct hlist_head *fa_head;
147 };
148 
149 struct fib_result_nl {
150 	__be32		fl_addr;   /* To be looked up*/
151 	u32		fl_mark;
152 	unsigned char	fl_tos;
153 	unsigned char   fl_scope;
154 	unsigned char   tb_id_in;
155 
156 	unsigned char   tb_id;      /* Results */
157 	unsigned char	prefixlen;
158 	unsigned char	nh_sel;
159 	unsigned char	type;
160 	unsigned char	scope;
161 	int             err;
162 };
163 
164 #ifdef CONFIG_IP_ROUTE_MULTIPATH
165 #define FIB_RES_NH(res)		((res).fi->fib_nh[(res).nh_sel])
166 #else /* CONFIG_IP_ROUTE_MULTIPATH */
167 #define FIB_RES_NH(res)		((res).fi->fib_nh[0])
168 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
169 
170 #ifdef CONFIG_IP_MULTIPLE_TABLES
171 #define FIB_TABLE_HASHSZ 256
172 #else
173 #define FIB_TABLE_HASHSZ 2
174 #endif
175 
176 __be32 fib_info_update_nh_saddr(struct net *net, struct fib_nh *nh);
177 
178 #define FIB_RES_SADDR(net, res)				\
179 	((FIB_RES_NH(res).nh_saddr_genid ==		\
180 	  atomic_read(&(net)->ipv4.dev_addr_genid)) ?	\
181 	 FIB_RES_NH(res).nh_saddr :			\
182 	 fib_info_update_nh_saddr((net), &FIB_RES_NH(res)))
183 #define FIB_RES_GW(res)			(FIB_RES_NH(res).nh_gw)
184 #define FIB_RES_DEV(res)		(FIB_RES_NH(res).nh_dev)
185 #define FIB_RES_OIF(res)		(FIB_RES_NH(res).nh_oif)
186 
187 #define FIB_RES_PREFSRC(net, res)	((res).fi->fib_prefsrc ? : \
188 					 FIB_RES_SADDR(net, res))
189 
190 struct fib_entry_notifier_info {
191 	struct fib_notifier_info info; /* must be first */
192 	u32 dst;
193 	int dst_len;
194 	struct fib_info *fi;
195 	u8 tos;
196 	u8 type;
197 	u32 tb_id;
198 };
199 
200 struct fib_nh_notifier_info {
201 	struct fib_notifier_info info; /* must be first */
202 	struct fib_nh *fib_nh;
203 };
204 
205 int call_fib4_notifier(struct notifier_block *nb, struct net *net,
206 		       enum fib_event_type event_type,
207 		       struct fib_notifier_info *info);
208 int call_fib4_notifiers(struct net *net, enum fib_event_type event_type,
209 			struct fib_notifier_info *info);
210 
211 int __net_init fib4_notifier_init(struct net *net);
212 void __net_exit fib4_notifier_exit(struct net *net);
213 
214 void fib_notify(struct net *net, struct notifier_block *nb);
215 
216 struct fib_table {
217 	struct hlist_node	tb_hlist;
218 	u32			tb_id;
219 	int			tb_num_default;
220 	struct rcu_head		rcu;
221 	unsigned long 		*tb_data;
222 	unsigned long		__data[0];
223 };
224 
225 int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
226 		     struct fib_result *res, int fib_flags);
227 int fib_table_insert(struct net *, struct fib_table *, struct fib_config *,
228 		     struct netlink_ext_ack *extack);
229 int fib_table_delete(struct net *, struct fib_table *, struct fib_config *,
230 		     struct netlink_ext_ack *extack);
231 int fib_table_dump(struct fib_table *table, struct sk_buff *skb,
232 		   struct netlink_callback *cb);
233 int fib_table_flush(struct net *net, struct fib_table *table);
234 struct fib_table *fib_trie_unmerge(struct fib_table *main_tb);
235 void fib_table_flush_external(struct fib_table *table);
236 void fib_free_table(struct fib_table *tb);
237 
238 #ifndef CONFIG_IP_MULTIPLE_TABLES
239 
240 #define TABLE_LOCAL_INDEX	(RT_TABLE_LOCAL & (FIB_TABLE_HASHSZ - 1))
241 #define TABLE_MAIN_INDEX	(RT_TABLE_MAIN  & (FIB_TABLE_HASHSZ - 1))
242 
243 static inline struct fib_table *fib_get_table(struct net *net, u32 id)
244 {
245 	struct hlist_node *tb_hlist;
246 	struct hlist_head *ptr;
247 
248 	ptr = id == RT_TABLE_LOCAL ?
249 		&net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
250 		&net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
251 
252 	tb_hlist = rcu_dereference_rtnl(hlist_first_rcu(ptr));
253 
254 	return hlist_entry(tb_hlist, struct fib_table, tb_hlist);
255 }
256 
257 static inline struct fib_table *fib_new_table(struct net *net, u32 id)
258 {
259 	return fib_get_table(net, id);
260 }
261 
262 static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
263 			     struct fib_result *res, unsigned int flags)
264 {
265 	struct fib_table *tb;
266 	int err = -ENETUNREACH;
267 
268 	rcu_read_lock();
269 
270 	tb = fib_get_table(net, RT_TABLE_MAIN);
271 	if (tb)
272 		err = fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF);
273 
274 	if (err == -EAGAIN)
275 		err = -ENETUNREACH;
276 
277 	rcu_read_unlock();
278 
279 	return err;
280 }
281 
282 static inline bool fib4_rule_default(const struct fib_rule *rule)
283 {
284 	return true;
285 }
286 
287 static inline int fib4_rules_dump(struct net *net, struct notifier_block *nb)
288 {
289 	return 0;
290 }
291 
292 static inline unsigned int fib4_rules_seq_read(struct net *net)
293 {
294 	return 0;
295 }
296 
297 static inline bool fib4_rules_early_flow_dissect(struct net *net,
298 						 struct sk_buff *skb,
299 						 struct flowi4 *fl4,
300 						 struct flow_keys *flkeys)
301 {
302 	return false;
303 }
304 #else /* CONFIG_IP_MULTIPLE_TABLES */
305 int __net_init fib4_rules_init(struct net *net);
306 void __net_exit fib4_rules_exit(struct net *net);
307 
308 struct fib_table *fib_new_table(struct net *net, u32 id);
309 struct fib_table *fib_get_table(struct net *net, u32 id);
310 
311 int __fib_lookup(struct net *net, struct flowi4 *flp,
312 		 struct fib_result *res, unsigned int flags);
313 
314 static inline int fib_lookup(struct net *net, struct flowi4 *flp,
315 			     struct fib_result *res, unsigned int flags)
316 {
317 	struct fib_table *tb;
318 	int err = -ENETUNREACH;
319 
320 	flags |= FIB_LOOKUP_NOREF;
321 	if (net->ipv4.fib_has_custom_rules)
322 		return __fib_lookup(net, flp, res, flags);
323 
324 	rcu_read_lock();
325 
326 	res->tclassid = 0;
327 
328 	tb = rcu_dereference_rtnl(net->ipv4.fib_main);
329 	if (tb)
330 		err = fib_table_lookup(tb, flp, res, flags);
331 
332 	if (!err)
333 		goto out;
334 
335 	tb = rcu_dereference_rtnl(net->ipv4.fib_default);
336 	if (tb)
337 		err = fib_table_lookup(tb, flp, res, flags);
338 
339 out:
340 	if (err == -EAGAIN)
341 		err = -ENETUNREACH;
342 
343 	rcu_read_unlock();
344 
345 	return err;
346 }
347 
348 bool fib4_rule_default(const struct fib_rule *rule);
349 int fib4_rules_dump(struct net *net, struct notifier_block *nb);
350 unsigned int fib4_rules_seq_read(struct net *net);
351 
352 static inline bool fib4_rules_early_flow_dissect(struct net *net,
353 						 struct sk_buff *skb,
354 						 struct flowi4 *fl4,
355 						 struct flow_keys *flkeys)
356 {
357 	unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
358 
359 	if (!net->ipv4.fib_rules_require_fldissect)
360 		return false;
361 
362 	skb_flow_dissect_flow_keys(skb, flkeys, flag);
363 	fl4->fl4_sport = flkeys->ports.src;
364 	fl4->fl4_dport = flkeys->ports.dst;
365 	fl4->flowi4_proto = flkeys->basic.ip_proto;
366 
367 	return true;
368 }
369 
370 #endif /* CONFIG_IP_MULTIPLE_TABLES */
371 
372 /* Exported by fib_frontend.c */
373 extern const struct nla_policy rtm_ipv4_policy[];
374 void ip_fib_init(void);
375 __be32 fib_compute_spec_dst(struct sk_buff *skb);
376 int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
377 			u8 tos, int oif, struct net_device *dev,
378 			struct in_device *idev, u32 *itag);
379 #ifdef CONFIG_IP_ROUTE_CLASSID
380 static inline int fib_num_tclassid_users(struct net *net)
381 {
382 	return net->ipv4.fib_num_tclassid_users;
383 }
384 #else
385 static inline int fib_num_tclassid_users(struct net *net)
386 {
387 	return 0;
388 }
389 #endif
390 int fib_unmerge(struct net *net);
391 
392 /* Exported by fib_semantics.c */
393 int ip_fib_check_default(__be32 gw, struct net_device *dev);
394 int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force);
395 int fib_sync_down_addr(struct net_device *dev, __be32 local);
396 int fib_sync_up(struct net_device *dev, unsigned int nh_flags);
397 
398 #ifdef CONFIG_IP_ROUTE_MULTIPATH
399 int fib_multipath_hash(const struct net *net, const struct flowi4 *fl4,
400 		       const struct sk_buff *skb, struct flow_keys *flkeys);
401 #endif
402 void fib_select_multipath(struct fib_result *res, int hash);
403 void fib_select_path(struct net *net, struct fib_result *res,
404 		     struct flowi4 *fl4, const struct sk_buff *skb);
405 
406 /* Exported by fib_trie.c */
407 void fib_trie_init(void);
408 struct fib_table *fib_trie_table(u32 id, struct fib_table *alias);
409 
410 static inline void fib_combine_itag(u32 *itag, const struct fib_result *res)
411 {
412 #ifdef CONFIG_IP_ROUTE_CLASSID
413 #ifdef CONFIG_IP_MULTIPLE_TABLES
414 	u32 rtag;
415 #endif
416 	*itag = FIB_RES_NH(*res).nh_tclassid<<16;
417 #ifdef CONFIG_IP_MULTIPLE_TABLES
418 	rtag = res->tclassid;
419 	if (*itag == 0)
420 		*itag = (rtag<<16);
421 	*itag |= (rtag>>16);
422 #endif
423 #endif
424 }
425 
426 void free_fib_info(struct fib_info *fi);
427 
428 static inline void fib_info_hold(struct fib_info *fi)
429 {
430 	refcount_inc(&fi->fib_clntref);
431 }
432 
433 static inline void fib_info_put(struct fib_info *fi)
434 {
435 	if (refcount_dec_and_test(&fi->fib_clntref))
436 		free_fib_info(fi);
437 }
438 
439 #ifdef CONFIG_PROC_FS
440 int __net_init fib_proc_init(struct net *net);
441 void __net_exit fib_proc_exit(struct net *net);
442 #else
443 static inline int fib_proc_init(struct net *net)
444 {
445 	return 0;
446 }
447 static inline void fib_proc_exit(struct net *net)
448 {
449 }
450 #endif
451 
452 u32 ip_mtu_from_fib_result(struct fib_result *res, __be32 daddr);
453 
454 #endif  /* _NET_FIB_H */
455