Linux Audio

Check our new training course

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