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