1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  * INET		An implementation of the TCP/IP protocol suite for the LINUX
4  *		operating system.  INET  is implemented using the  BSD Socket
5  *		interface as the means of communication with the user level.
6  *
7  *		Definitions for the Forwarding Information Base.
8  *
9  * Authors:	A.N.Kuznetsov, <kuznet@ms2.inr.ac.ru>
10  */
11 
12 #ifndef _NET_IP_FIB_H
13 #define _NET_IP_FIB_H
14 
15 #include <net/flow.h>
16 #include <linux/seq_file.h>
17 #include <linux/rcupdate.h>
18 #include <net/fib_notifier.h>
19 #include <net/fib_rules.h>
20 #include <net/inet_dscp.h>
21 #include <net/inetpeer.h>
22 #include <linux/percpu.h>
23 #include <linux/notifier.h>
24 #include <linux/refcount.h>
25 
26 struct fib_config {
27 	u8			fc_dst_len;
28 	dscp_t			fc_dscp;
29 	u8			fc_protocol;
30 	u8			fc_scope;
31 	u8			fc_type;
32 	u8			fc_gw_family;
33 	/* 2 bytes unused */
34 	u32			fc_table;
35 	__be32			fc_dst;
36 	union {
37 		__be32		fc_gw4;
38 		struct in6_addr	fc_gw6;
39 	};
40 	int			fc_oif;
41 	u32			fc_flags;
42 	u32			fc_priority;
43 	__be32			fc_prefsrc;
44 	u32			fc_nh_id;
45 	struct nlattr		*fc_mx;
46 	struct rtnexthop	*fc_mp;
47 	int			fc_mx_len;
48 	int			fc_mp_len;
49 	u32			fc_flow;
50 	u32			fc_nlflags;
51 	struct nl_info		fc_nlinfo;
52 	struct nlattr		*fc_encap;
53 	u16			fc_encap_type;
54 };
55 
56 struct fib_info;
57 struct rtable;
58 
59 struct fib_nh_exception {
60 	struct fib_nh_exception __rcu	*fnhe_next;
61 	int				fnhe_genid;
62 	__be32				fnhe_daddr;
63 	u32				fnhe_pmtu;
64 	bool				fnhe_mtu_locked;
65 	__be32				fnhe_gw;
66 	unsigned long			fnhe_expires;
67 	struct rtable __rcu		*fnhe_rth_input;
68 	struct rtable __rcu		*fnhe_rth_output;
69 	unsigned long			fnhe_stamp;
70 	struct rcu_head			rcu;
71 };
72 
73 struct fnhe_hash_bucket {
74 	struct fib_nh_exception __rcu	*chain;
75 };
76 
77 #define FNHE_HASH_SHIFT		11
78 #define FNHE_HASH_SIZE		(1 << FNHE_HASH_SHIFT)
79 #define FNHE_RECLAIM_DEPTH	5
80 
81 struct fib_nh_common {
82 	struct net_device	*nhc_dev;
83 	netdevice_tracker	nhc_dev_tracker;
84 	int			nhc_oif;
85 	unsigned char		nhc_scope;
86 	u8			nhc_family;
87 	u8			nhc_gw_family;
88 	unsigned char		nhc_flags;
89 	struct lwtunnel_state	*nhc_lwtstate;
90 
91 	union {
92 		__be32          ipv4;
93 		struct in6_addr ipv6;
94 	} nhc_gw;
95 
96 	int			nhc_weight;
97 	atomic_t		nhc_upper_bound;
98 
99 	/* v4 specific, but allows fib6_nh with v4 routes */
100 	struct rtable __rcu * __percpu *nhc_pcpu_rth_output;
101 	struct rtable __rcu     *nhc_rth_input;
102 	struct fnhe_hash_bucket	__rcu *nhc_exceptions;
103 };
104 
105 struct fib_nh {
106 	struct fib_nh_common	nh_common;
107 	struct hlist_node	nh_hash;
108 	struct fib_info		*nh_parent;
109 #ifdef CONFIG_IP_ROUTE_CLASSID
110 	__u32			nh_tclassid;
111 #endif
112 	__be32			nh_saddr;
113 	int			nh_saddr_genid;
114 #define fib_nh_family		nh_common.nhc_family
115 #define fib_nh_dev		nh_common.nhc_dev
116 #define fib_nh_dev_tracker	nh_common.nhc_dev_tracker
117 #define fib_nh_oif		nh_common.nhc_oif
118 #define fib_nh_flags		nh_common.nhc_flags
119 #define fib_nh_lws		nh_common.nhc_lwtstate
120 #define fib_nh_scope		nh_common.nhc_scope
121 #define fib_nh_gw_family	nh_common.nhc_gw_family
122 #define fib_nh_gw4		nh_common.nhc_gw.ipv4
123 #define fib_nh_gw6		nh_common.nhc_gw.ipv6
124 #define fib_nh_weight		nh_common.nhc_weight
125 #define fib_nh_upper_bound	nh_common.nhc_upper_bound
126 };
127 
128 /*
129  * This structure contains data shared by many of routes.
130  */
131 
132 struct nexthop;
133 
134 struct fib_info {
135 	struct hlist_node	fib_hash;
136 	struct hlist_node	fib_lhash;
137 	struct list_head	nh_list;
138 	struct net		*fib_net;
139 	refcount_t		fib_treeref;
140 	refcount_t		fib_clntref;
141 	unsigned int		fib_flags;
142 	unsigned char		fib_dead;
143 	unsigned char		fib_protocol;
144 	unsigned char		fib_scope;
145 	unsigned char		fib_type;
146 	__be32			fib_prefsrc;
147 	u32			fib_tb_id;
148 	u32			fib_priority;
149 	struct dst_metrics	*fib_metrics;
150 #define fib_mtu fib_metrics->metrics[RTAX_MTU-1]
151 #define fib_window fib_metrics->metrics[RTAX_WINDOW-1]
152 #define fib_rtt fib_metrics->metrics[RTAX_RTT-1]
153 #define fib_advmss fib_metrics->metrics[RTAX_ADVMSS-1]
154 	int			fib_nhs;
155 	bool			fib_nh_is_v6;
156 	bool			nh_updated;
157 	struct nexthop		*nh;
158 	struct rcu_head		rcu;
159 	struct fib_nh		fib_nh[];
160 };
161 
162 
163 #ifdef CONFIG_IP_MULTIPLE_TABLES
164 struct fib_rule;
165 #endif
166 
167 struct fib_table;
168 struct fib_result {
169 	__be32			prefix;
170 	unsigned char		prefixlen;
171 	unsigned char		nh_sel;
172 	unsigned char		type;
173 	unsigned char		scope;
174 	u32			tclassid;
175 	struct fib_nh_common	*nhc;
176 	struct fib_info		*fi;
177 	struct fib_table	*table;
178 	struct hlist_head	*fa_head;
179 };
180 
181 struct fib_result_nl {
182 	__be32		fl_addr;   /* To be looked up*/
183 	u32		fl_mark;
184 	unsigned char	fl_tos;
185 	unsigned char   fl_scope;
186 	unsigned char   tb_id_in;
187 
188 	unsigned char   tb_id;      /* Results */
189 	unsigned char	prefixlen;
190 	unsigned char	nh_sel;
191 	unsigned char	type;
192 	unsigned char	scope;
193 	int             err;
194 };
195 
196 #ifdef CONFIG_IP_MULTIPLE_TABLES
197 #define FIB_TABLE_HASHSZ 256
198 #else
199 #define FIB_TABLE_HASHSZ 2
200 #endif
201 
202 __be32 fib_info_update_nhc_saddr(struct net *net, struct fib_nh_common *nhc,
203 				 unsigned char scope);
204 __be32 fib_result_prefsrc(struct net *net, struct fib_result *res);
205 
206 #define FIB_RES_NHC(res)		((res).nhc)
207 #define FIB_RES_DEV(res)	(FIB_RES_NHC(res)->nhc_dev)
208 #define FIB_RES_OIF(res)	(FIB_RES_NHC(res)->nhc_oif)
209 
210 struct fib_rt_info {
211 	struct fib_info		*fi;
212 	u32			tb_id;
213 	__be32			dst;
214 	int			dst_len;
215 	dscp_t			dscp;
216 	u8			type;
217 	u8			offload:1,
218 				trap:1,
219 				offload_failed:1,
220 				unused:5;
221 };
222 
223 struct fib_entry_notifier_info {
224 	struct fib_notifier_info info; /* must be first */
225 	u32 dst;
226 	int dst_len;
227 	struct fib_info *fi;
228 	dscp_t dscp;
229 	u8 type;
230 	u32 tb_id;
231 };
232 
233 struct fib_nh_notifier_info {
234 	struct fib_notifier_info info; /* must be first */
235 	struct fib_nh *fib_nh;
236 };
237 
238 int call_fib4_notifier(struct notifier_block *nb,
239 		       enum fib_event_type event_type,
240 		       struct fib_notifier_info *info);
241 int call_fib4_notifiers(struct net *net, enum fib_event_type event_type,
242 			struct fib_notifier_info *info);
243 
244 int __net_init fib4_notifier_init(struct net *net);
245 void __net_exit fib4_notifier_exit(struct net *net);
246 
247 void fib_info_notify_update(struct net *net, struct nl_info *info);
248 int fib_notify(struct net *net, struct notifier_block *nb,
249 	       struct netlink_ext_ack *extack);
250 
251 struct fib_table {
252 	struct hlist_node	tb_hlist;
253 	u32			tb_id;
254 	int			tb_num_default;
255 	struct rcu_head		rcu;
256 	unsigned long 		*tb_data;
257 	unsigned long		__data[];
258 };
259 
260 struct fib_dump_filter {
261 	u32			table_id;
262 	/* filter_set is an optimization that an entry is set */
263 	bool			filter_set;
264 	bool			dump_routes;
265 	bool			dump_exceptions;
266 	unsigned char		protocol;
267 	unsigned char		rt_type;
268 	unsigned int		flags;
269 	struct net_device	*dev;
270 };
271 
272 int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
273 		     struct fib_result *res, int fib_flags);
274 int fib_table_insert(struct net *, struct fib_table *, struct fib_config *,
275 		     struct netlink_ext_ack *extack);
276 int fib_table_delete(struct net *, struct fib_table *, struct fib_config *,
277 		     struct netlink_ext_ack *extack);
278 int fib_table_dump(struct fib_table *table, struct sk_buff *skb,
279 		   struct netlink_callback *cb, struct fib_dump_filter *filter);
280 int fib_table_flush(struct net *net, struct fib_table *table, bool flush_all);
281 struct fib_table *fib_trie_unmerge(struct fib_table *main_tb);
282 void fib_table_flush_external(struct fib_table *table);
283 void fib_free_table(struct fib_table *tb);
284 
285 #ifndef CONFIG_IP_MULTIPLE_TABLES
286 
287 #define TABLE_LOCAL_INDEX	(RT_TABLE_LOCAL & (FIB_TABLE_HASHSZ - 1))
288 #define TABLE_MAIN_INDEX	(RT_TABLE_MAIN  & (FIB_TABLE_HASHSZ - 1))
289 
fib_get_table(struct net * net,u32 id)290 static inline struct fib_table *fib_get_table(struct net *net, u32 id)
291 {
292 	struct hlist_node *tb_hlist;
293 	struct hlist_head *ptr;
294 
295 	ptr = id == RT_TABLE_LOCAL ?
296 		&net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
297 		&net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
298 
299 	tb_hlist = rcu_dereference_rtnl(hlist_first_rcu(ptr));
300 
301 	return hlist_entry(tb_hlist, struct fib_table, tb_hlist);
302 }
303 
fib_new_table(struct net * net,u32 id)304 static inline struct fib_table *fib_new_table(struct net *net, u32 id)
305 {
306 	return fib_get_table(net, id);
307 }
308 
fib_lookup(struct net * net,const struct flowi4 * flp,struct fib_result * res,unsigned int flags)309 static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
310 			     struct fib_result *res, unsigned int flags)
311 {
312 	struct fib_table *tb;
313 	int err = -ENETUNREACH;
314 
315 	rcu_read_lock();
316 
317 	tb = fib_get_table(net, RT_TABLE_MAIN);
318 	if (tb)
319 		err = fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF);
320 
321 	if (err == -EAGAIN)
322 		err = -ENETUNREACH;
323 
324 	rcu_read_unlock();
325 
326 	return err;
327 }
328 
fib4_has_custom_rules(const struct net * net)329 static inline bool fib4_has_custom_rules(const struct net *net)
330 {
331 	return false;
332 }
333 
fib4_rule_default(const struct fib_rule * rule)334 static inline bool fib4_rule_default(const struct fib_rule *rule)
335 {
336 	return true;
337 }
338 
fib4_rules_dump(struct net * net,struct notifier_block * nb,struct netlink_ext_ack * extack)339 static inline int fib4_rules_dump(struct net *net, struct notifier_block *nb,
340 				  struct netlink_ext_ack *extack)
341 {
342 	return 0;
343 }
344 
fib4_rules_seq_read(struct net * net)345 static inline unsigned int fib4_rules_seq_read(struct net *net)
346 {
347 	return 0;
348 }
349 
fib4_rules_early_flow_dissect(struct net * net,struct sk_buff * skb,struct flowi4 * fl4,struct flow_keys * flkeys)350 static inline bool fib4_rules_early_flow_dissect(struct net *net,
351 						 struct sk_buff *skb,
352 						 struct flowi4 *fl4,
353 						 struct flow_keys *flkeys)
354 {
355 	return false;
356 }
357 #else /* CONFIG_IP_MULTIPLE_TABLES */
358 int __net_init fib4_rules_init(struct net *net);
359 void __net_exit fib4_rules_exit(struct net *net);
360 
361 struct fib_table *fib_new_table(struct net *net, u32 id);
362 struct fib_table *fib_get_table(struct net *net, u32 id);
363 
364 int __fib_lookup(struct net *net, struct flowi4 *flp,
365 		 struct fib_result *res, unsigned int flags);
366 
fib_lookup(struct net * net,struct flowi4 * flp,struct fib_result * res,unsigned int flags)367 static inline int fib_lookup(struct net *net, struct flowi4 *flp,
368 			     struct fib_result *res, unsigned int flags)
369 {
370 	struct fib_table *tb;
371 	int err = -ENETUNREACH;
372 
373 	flags |= FIB_LOOKUP_NOREF;
374 	if (net->ipv4.fib_has_custom_rules)
375 		return __fib_lookup(net, flp, res, flags);
376 
377 	rcu_read_lock();
378 
379 	res->tclassid = 0;
380 
381 	tb = rcu_dereference_rtnl(net->ipv4.fib_main);
382 	if (tb)
383 		err = fib_table_lookup(tb, flp, res, flags);
384 
385 	if (!err)
386 		goto out;
387 
388 	tb = rcu_dereference_rtnl(net->ipv4.fib_default);
389 	if (tb)
390 		err = fib_table_lookup(tb, flp, res, flags);
391 
392 out:
393 	if (err == -EAGAIN)
394 		err = -ENETUNREACH;
395 
396 	rcu_read_unlock();
397 
398 	return err;
399 }
400 
fib4_has_custom_rules(const struct net * net)401 static inline bool fib4_has_custom_rules(const struct net *net)
402 {
403 	return net->ipv4.fib_has_custom_rules;
404 }
405 
406 bool fib4_rule_default(const struct fib_rule *rule);
407 int fib4_rules_dump(struct net *net, struct notifier_block *nb,
408 		    struct netlink_ext_ack *extack);
409 unsigned int fib4_rules_seq_read(struct net *net);
410 
fib4_rules_early_flow_dissect(struct net * net,struct sk_buff * skb,struct flowi4 * fl4,struct flow_keys * flkeys)411 static inline bool fib4_rules_early_flow_dissect(struct net *net,
412 						 struct sk_buff *skb,
413 						 struct flowi4 *fl4,
414 						 struct flow_keys *flkeys)
415 {
416 	unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
417 
418 	if (!net->ipv4.fib_rules_require_fldissect)
419 		return false;
420 
421 	skb_flow_dissect_flow_keys(skb, flkeys, flag);
422 	fl4->fl4_sport = flkeys->ports.src;
423 	fl4->fl4_dport = flkeys->ports.dst;
424 	fl4->flowi4_proto = flkeys->basic.ip_proto;
425 
426 	return true;
427 }
428 
429 #endif /* CONFIG_IP_MULTIPLE_TABLES */
430 
431 /* Exported by fib_frontend.c */
432 extern const struct nla_policy rtm_ipv4_policy[];
433 void ip_fib_init(void);
434 int fib_gw_from_via(struct fib_config *cfg, struct nlattr *nla,
435 		    struct netlink_ext_ack *extack);
436 __be32 fib_compute_spec_dst(struct sk_buff *skb);
437 bool fib_info_nh_uses_dev(struct fib_info *fi, const struct net_device *dev);
438 int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
439 			u8 tos, int oif, struct net_device *dev,
440 			struct in_device *idev, u32 *itag);
441 #ifdef CONFIG_IP_ROUTE_CLASSID
fib_num_tclassid_users(struct net * net)442 static inline int fib_num_tclassid_users(struct net *net)
443 {
444 	return atomic_read(&net->ipv4.fib_num_tclassid_users);
445 }
446 #else
fib_num_tclassid_users(struct net * net)447 static inline int fib_num_tclassid_users(struct net *net)
448 {
449 	return 0;
450 }
451 #endif
452 int fib_unmerge(struct net *net);
453 
nhc_l3mdev_matches_dev(const struct fib_nh_common * nhc,const struct net_device * dev)454 static inline bool nhc_l3mdev_matches_dev(const struct fib_nh_common *nhc,
455 const struct net_device *dev)
456 {
457 	if (nhc->nhc_dev == dev ||
458 	    l3mdev_master_ifindex_rcu(nhc->nhc_dev) == dev->ifindex)
459 		return true;
460 
461 	return false;
462 }
463 
464 /* Exported by fib_semantics.c */
465 int ip_fib_check_default(__be32 gw, struct net_device *dev);
466 int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force);
467 int fib_sync_down_addr(struct net_device *dev, __be32 local);
468 int fib_sync_up(struct net_device *dev, unsigned char nh_flags);
469 void fib_sync_mtu(struct net_device *dev, u32 orig_mtu);
470 void fib_nhc_update_mtu(struct fib_nh_common *nhc, u32 new, u32 orig);
471 
472 /* Fields used for sysctl_fib_multipath_hash_fields.
473  * Common to IPv4 and IPv6.
474  *
475  * Add new fields at the end. This is user API.
476  */
477 #define FIB_MULTIPATH_HASH_FIELD_SRC_IP			BIT(0)
478 #define FIB_MULTIPATH_HASH_FIELD_DST_IP			BIT(1)
479 #define FIB_MULTIPATH_HASH_FIELD_IP_PROTO		BIT(2)
480 #define FIB_MULTIPATH_HASH_FIELD_FLOWLABEL		BIT(3)
481 #define FIB_MULTIPATH_HASH_FIELD_SRC_PORT		BIT(4)
482 #define FIB_MULTIPATH_HASH_FIELD_DST_PORT		BIT(5)
483 #define FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP		BIT(6)
484 #define FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP		BIT(7)
485 #define FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO		BIT(8)
486 #define FIB_MULTIPATH_HASH_FIELD_INNER_FLOWLABEL	BIT(9)
487 #define FIB_MULTIPATH_HASH_FIELD_INNER_SRC_PORT		BIT(10)
488 #define FIB_MULTIPATH_HASH_FIELD_INNER_DST_PORT		BIT(11)
489 
490 #define FIB_MULTIPATH_HASH_FIELD_OUTER_MASK		\
491 	(FIB_MULTIPATH_HASH_FIELD_SRC_IP |		\
492 	 FIB_MULTIPATH_HASH_FIELD_DST_IP |		\
493 	 FIB_MULTIPATH_HASH_FIELD_IP_PROTO |		\
494 	 FIB_MULTIPATH_HASH_FIELD_FLOWLABEL |		\
495 	 FIB_MULTIPATH_HASH_FIELD_SRC_PORT |		\
496 	 FIB_MULTIPATH_HASH_FIELD_DST_PORT)
497 
498 #define FIB_MULTIPATH_HASH_FIELD_INNER_MASK		\
499 	(FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP |	\
500 	 FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP |	\
501 	 FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO |	\
502 	 FIB_MULTIPATH_HASH_FIELD_INNER_FLOWLABEL |	\
503 	 FIB_MULTIPATH_HASH_FIELD_INNER_SRC_PORT |	\
504 	 FIB_MULTIPATH_HASH_FIELD_INNER_DST_PORT)
505 
506 #define FIB_MULTIPATH_HASH_FIELD_ALL_MASK		\
507 	(FIB_MULTIPATH_HASH_FIELD_OUTER_MASK |		\
508 	 FIB_MULTIPATH_HASH_FIELD_INNER_MASK)
509 
510 #define FIB_MULTIPATH_HASH_FIELD_DEFAULT_MASK		\
511 	(FIB_MULTIPATH_HASH_FIELD_SRC_IP |		\
512 	 FIB_MULTIPATH_HASH_FIELD_DST_IP |		\
513 	 FIB_MULTIPATH_HASH_FIELD_IP_PROTO)
514 
515 #ifdef CONFIG_IP_ROUTE_MULTIPATH
516 int fib_multipath_hash(const struct net *net, const struct flowi4 *fl4,
517 		       const struct sk_buff *skb, struct flow_keys *flkeys);
518 #endif
519 int fib_check_nh(struct net *net, struct fib_nh *nh, u32 table, u8 scope,
520 		 struct netlink_ext_ack *extack);
521 void fib_select_multipath(struct fib_result *res, int hash);
522 void fib_select_path(struct net *net, struct fib_result *res,
523 		     struct flowi4 *fl4, const struct sk_buff *skb);
524 
525 int fib_nh_init(struct net *net, struct fib_nh *fib_nh,
526 		struct fib_config *cfg, int nh_weight,
527 		struct netlink_ext_ack *extack);
528 void fib_nh_release(struct net *net, struct fib_nh *fib_nh);
529 int fib_nh_common_init(struct net *net, struct fib_nh_common *nhc,
530 		       struct nlattr *fc_encap, u16 fc_encap_type,
531 		       void *cfg, gfp_t gfp_flags,
532 		       struct netlink_ext_ack *extack);
533 void fib_nh_common_release(struct fib_nh_common *nhc);
534 
535 /* Exported by fib_trie.c */
536 void fib_alias_hw_flags_set(struct net *net, const struct fib_rt_info *fri);
537 void fib_trie_init(void);
538 struct fib_table *fib_trie_table(u32 id, struct fib_table *alias);
539 bool fib_lookup_good_nhc(const struct fib_nh_common *nhc, int fib_flags,
540 			 const struct flowi4 *flp);
541 
fib_combine_itag(u32 * itag,const struct fib_result * res)542 static inline void fib_combine_itag(u32 *itag, const struct fib_result *res)
543 {
544 #ifdef CONFIG_IP_ROUTE_CLASSID
545 	struct fib_nh_common *nhc = res->nhc;
546 #ifdef CONFIG_IP_MULTIPLE_TABLES
547 	u32 rtag;
548 #endif
549 	if (nhc->nhc_family == AF_INET) {
550 		struct fib_nh *nh;
551 
552 		nh = container_of(nhc, struct fib_nh, nh_common);
553 		*itag = nh->nh_tclassid << 16;
554 	} else {
555 		*itag = 0;
556 	}
557 
558 #ifdef CONFIG_IP_MULTIPLE_TABLES
559 	rtag = res->tclassid;
560 	if (*itag == 0)
561 		*itag = (rtag<<16);
562 	*itag |= (rtag>>16);
563 #endif
564 #endif
565 }
566 
567 void fib_flush(struct net *net);
568 void free_fib_info(struct fib_info *fi);
569 
fib_info_hold(struct fib_info * fi)570 static inline void fib_info_hold(struct fib_info *fi)
571 {
572 	refcount_inc(&fi->fib_clntref);
573 }
574 
fib_info_put(struct fib_info * fi)575 static inline void fib_info_put(struct fib_info *fi)
576 {
577 	if (refcount_dec_and_test(&fi->fib_clntref))
578 		free_fib_info(fi);
579 }
580 
581 #ifdef CONFIG_PROC_FS
582 int __net_init fib_proc_init(struct net *net);
583 void __net_exit fib_proc_exit(struct net *net);
584 #else
fib_proc_init(struct net * net)585 static inline int fib_proc_init(struct net *net)
586 {
587 	return 0;
588 }
fib_proc_exit(struct net * net)589 static inline void fib_proc_exit(struct net *net)
590 {
591 }
592 #endif
593 
594 u32 ip_mtu_from_fib_result(struct fib_result *res, __be32 daddr);
595 
596 int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,
597 			  struct fib_dump_filter *filter,
598 			  struct netlink_callback *cb);
599 
600 int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nh,
601 		     u8 rt_family, unsigned char *flags, bool skip_oif);
602 int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nh,
603 		    int nh_weight, u8 rt_family, u32 nh_tclassid);
604 #endif  /* _NET_FIB_H */
605