include/net/ip6_fib.h

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