| 1 | /* |
| 2 | * Linux INET6 implementation |
| 3 | * |
| 4 | * Authors: |
| 5 | * Pedro Roque <roque@di.fc.ul.pt> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU General Public License |
| 9 | * as published by the Free Software Foundation; either version |
| 10 | * 2 of the License, or (at your option) any later version. |
| 11 | */ |
| 12 | |
| 13 | #ifndef _IP6_FIB_H |
| 14 | #define _IP6_FIB_H |
| 15 | |
| 16 | #include <linux/ipv6_route.h> |
| 17 | #include <linux/rtnetlink.h> |
| 18 | #include <linux/spinlock.h> |
| 19 | #include <linux/notifier.h> |
| 20 | #include <net/dst.h> |
| 21 | #include <net/flow.h> |
| 22 | #include <net/ip_fib.h> |
| 23 | #include <net/netlink.h> |
| 24 | #include <net/inetpeer.h> |
| 25 | #include <net/fib_notifier.h> |
| 26 | |
| 27 | #ifdef CONFIG_IPV6_MULTIPLE_TABLES |
| 28 | #define FIB6_TABLE_HASHSZ 256 |
| 29 | #else |
| 30 | #define FIB6_TABLE_HASHSZ 1 |
| 31 | #endif |
| 32 | |
| 33 | #define RT6_DEBUG 2 |
| 34 | |
| 35 | #if RT6_DEBUG >= 3 |
| 36 | #define RT6_TRACE(x...) pr_debug(x) |
| 37 | #else |
| 38 | #define RT6_TRACE(x...) do { ; } while (0) |
| 39 | #endif |
| 40 | |
| 41 | struct rt6_info; |
| 42 | struct fib6_info; |
| 43 | |
| 44 | struct fib6_config { |
| 45 | u32 fc_table; |
| 46 | u32 fc_metric; |
| 47 | int fc_dst_len; |
| 48 | int fc_src_len; |
| 49 | int fc_ifindex; |
| 50 | u32 fc_flags; |
| 51 | u32 fc_protocol; |
| 52 | u16 fc_type; /* only 8 bits are used */ |
| 53 | u16 fc_delete_all_nh : 1, |
| 54 | fc_ignore_dev_down:1, |
| 55 | __unused : 14; |
| 56 | |
| 57 | struct in6_addr fc_dst; |
| 58 | struct in6_addr fc_src; |
| 59 | struct in6_addr fc_prefsrc; |
| 60 | struct in6_addr fc_gateway; |
| 61 | |
| 62 | unsigned long fc_expires; |
| 63 | struct nlattr *fc_mx; |
| 64 | int fc_mx_len; |
| 65 | int fc_mp_len; |
| 66 | struct nlattr *fc_mp; |
| 67 | |
| 68 | struct nl_info fc_nlinfo; |
| 69 | struct nlattr *fc_encap; |
| 70 | u16 fc_encap_type; |
| 71 | }; |
| 72 | |
| 73 | struct fib6_node { |
| 74 | struct fib6_node __rcu *parent; |
| 75 | struct fib6_node __rcu *left; |
| 76 | struct fib6_node __rcu *right; |
| 77 | #ifdef CONFIG_IPV6_SUBTREES |
| 78 | struct fib6_node __rcu *subtree; |
| 79 | #endif |
| 80 | struct fib6_info __rcu *leaf; |
| 81 | |
| 82 | __u16 fn_bit; /* bit key */ |
| 83 | __u16 fn_flags; |
| 84 | int fn_sernum; |
| 85 | struct fib6_info __rcu *rr_ptr; |
| 86 | struct rcu_head rcu; |
| 87 | }; |
| 88 | |
| 89 | struct fib6_gc_args { |
| 90 | int timeout; |
| 91 | int more; |
| 92 | }; |
| 93 | |
| 94 | #ifndef CONFIG_IPV6_SUBTREES |
| 95 | #define FIB6_SUBTREE(fn) NULL |
| 96 | #else |
| 97 | #define FIB6_SUBTREE(fn) (rcu_dereference_protected((fn)->subtree, 1)) |
| 98 | #endif |
| 99 | |
| 100 | /* |
| 101 | * routing information |
| 102 | * |
| 103 | */ |
| 104 | |
| 105 | struct rt6key { |
| 106 | struct in6_addr addr; |
| 107 | int plen; |
| 108 | }; |
| 109 | |
| 110 | struct fib6_table; |
| 111 | |
| 112 | struct rt6_exception_bucket { |
| 113 | struct hlist_head chain; |
| 114 | int depth; |
| 115 | }; |
| 116 | |
| 117 | struct rt6_exception { |
| 118 | struct hlist_node hlist; |
| 119 | struct rt6_info *rt6i; |
| 120 | unsigned long stamp; |
| 121 | struct rcu_head rcu; |
| 122 | }; |
| 123 | |
| 124 | #define FIB6_EXCEPTION_BUCKET_SIZE_SHIFT 10 |
| 125 | #define FIB6_EXCEPTION_BUCKET_SIZE (1 << FIB6_EXCEPTION_BUCKET_SIZE_SHIFT) |
| 126 | #define FIB6_MAX_DEPTH 5 |
| 127 | |
| 128 | struct fib6_nh { |
| 129 | struct fib_nh_common nh_common; |
| 130 | |
| 131 | #ifdef CONFIG_IPV6_ROUTER_PREF |
| 132 | unsigned long last_probe; |
| 133 | #endif |
| 134 | }; |
| 135 | |
| 136 | struct fib6_info { |
| 137 | struct fib6_table *fib6_table; |
| 138 | struct fib6_info __rcu *fib6_next; |
| 139 | struct fib6_node __rcu *fib6_node; |
| 140 | |
| 141 | /* Multipath routes: |
| 142 | * siblings is a list of fib6_info that have the the same metric/weight, |
| 143 | * destination, but not the same gateway. nsiblings is just a cache |
| 144 | * to speed up lookup. |
| 145 | */ |
| 146 | struct list_head fib6_siblings; |
| 147 | unsigned int fib6_nsiblings; |
| 148 | |
| 149 | refcount_t fib6_ref; |
| 150 | unsigned long expires; |
| 151 | struct dst_metrics *fib6_metrics; |
| 152 | #define fib6_pmtu fib6_metrics->metrics[RTAX_MTU-1] |
| 153 | |
| 154 | struct rt6key fib6_dst; |
| 155 | u32 fib6_flags; |
| 156 | struct rt6key fib6_src; |
| 157 | struct rt6key fib6_prefsrc; |
| 158 | |
| 159 | struct rt6_info * __percpu *rt6i_pcpu; |
| 160 | struct rt6_exception_bucket __rcu *rt6i_exception_bucket; |
| 161 | |
| 162 | u32 fib6_metric; |
| 163 | u8 fib6_protocol; |
| 164 | u8 fib6_type; |
| 165 | u8 exception_bucket_flushed:1, |
| 166 | should_flush:1, |
| 167 | dst_nocount:1, |
| 168 | dst_nopolicy:1, |
| 169 | dst_host:1, |
| 170 | fib6_destroying:1, |
| 171 | unused:2; |
| 172 | |
| 173 | struct fib6_nh fib6_nh; |
| 174 | struct rcu_head rcu; |
| 175 | }; |
| 176 | |
| 177 | struct rt6_info { |
| 178 | struct dst_entry dst; |
| 179 | struct fib6_info __rcu *from; |
| 180 | |
| 181 | struct rt6key rt6i_dst; |
| 182 | struct rt6key rt6i_src; |
| 183 | struct in6_addr rt6i_gateway; |
| 184 | struct inet6_dev *rt6i_idev; |
| 185 | u32 rt6i_flags; |
| 186 | |
| 187 | struct list_head rt6i_uncached; |
| 188 | struct uncached_list *rt6i_uncached_list; |
| 189 | |
| 190 | /* more non-fragment space at head required */ |
| 191 | unsigned short rt6i_nfheader_len; |
| 192 | }; |
| 193 | |
| 194 | struct fib6_result { |
| 195 | struct fib6_nh *nh; |
| 196 | struct fib6_info *f6i; |
| 197 | u32 fib6_flags; |
| 198 | u8 fib6_type; |
| 199 | struct rt6_info *rt6; |
| 200 | }; |
| 201 | |
| 202 | #define for_each_fib6_node_rt_rcu(fn) \ |
| 203 | for (rt = rcu_dereference((fn)->leaf); rt; \ |
| 204 | rt = rcu_dereference(rt->fib6_next)) |
| 205 | |
| 206 | #define for_each_fib6_walker_rt(w) \ |
| 207 | for (rt = (w)->leaf; rt; \ |
| 208 | rt = rcu_dereference_protected(rt->fib6_next, 1)) |
| 209 | |
| 210 | static inline struct inet6_dev *ip6_dst_idev(struct dst_entry *dst) |
| 211 | { |
| 212 | return ((struct rt6_info *)dst)->rt6i_idev; |
| 213 | } |
| 214 | |
| 215 | static inline void fib6_clean_expires(struct fib6_info *f6i) |
| 216 | { |
| 217 | f6i->fib6_flags &= ~RTF_EXPIRES; |
| 218 | f6i->expires = 0; |
| 219 | } |
| 220 | |
| 221 | static inline void fib6_set_expires(struct fib6_info *f6i, |
| 222 | unsigned long expires) |
| 223 | { |
| 224 | f6i->expires = expires; |
| 225 | f6i->fib6_flags |= RTF_EXPIRES; |
| 226 | } |
| 227 | |
| 228 | static inline bool fib6_check_expired(const struct fib6_info *f6i) |
| 229 | { |
| 230 | if (f6i->fib6_flags & RTF_EXPIRES) |
| 231 | return time_after(jiffies, f6i->expires); |
| 232 | return false; |
| 233 | } |
| 234 | |
| 235 | /* Function to safely get fn->sernum for passed in rt |
| 236 | * and store result in passed in cookie. |
| 237 | * Return true if we can get cookie safely |
| 238 | * Return false if not |
| 239 | */ |
| 240 | static inline bool fib6_get_cookie_safe(const struct fib6_info *f6i, |
| 241 | u32 *cookie) |
| 242 | { |
| 243 | struct fib6_node *fn; |
| 244 | bool status = false; |
| 245 | |
| 246 | fn = rcu_dereference(f6i->fib6_node); |
| 247 | |
| 248 | if (fn) { |
| 249 | *cookie = fn->fn_sernum; |
| 250 | /* pairs with smp_wmb() in fib6_update_sernum_upto_root() */ |
| 251 | smp_rmb(); |
| 252 | status = true; |
| 253 | } |
| 254 | |
| 255 | return status; |
| 256 | } |
| 257 | |
| 258 | static inline u32 rt6_get_cookie(const struct rt6_info *rt) |
| 259 | { |
| 260 | struct fib6_info *from; |
| 261 | u32 cookie = 0; |
| 262 | |
| 263 | rcu_read_lock(); |
| 264 | |
| 265 | from = rcu_dereference(rt->from); |
| 266 | if (from && (rt->rt6i_flags & RTF_PCPU || |
| 267 | unlikely(!list_empty(&rt->rt6i_uncached)))) |
| 268 | fib6_get_cookie_safe(from, &cookie); |
| 269 | |
| 270 | rcu_read_unlock(); |
| 271 | |
| 272 | return cookie; |
| 273 | } |
| 274 | |
| 275 | static inline void ip6_rt_put(struct rt6_info *rt) |
| 276 | { |
| 277 | /* dst_release() accepts a NULL parameter. |
| 278 | * We rely on dst being first structure in struct rt6_info |
| 279 | */ |
| 280 | BUILD_BUG_ON(offsetof(struct rt6_info, dst) != 0); |
| 281 | dst_release(&rt->dst); |
| 282 | } |
| 283 | |
| 284 | struct fib6_info *fib6_info_alloc(gfp_t gfp_flags); |
| 285 | void fib6_info_destroy_rcu(struct rcu_head *head); |
| 286 | |
| 287 | static inline void fib6_info_hold(struct fib6_info *f6i) |
| 288 | { |
| 289 | refcount_inc(&f6i->fib6_ref); |
| 290 | } |
| 291 | |
| 292 | static inline bool fib6_info_hold_safe(struct fib6_info *f6i) |
| 293 | { |
| 294 | return refcount_inc_not_zero(&f6i->fib6_ref); |
| 295 | } |
| 296 | |
| 297 | static inline void fib6_info_release(struct fib6_info *f6i) |
| 298 | { |
| 299 | if (f6i && refcount_dec_and_test(&f6i->fib6_ref)) |
| 300 | call_rcu(&f6i->rcu, fib6_info_destroy_rcu); |
| 301 | } |
| 302 | |
| 303 | enum fib6_walk_state { |
| 304 | #ifdef CONFIG_IPV6_SUBTREES |
| 305 | FWS_S, |
| 306 | #endif |
| 307 | FWS_L, |
| 308 | FWS_R, |
| 309 | FWS_C, |
| 310 | FWS_U |
| 311 | }; |
| 312 | |
| 313 | struct fib6_walker { |
| 314 | struct list_head lh; |
| 315 | struct fib6_node *root, *node; |
| 316 | struct fib6_info *leaf; |
| 317 | enum fib6_walk_state state; |
| 318 | unsigned int skip; |
| 319 | unsigned int count; |
| 320 | int (*func)(struct fib6_walker *); |
| 321 | void *args; |
| 322 | }; |
| 323 | |
| 324 | struct rt6_statistics { |
| 325 | __u32 fib_nodes; /* all fib6 nodes */ |
| 326 | __u32 fib_route_nodes; /* intermediate nodes */ |
| 327 | __u32 fib_rt_entries; /* rt entries in fib table */ |
| 328 | __u32 fib_rt_cache; /* cached rt entries in exception table */ |
| 329 | __u32 fib_discarded_routes; /* total number of routes delete */ |
| 330 | |
| 331 | /* The following stats are not protected by any lock */ |
| 332 | atomic_t fib_rt_alloc; /* total number of routes alloced */ |
| 333 | atomic_t fib_rt_uncache; /* rt entries in uncached list */ |
| 334 | }; |
| 335 | |
| 336 | #define RTN_TL_ROOT 0x0001 |
| 337 | #define RTN_ROOT 0x0002 /* tree root node */ |
| 338 | #define RTN_RTINFO 0x0004 /* node with valid routing info */ |
| 339 | |
| 340 | /* |
| 341 | * priority levels (or metrics) |
| 342 | * |
| 343 | */ |
| 344 | |
| 345 | |
| 346 | struct fib6_table { |
| 347 | struct hlist_node tb6_hlist; |
| 348 | u32 tb6_id; |
| 349 | spinlock_t tb6_lock; |
| 350 | struct fib6_node tb6_root; |
| 351 | struct inet_peer_base tb6_peers; |
| 352 | unsigned int flags; |
| 353 | unsigned int fib_seq; |
| 354 | #define RT6_TABLE_HAS_DFLT_ROUTER BIT(0) |
| 355 | }; |
| 356 | |
| 357 | #define RT6_TABLE_UNSPEC RT_TABLE_UNSPEC |
| 358 | #define RT6_TABLE_MAIN RT_TABLE_MAIN |
| 359 | #define RT6_TABLE_DFLT RT6_TABLE_MAIN |
| 360 | #define RT6_TABLE_INFO RT6_TABLE_MAIN |
| 361 | #define RT6_TABLE_PREFIX RT6_TABLE_MAIN |
| 362 | |
| 363 | #ifdef CONFIG_IPV6_MULTIPLE_TABLES |
| 364 | #define FIB6_TABLE_MIN 1 |
| 365 | #define FIB6_TABLE_MAX RT_TABLE_MAX |
| 366 | #define RT6_TABLE_LOCAL RT_TABLE_LOCAL |
| 367 | #else |
| 368 | #define FIB6_TABLE_MIN RT_TABLE_MAIN |
| 369 | #define FIB6_TABLE_MAX FIB6_TABLE_MIN |
| 370 | #define RT6_TABLE_LOCAL RT6_TABLE_MAIN |
| 371 | #endif |
| 372 | |
| 373 | typedef struct rt6_info *(*pol_lookup_t)(struct net *, |
| 374 | struct fib6_table *, |
| 375 | struct flowi6 *, |
| 376 | const struct sk_buff *, int); |
| 377 | |
| 378 | struct fib6_entry_notifier_info { |
| 379 | struct fib_notifier_info info; /* must be first */ |
| 380 | struct fib6_info *rt; |
| 381 | }; |
| 382 | |
| 383 | /* |
| 384 | * exported functions |
| 385 | */ |
| 386 | |
| 387 | struct fib6_table *fib6_get_table(struct net *net, u32 id); |
| 388 | struct fib6_table *fib6_new_table(struct net *net, u32 id); |
| 389 | struct dst_entry *fib6_rule_lookup(struct net *net, struct flowi6 *fl6, |
| 390 | const struct sk_buff *skb, |
| 391 | int flags, pol_lookup_t lookup); |
| 392 | |
| 393 | /* called with rcu lock held; can return error pointer |
| 394 | * caller needs to select path |
| 395 | */ |
| 396 | int fib6_lookup(struct net *net, int oif, struct flowi6 *fl6, |
| 397 | struct fib6_result *res, int flags); |
| 398 | |
| 399 | /* called with rcu lock held; caller needs to select path */ |
| 400 | int fib6_table_lookup(struct net *net, struct fib6_table *table, |
| 401 | int oif, struct flowi6 *fl6, struct fib6_result *res, |
| 402 | int strict); |
| 403 | |
| 404 | void fib6_select_path(const struct net *net, struct fib6_result *res, |
| 405 | struct flowi6 *fl6, int oif, bool have_oif_match, |
| 406 | const struct sk_buff *skb, int strict); |
| 407 | struct fib6_node *fib6_node_lookup(struct fib6_node *root, |
| 408 | const struct in6_addr *daddr, |
| 409 | const struct in6_addr *saddr); |
| 410 | |
| 411 | struct fib6_node *fib6_locate(struct fib6_node *root, |
| 412 | const struct in6_addr *daddr, int dst_len, |
| 413 | const struct in6_addr *saddr, int src_len, |
| 414 | bool exact_match); |
| 415 | |
| 416 | void fib6_clean_all(struct net *net, int (*func)(struct fib6_info *, void *arg), |
| 417 | void *arg); |
| 418 | void fib6_clean_all_skip_notify(struct net *net, |
| 419 | int (*func)(struct fib6_info *, void *arg), |
| 420 | void *arg); |
| 421 | |
| 422 | int fib6_add(struct fib6_node *root, struct fib6_info *rt, |
| 423 | struct nl_info *info, struct netlink_ext_ack *extack); |
| 424 | int fib6_del(struct fib6_info *rt, struct nl_info *info); |
| 425 | |
| 426 | static inline |
| 427 | void rt6_get_prefsrc(const struct rt6_info *rt, struct in6_addr *addr) |
| 428 | { |
| 429 | const struct fib6_info *from; |
| 430 | |
| 431 | rcu_read_lock(); |
| 432 | |
| 433 | from = rcu_dereference(rt->from); |
| 434 | if (from) { |
| 435 | *addr = from->fib6_prefsrc.addr; |
| 436 | } else { |
| 437 | struct in6_addr in6_zero = {}; |
| 438 | |
| 439 | *addr = in6_zero; |
| 440 | } |
| 441 | |
| 442 | rcu_read_unlock(); |
| 443 | } |
| 444 | |
| 445 | static inline struct net_device *fib6_info_nh_dev(const struct fib6_info *f6i) |
| 446 | { |
| 447 | return f6i->fib6_nh.fib_nh_dev; |
| 448 | } |
| 449 | |
| 450 | int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh, |
| 451 | struct fib6_config *cfg, gfp_t gfp_flags, |
| 452 | struct netlink_ext_ack *extack); |
| 453 | void fib6_nh_release(struct fib6_nh *fib6_nh); |
| 454 | |
| 455 | void inet6_rt_notify(int event, struct fib6_info *rt, struct nl_info *info, |
| 456 | unsigned int flags); |
| 457 | |
| 458 | void fib6_run_gc(unsigned long expires, struct net *net, bool force); |
| 459 | |
| 460 | void fib6_gc_cleanup(void); |
| 461 | |
| 462 | int fib6_init(void); |
| 463 | |
| 464 | struct ipv6_route_iter { |
| 465 | struct seq_net_private p; |
| 466 | struct fib6_walker w; |
| 467 | loff_t skip; |
| 468 | struct fib6_table *tbl; |
| 469 | int sernum; |
| 470 | }; |
| 471 | |
| 472 | extern const struct seq_operations ipv6_route_seq_ops; |
| 473 | |
| 474 | int call_fib6_notifier(struct notifier_block *nb, struct net *net, |
| 475 | enum fib_event_type event_type, |
| 476 | struct fib_notifier_info *info); |
| 477 | int call_fib6_notifiers(struct net *net, enum fib_event_type event_type, |
| 478 | struct fib_notifier_info *info); |
| 479 | |
| 480 | int __net_init fib6_notifier_init(struct net *net); |
| 481 | void __net_exit fib6_notifier_exit(struct net *net); |
| 482 | |
| 483 | unsigned int fib6_tables_seq_read(struct net *net); |
| 484 | int fib6_tables_dump(struct net *net, struct notifier_block *nb); |
| 485 | |
| 486 | void fib6_update_sernum(struct net *net, struct fib6_info *rt); |
| 487 | void fib6_update_sernum_upto_root(struct net *net, struct fib6_info *rt); |
| 488 | |
| 489 | void fib6_metric_set(struct fib6_info *f6i, int metric, u32 val); |
| 490 | static inline bool fib6_metric_locked(struct fib6_info *f6i, int metric) |
| 491 | { |
| 492 | return !!(f6i->fib6_metrics->metrics[RTAX_LOCK - 1] & (1 << metric)); |
| 493 | } |
| 494 | |
| 495 | #ifdef CONFIG_IPV6_MULTIPLE_TABLES |
| 496 | int fib6_rules_init(void); |
| 497 | void fib6_rules_cleanup(void); |
| 498 | bool fib6_rule_default(const struct fib_rule *rule); |
| 499 | int fib6_rules_dump(struct net *net, struct notifier_block *nb); |
| 500 | unsigned int fib6_rules_seq_read(struct net *net); |
| 501 | |
| 502 | static inline bool fib6_rules_early_flow_dissect(struct net *net, |
| 503 | struct sk_buff *skb, |
| 504 | struct flowi6 *fl6, |
| 505 | struct flow_keys *flkeys) |
| 506 | { |
| 507 | unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP; |
| 508 | |
| 509 | if (!net->ipv6.fib6_rules_require_fldissect) |
| 510 | return false; |
| 511 | |
| 512 | skb_flow_dissect_flow_keys(skb, flkeys, flag); |
| 513 | fl6->fl6_sport = flkeys->ports.src; |
| 514 | fl6->fl6_dport = flkeys->ports.dst; |
| 515 | fl6->flowi6_proto = flkeys->basic.ip_proto; |
| 516 | |
| 517 | return true; |
| 518 | } |
| 519 | #else |
| 520 | static inline int fib6_rules_init(void) |
| 521 | { |
| 522 | return 0; |
| 523 | } |
| 524 | static inline void fib6_rules_cleanup(void) |
| 525 | { |
| 526 | return ; |
| 527 | } |
| 528 | static inline bool fib6_rule_default(const struct fib_rule *rule) |
| 529 | { |
| 530 | return true; |
| 531 | } |
| 532 | static inline int fib6_rules_dump(struct net *net, struct notifier_block *nb) |
| 533 | { |
| 534 | return 0; |
| 535 | } |
| 536 | static inline unsigned int fib6_rules_seq_read(struct net *net) |
| 537 | { |
| 538 | return 0; |
| 539 | } |
| 540 | static inline bool fib6_rules_early_flow_dissect(struct net *net, |
| 541 | struct sk_buff *skb, |
| 542 | struct flowi6 *fl6, |
| 543 | struct flow_keys *flkeys) |
| 544 | { |
| 545 | return false; |
| 546 | } |
| 547 | #endif |
| 548 | #endif |