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 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_common { 80 struct net_device *nhc_dev; 81 int nhc_oif; 82 unsigned char nhc_scope; 83 u8 nhc_family; 84 u8 nhc_gw_family; 85 unsigned char nhc_flags; 86 struct lwtunnel_state *nhc_lwtstate; 87 88 union { 89 __be32 ipv4; 90 struct in6_addr ipv6; 91 } nhc_gw; 92 93 int nhc_weight; 94 atomic_t nhc_upper_bound; 95 96 /* v4 specific, but allows fib6_nh with v4 routes */ 97 struct rtable __rcu * __percpu *nhc_pcpu_rth_output; 98 struct rtable __rcu *nhc_rth_input; 99 struct fnhe_hash_bucket __rcu *nhc_exceptions; 100 }; 101 102 struct fib_nh { 103 struct fib_nh_common nh_common; 104 struct hlist_node nh_hash; 105 struct fib_info *nh_parent; 106 #ifdef CONFIG_IP_ROUTE_CLASSID 107 __u32 nh_tclassid; 108 #endif 109 __be32 nh_saddr; 110 int nh_saddr_genid; 111 #define fib_nh_family nh_common.nhc_family 112 #define fib_nh_dev nh_common.nhc_dev 113 #define fib_nh_oif nh_common.nhc_oif 114 #define fib_nh_flags nh_common.nhc_flags 115 #define fib_nh_lws nh_common.nhc_lwtstate 116 #define fib_nh_scope nh_common.nhc_scope 117 #define fib_nh_gw_family nh_common.nhc_gw_family 118 #define fib_nh_gw4 nh_common.nhc_gw.ipv4 119 #define fib_nh_gw6 nh_common.nhc_gw.ipv6 120 #define fib_nh_weight nh_common.nhc_weight 121 #define fib_nh_upper_bound nh_common.nhc_upper_bound 122 }; 123 124 /* 125 * This structure contains data shared by many of routes. 126 */ 127 128 struct fib_info { 129 struct hlist_node fib_hash; 130 struct hlist_node fib_lhash; 131 struct net *fib_net; 132 int fib_treeref; 133 refcount_t fib_clntref; 134 unsigned int fib_flags; 135 unsigned char fib_dead; 136 unsigned char fib_protocol; 137 unsigned char fib_scope; 138 unsigned char fib_type; 139 __be32 fib_prefsrc; 140 u32 fib_tb_id; 141 u32 fib_priority; 142 struct dst_metrics *fib_metrics; 143 #define fib_mtu fib_metrics->metrics[RTAX_MTU-1] 144 #define fib_window fib_metrics->metrics[RTAX_WINDOW-1] 145 #define fib_rtt fib_metrics->metrics[RTAX_RTT-1] 146 #define fib_advmss fib_metrics->metrics[RTAX_ADVMSS-1] 147 int fib_nhs; 148 bool fib_nh_is_v6; 149 struct rcu_head rcu; 150 struct fib_nh fib_nh[0]; 151 #define fib_dev fib_nh[0].fib_nh_dev 152 }; 153 154 155 #ifdef CONFIG_IP_MULTIPLE_TABLES 156 struct fib_rule; 157 #endif 158 159 struct fib_table; 160 struct fib_result { 161 __be32 prefix; 162 unsigned char prefixlen; 163 unsigned char nh_sel; 164 unsigned char type; 165 unsigned char scope; 166 u32 tclassid; 167 struct fib_nh_common *nhc; 168 struct fib_info *fi; 169 struct fib_table *table; 170 struct hlist_head *fa_head; 171 }; 172 173 struct fib_result_nl { 174 __be32 fl_addr; /* To be looked up*/ 175 u32 fl_mark; 176 unsigned char fl_tos; 177 unsigned char fl_scope; 178 unsigned char tb_id_in; 179 180 unsigned char tb_id; /* Results */ 181 unsigned char prefixlen; 182 unsigned char nh_sel; 183 unsigned char type; 184 unsigned char scope; 185 int err; 186 }; 187 188 static inline struct fib_nh_common *fib_info_nhc(struct fib_info *fi, int nhsel) 189 { 190 return &fi->fib_nh[nhsel].nh_common; 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_nh_saddr(struct net *net, struct fib_nh *nh); 200 __be32 fib_result_prefsrc(struct net *net, struct fib_result *res); 201 202 #define FIB_RES_NHC(res) ((res).nhc) 203 #define FIB_RES_DEV(res) (FIB_RES_NHC(res)->nhc_dev) 204 #define FIB_RES_OIF(res) (FIB_RES_NHC(res)->nhc_oif) 205 206 struct fib_entry_notifier_info { 207 struct fib_notifier_info info; /* must be first */ 208 u32 dst; 209 int dst_len; 210 struct fib_info *fi; 211 u8 tos; 212 u8 type; 213 u32 tb_id; 214 }; 215 216 struct fib_nh_notifier_info { 217 struct fib_notifier_info info; /* must be first */ 218 struct fib_nh *fib_nh; 219 }; 220 221 int call_fib4_notifier(struct notifier_block *nb, struct net *net, 222 enum fib_event_type event_type, 223 struct fib_notifier_info *info); 224 int call_fib4_notifiers(struct net *net, enum fib_event_type event_type, 225 struct fib_notifier_info *info); 226 227 int __net_init fib4_notifier_init(struct net *net); 228 void __net_exit fib4_notifier_exit(struct net *net); 229 230 void fib_notify(struct net *net, struct notifier_block *nb); 231 232 struct fib_table { 233 struct hlist_node tb_hlist; 234 u32 tb_id; 235 int tb_num_default; 236 struct rcu_head rcu; 237 unsigned long *tb_data; 238 unsigned long __data[0]; 239 }; 240 241 struct fib_dump_filter { 242 u32 table_id; 243 /* filter_set is an optimization that an entry is set */ 244 bool filter_set; 245 bool dump_all_families; 246 unsigned char protocol; 247 unsigned char rt_type; 248 unsigned int flags; 249 struct net_device *dev; 250 }; 251 252 int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp, 253 struct fib_result *res, int fib_flags); 254 int fib_table_insert(struct net *, struct fib_table *, struct fib_config *, 255 struct netlink_ext_ack *extack); 256 int fib_table_delete(struct net *, struct fib_table *, struct fib_config *, 257 struct netlink_ext_ack *extack); 258 int fib_table_dump(struct fib_table *table, struct sk_buff *skb, 259 struct netlink_callback *cb, struct fib_dump_filter *filter); 260 int fib_table_flush(struct net *net, struct fib_table *table, bool flush_all); 261 struct fib_table *fib_trie_unmerge(struct fib_table *main_tb); 262 void fib_table_flush_external(struct fib_table *table); 263 void fib_free_table(struct fib_table *tb); 264 265 #ifndef CONFIG_IP_MULTIPLE_TABLES 266 267 #define TABLE_LOCAL_INDEX (RT_TABLE_LOCAL & (FIB_TABLE_HASHSZ - 1)) 268 #define TABLE_MAIN_INDEX (RT_TABLE_MAIN & (FIB_TABLE_HASHSZ - 1)) 269 270 static inline struct fib_table *fib_get_table(struct net *net, u32 id) 271 { 272 struct hlist_node *tb_hlist; 273 struct hlist_head *ptr; 274 275 ptr = id == RT_TABLE_LOCAL ? 276 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] : 277 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]; 278 279 tb_hlist = rcu_dereference_rtnl(hlist_first_rcu(ptr)); 280 281 return hlist_entry(tb_hlist, struct fib_table, tb_hlist); 282 } 283 284 static inline struct fib_table *fib_new_table(struct net *net, u32 id) 285 { 286 return fib_get_table(net, id); 287 } 288 289 static inline int fib_lookup(struct net *net, const struct flowi4 *flp, 290 struct fib_result *res, unsigned int flags) 291 { 292 struct fib_table *tb; 293 int err = -ENETUNREACH; 294 295 rcu_read_lock(); 296 297 tb = fib_get_table(net, RT_TABLE_MAIN); 298 if (tb) 299 err = fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF); 300 301 if (err == -EAGAIN) 302 err = -ENETUNREACH; 303 304 rcu_read_unlock(); 305 306 return err; 307 } 308 309 static inline bool fib4_rule_default(const struct fib_rule *rule) 310 { 311 return true; 312 } 313 314 static inline int fib4_rules_dump(struct net *net, struct notifier_block *nb) 315 { 316 return 0; 317 } 318 319 static inline unsigned int fib4_rules_seq_read(struct net *net) 320 { 321 return 0; 322 } 323 324 static inline bool fib4_rules_early_flow_dissect(struct net *net, 325 struct sk_buff *skb, 326 struct flowi4 *fl4, 327 struct flow_keys *flkeys) 328 { 329 return false; 330 } 331 #else /* CONFIG_IP_MULTIPLE_TABLES */ 332 int __net_init fib4_rules_init(struct net *net); 333 void __net_exit fib4_rules_exit(struct net *net); 334 335 struct fib_table *fib_new_table(struct net *net, u32 id); 336 struct fib_table *fib_get_table(struct net *net, u32 id); 337 338 int __fib_lookup(struct net *net, struct flowi4 *flp, 339 struct fib_result *res, unsigned int flags); 340 341 static inline int fib_lookup(struct net *net, struct flowi4 *flp, 342 struct fib_result *res, unsigned int flags) 343 { 344 struct fib_table *tb; 345 int err = -ENETUNREACH; 346 347 flags |= FIB_LOOKUP_NOREF; 348 if (net->ipv4.fib_has_custom_rules) 349 return __fib_lookup(net, flp, res, flags); 350 351 rcu_read_lock(); 352 353 res->tclassid = 0; 354 355 tb = rcu_dereference_rtnl(net->ipv4.fib_main); 356 if (tb) 357 err = fib_table_lookup(tb, flp, res, flags); 358 359 if (!err) 360 goto out; 361 362 tb = rcu_dereference_rtnl(net->ipv4.fib_default); 363 if (tb) 364 err = fib_table_lookup(tb, flp, res, flags); 365 366 out: 367 if (err == -EAGAIN) 368 err = -ENETUNREACH; 369 370 rcu_read_unlock(); 371 372 return err; 373 } 374 375 bool fib4_rule_default(const struct fib_rule *rule); 376 int fib4_rules_dump(struct net *net, struct notifier_block *nb); 377 unsigned int fib4_rules_seq_read(struct net *net); 378 379 static inline bool fib4_rules_early_flow_dissect(struct net *net, 380 struct sk_buff *skb, 381 struct flowi4 *fl4, 382 struct flow_keys *flkeys) 383 { 384 unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP; 385 386 if (!net->ipv4.fib_rules_require_fldissect) 387 return false; 388 389 skb_flow_dissect_flow_keys(skb, flkeys, flag); 390 fl4->fl4_sport = flkeys->ports.src; 391 fl4->fl4_dport = flkeys->ports.dst; 392 fl4->flowi4_proto = flkeys->basic.ip_proto; 393 394 return true; 395 } 396 397 #endif /* CONFIG_IP_MULTIPLE_TABLES */ 398 399 /* Exported by fib_frontend.c */ 400 extern const struct nla_policy rtm_ipv4_policy[]; 401 void ip_fib_init(void); 402 int fib_gw_from_via(struct fib_config *cfg, struct nlattr *nla, 403 struct netlink_ext_ack *extack); 404 __be32 fib_compute_spec_dst(struct sk_buff *skb); 405 bool fib_info_nh_uses_dev(struct fib_info *fi, const struct net_device *dev); 406 int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst, 407 u8 tos, int oif, struct net_device *dev, 408 struct in_device *idev, u32 *itag); 409 #ifdef CONFIG_IP_ROUTE_CLASSID 410 static inline int fib_num_tclassid_users(struct net *net) 411 { 412 return net->ipv4.fib_num_tclassid_users; 413 } 414 #else 415 static inline int fib_num_tclassid_users(struct net *net) 416 { 417 return 0; 418 } 419 #endif 420 int fib_unmerge(struct net *net); 421 422 /* Exported by fib_semantics.c */ 423 int ip_fib_check_default(__be32 gw, struct net_device *dev); 424 int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force); 425 int fib_sync_down_addr(struct net_device *dev, __be32 local); 426 int fib_sync_up(struct net_device *dev, unsigned char nh_flags); 427 void fib_sync_mtu(struct net_device *dev, u32 orig_mtu); 428 429 #ifdef CONFIG_IP_ROUTE_MULTIPATH 430 int fib_multipath_hash(const struct net *net, const struct flowi4 *fl4, 431 const struct sk_buff *skb, struct flow_keys *flkeys); 432 #endif 433 void fib_select_multipath(struct fib_result *res, int hash); 434 void fib_select_path(struct net *net, struct fib_result *res, 435 struct flowi4 *fl4, const struct sk_buff *skb); 436 437 int fib_nh_init(struct net *net, struct fib_nh *fib_nh, 438 struct fib_config *cfg, int nh_weight, 439 struct netlink_ext_ack *extack); 440 void fib_nh_release(struct net *net, struct fib_nh *fib_nh); 441 int fib_nh_common_init(struct fib_nh_common *nhc, struct nlattr *fc_encap, 442 u16 fc_encap_type, void *cfg, gfp_t gfp_flags, 443 struct netlink_ext_ack *extack); 444 void fib_nh_common_release(struct fib_nh_common *nhc); 445 446 /* Exported by fib_trie.c */ 447 void fib_trie_init(void); 448 struct fib_table *fib_trie_table(u32 id, struct fib_table *alias); 449 450 static inline void fib_combine_itag(u32 *itag, const struct fib_result *res) 451 { 452 #ifdef CONFIG_IP_ROUTE_CLASSID 453 struct fib_nh_common *nhc = res->nhc; 454 struct fib_nh *nh = container_of(nhc, struct fib_nh, nh_common); 455 #ifdef CONFIG_IP_MULTIPLE_TABLES 456 u32 rtag; 457 #endif 458 *itag = nh->nh_tclassid << 16; 459 #ifdef CONFIG_IP_MULTIPLE_TABLES 460 rtag = res->tclassid; 461 if (*itag == 0) 462 *itag = (rtag<<16); 463 *itag |= (rtag>>16); 464 #endif 465 #endif 466 } 467 468 void free_fib_info(struct fib_info *fi); 469 470 static inline void fib_info_hold(struct fib_info *fi) 471 { 472 refcount_inc(&fi->fib_clntref); 473 } 474 475 static inline void fib_info_put(struct fib_info *fi) 476 { 477 if (refcount_dec_and_test(&fi->fib_clntref)) 478 free_fib_info(fi); 479 } 480 481 #ifdef CONFIG_PROC_FS 482 int __net_init fib_proc_init(struct net *net); 483 void __net_exit fib_proc_exit(struct net *net); 484 #else 485 static inline int fib_proc_init(struct net *net) 486 { 487 return 0; 488 } 489 static inline void fib_proc_exit(struct net *net) 490 { 491 } 492 #endif 493 494 u32 ip_mtu_from_fib_result(struct fib_result *res, __be32 daddr); 495 496 int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh, 497 struct fib_dump_filter *filter, 498 struct netlink_callback *cb); 499 500 int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nh, 501 unsigned char *flags, bool skip_oif); 502 int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nh, 503 int nh_weight); 504 #endif /* _NET_FIB_H */ 505