]> Git Repo - linux.git/blob - include/net/ip6_fib.h
libbpf: fix GCC8 warning for strncpy
[linux.git] / include / net / ip6_fib.h
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  *      Linux INET6 implementation 
4  *
5  *      Authors:
6  *      Pedro Roque             <[email protected]>     
7  */
8
9 #ifndef _IP6_FIB_H
10 #define _IP6_FIB_H
11
12 #include <linux/ipv6_route.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/spinlock.h>
15 #include <linux/notifier.h>
16 #include <net/dst.h>
17 #include <net/flow.h>
18 #include <net/ip_fib.h>
19 #include <net/netlink.h>
20 #include <net/inetpeer.h>
21 #include <net/fib_notifier.h>
22
23 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
24 #define FIB6_TABLE_HASHSZ 256
25 #else
26 #define FIB6_TABLE_HASHSZ 1
27 #endif
28
29 #define RT6_DEBUG 2
30
31 #if RT6_DEBUG >= 3
32 #define RT6_TRACE(x...) pr_debug(x)
33 #else
34 #define RT6_TRACE(x...) do { ; } while (0)
35 #endif
36
37 struct rt6_info;
38 struct fib6_info;
39
40 struct fib6_config {
41         u32             fc_table;
42         u32             fc_metric;
43         int             fc_dst_len;
44         int             fc_src_len;
45         int             fc_ifindex;
46         u32             fc_flags;
47         u32             fc_protocol;
48         u16             fc_type;        /* only 8 bits are used */
49         u16             fc_delete_all_nh : 1,
50                         fc_ignore_dev_down:1,
51                         __unused : 14;
52         u32             fc_nh_id;
53
54         struct in6_addr fc_dst;
55         struct in6_addr fc_src;
56         struct in6_addr fc_prefsrc;
57         struct in6_addr fc_gateway;
58
59         unsigned long   fc_expires;
60         struct nlattr   *fc_mx;
61         int             fc_mx_len;
62         int             fc_mp_len;
63         struct nlattr   *fc_mp;
64
65         struct nl_info  fc_nlinfo;
66         struct nlattr   *fc_encap;
67         u16             fc_encap_type;
68 };
69
70 struct fib6_node {
71         struct fib6_node __rcu  *parent;
72         struct fib6_node __rcu  *left;
73         struct fib6_node __rcu  *right;
74 #ifdef CONFIG_IPV6_SUBTREES
75         struct fib6_node __rcu  *subtree;
76 #endif
77         struct fib6_info __rcu  *leaf;
78
79         __u16                   fn_bit;         /* bit key */
80         __u16                   fn_flags;
81         int                     fn_sernum;
82         struct fib6_info __rcu  *rr_ptr;
83         struct rcu_head         rcu;
84 };
85
86 struct fib6_gc_args {
87         int                     timeout;
88         int                     more;
89 };
90
91 #ifndef CONFIG_IPV6_SUBTREES
92 #define FIB6_SUBTREE(fn)        NULL
93 #else
94 #define FIB6_SUBTREE(fn)        (rcu_dereference_protected((fn)->subtree, 1))
95 #endif
96
97 /*
98  *      routing information
99  *
100  */
101
102 struct rt6key {
103         struct in6_addr addr;
104         int             plen;
105 };
106
107 struct fib6_table;
108
109 struct rt6_exception_bucket {
110         struct hlist_head       chain;
111         int                     depth;
112 };
113
114 struct rt6_exception {
115         struct hlist_node       hlist;
116         struct rt6_info         *rt6i;
117         unsigned long           stamp;
118         struct rcu_head         rcu;
119 };
120
121 #define FIB6_EXCEPTION_BUCKET_SIZE_SHIFT 10
122 #define FIB6_EXCEPTION_BUCKET_SIZE (1 << FIB6_EXCEPTION_BUCKET_SIZE_SHIFT)
123 #define FIB6_MAX_DEPTH 5
124
125 struct fib6_nh {
126         struct fib_nh_common    nh_common;
127
128 #ifdef CONFIG_IPV6_ROUTER_PREF
129         unsigned long           last_probe;
130 #endif
131
132         struct rt6_info * __percpu *rt6i_pcpu;
133         struct rt6_exception_bucket __rcu *rt6i_exception_bucket;
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         union {
147                 struct list_head        fib6_siblings;
148                 struct list_head        nh_list;
149         };
150         unsigned int                    fib6_nsiblings;
151
152         refcount_t                      fib6_ref;
153         unsigned long                   expires;
154         struct dst_metrics              *fib6_metrics;
155 #define fib6_pmtu               fib6_metrics->metrics[RTAX_MTU-1]
156
157         struct rt6key                   fib6_dst;
158         u32                             fib6_flags;
159         struct rt6key                   fib6_src;
160         struct rt6key                   fib6_prefsrc;
161
162         u32                             fib6_metric;
163         u8                              fib6_protocol;
164         u8                              fib6_type;
165         u8                              should_flush:1,
166                                         dst_nocount:1,
167                                         dst_nopolicy:1,
168                                         dst_host:1,
169                                         fib6_destroying:1,
170                                         unused:3;
171
172         struct rcu_head                 rcu;
173         struct nexthop                  *nh;
174         struct fib6_nh                  fib6_nh[0];
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)
267                 fib6_get_cookie_safe(from, &cookie);
268
269         rcu_read_unlock();
270
271         return cookie;
272 }
273
274 static inline void ip6_rt_put(struct rt6_info *rt)
275 {
276         /* dst_release() accepts a NULL parameter.
277          * We rely on dst being first structure in struct rt6_info
278          */
279         BUILD_BUG_ON(offsetof(struct rt6_info, dst) != 0);
280         dst_release(&rt->dst);
281 }
282
283 struct fib6_info *fib6_info_alloc(gfp_t gfp_flags, bool with_fib6_nh);
284 void fib6_info_destroy_rcu(struct rcu_head *head);
285
286 static inline void fib6_info_hold(struct fib6_info *f6i)
287 {
288         refcount_inc(&f6i->fib6_ref);
289 }
290
291 static inline bool fib6_info_hold_safe(struct fib6_info *f6i)
292 {
293         return refcount_inc_not_zero(&f6i->fib6_ref);
294 }
295
296 static inline void fib6_info_release(struct fib6_info *f6i)
297 {
298         if (f6i && refcount_dec_and_test(&f6i->fib6_ref))
299                 call_rcu(&f6i->rcu, fib6_info_destroy_rcu);
300 }
301
302 enum fib6_walk_state {
303 #ifdef CONFIG_IPV6_SUBTREES
304         FWS_S,
305 #endif
306         FWS_L,
307         FWS_R,
308         FWS_C,
309         FWS_U
310 };
311
312 struct fib6_walker {
313         struct list_head lh;
314         struct fib6_node *root, *node;
315         struct fib6_info *leaf;
316         enum fib6_walk_state state;
317         unsigned int skip;
318         unsigned int count;
319         int (*func)(struct fib6_walker *);
320         void *args;
321 };
322
323 struct rt6_statistics {
324         __u32           fib_nodes;              /* all fib6 nodes */
325         __u32           fib_route_nodes;        /* intermediate nodes */
326         __u32           fib_rt_entries;         /* rt entries in fib table */
327         __u32           fib_rt_cache;           /* cached rt entries in exception table */
328         __u32           fib_discarded_routes;   /* total number of routes delete */
329
330         /* The following stats are not protected by any lock */
331         atomic_t        fib_rt_alloc;           /* total number of routes alloced */
332         atomic_t        fib_rt_uncache;         /* rt entries in uncached list */
333 };
334
335 #define RTN_TL_ROOT     0x0001
336 #define RTN_ROOT        0x0002          /* tree root node               */
337 #define RTN_RTINFO      0x0004          /* node with valid routing info */
338
339 /*
340  *      priority levels (or metrics)
341  *
342  */
343
344
345 struct fib6_table {
346         struct hlist_node       tb6_hlist;
347         u32                     tb6_id;
348         spinlock_t              tb6_lock;
349         struct fib6_node        tb6_root;
350         struct inet_peer_base   tb6_peers;
351         unsigned int            flags;
352         unsigned int            fib_seq;
353 #define RT6_TABLE_HAS_DFLT_ROUTER       BIT(0)
354 };
355
356 #define RT6_TABLE_UNSPEC        RT_TABLE_UNSPEC
357 #define RT6_TABLE_MAIN          RT_TABLE_MAIN
358 #define RT6_TABLE_DFLT          RT6_TABLE_MAIN
359 #define RT6_TABLE_INFO          RT6_TABLE_MAIN
360 #define RT6_TABLE_PREFIX        RT6_TABLE_MAIN
361
362 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
363 #define FIB6_TABLE_MIN          1
364 #define FIB6_TABLE_MAX          RT_TABLE_MAX
365 #define RT6_TABLE_LOCAL         RT_TABLE_LOCAL
366 #else
367 #define FIB6_TABLE_MIN          RT_TABLE_MAIN
368 #define FIB6_TABLE_MAX          FIB6_TABLE_MIN
369 #define RT6_TABLE_LOCAL         RT6_TABLE_MAIN
370 #endif
371
372 typedef struct rt6_info *(*pol_lookup_t)(struct net *,
373                                          struct fib6_table *,
374                                          struct flowi6 *,
375                                          const struct sk_buff *, int);
376
377 struct fib6_entry_notifier_info {
378         struct fib_notifier_info info; /* must be first */
379         struct fib6_info *rt;
380         unsigned int nsiblings;
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 int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh,
446                  struct fib6_config *cfg, gfp_t gfp_flags,
447                  struct netlink_ext_ack *extack);
448 void fib6_nh_release(struct fib6_nh *fib6_nh);
449
450 int call_fib6_entry_notifiers(struct net *net,
451                               enum fib_event_type event_type,
452                               struct fib6_info *rt,
453                               struct netlink_ext_ack *extack);
454 int call_fib6_multipath_entry_notifiers(struct net *net,
455                                         enum fib_event_type event_type,
456                                         struct fib6_info *rt,
457                                         unsigned int nsiblings,
458                                         struct netlink_ext_ack *extack);
459 void fib6_rt_update(struct net *net, struct fib6_info *rt,
460                     struct nl_info *info);
461 void inet6_rt_notify(int event, struct fib6_info *rt, struct nl_info *info,
462                      unsigned int flags);
463
464 void fib6_run_gc(unsigned long expires, struct net *net, bool force);
465
466 void fib6_gc_cleanup(void);
467
468 int fib6_init(void);
469
470 struct ipv6_route_iter {
471         struct seq_net_private p;
472         struct fib6_walker w;
473         loff_t skip;
474         struct fib6_table *tbl;
475         int sernum;
476 };
477
478 extern const struct seq_operations ipv6_route_seq_ops;
479
480 int call_fib6_notifier(struct notifier_block *nb, struct net *net,
481                        enum fib_event_type event_type,
482                        struct fib_notifier_info *info);
483 int call_fib6_notifiers(struct net *net, enum fib_event_type event_type,
484                         struct fib_notifier_info *info);
485
486 int __net_init fib6_notifier_init(struct net *net);
487 void __net_exit fib6_notifier_exit(struct net *net);
488
489 unsigned int fib6_tables_seq_read(struct net *net);
490 int fib6_tables_dump(struct net *net, struct notifier_block *nb);
491
492 void fib6_update_sernum(struct net *net, struct fib6_info *rt);
493 void fib6_update_sernum_upto_root(struct net *net, struct fib6_info *rt);
494 void fib6_update_sernum_stub(struct net *net, struct fib6_info *f6i);
495
496 void fib6_metric_set(struct fib6_info *f6i, int metric, u32 val);
497 static inline bool fib6_metric_locked(struct fib6_info *f6i, int metric)
498 {
499         return !!(f6i->fib6_metrics->metrics[RTAX_LOCK - 1] & (1 << metric));
500 }
501
502 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
503 int fib6_rules_init(void);
504 void fib6_rules_cleanup(void);
505 bool fib6_rule_default(const struct fib_rule *rule);
506 int fib6_rules_dump(struct net *net, struct notifier_block *nb);
507 unsigned int fib6_rules_seq_read(struct net *net);
508
509 static inline bool fib6_rules_early_flow_dissect(struct net *net,
510                                                  struct sk_buff *skb,
511                                                  struct flowi6 *fl6,
512                                                  struct flow_keys *flkeys)
513 {
514         unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
515
516         if (!net->ipv6.fib6_rules_require_fldissect)
517                 return false;
518
519         skb_flow_dissect_flow_keys(skb, flkeys, flag);
520         fl6->fl6_sport = flkeys->ports.src;
521         fl6->fl6_dport = flkeys->ports.dst;
522         fl6->flowi6_proto = flkeys->basic.ip_proto;
523
524         return true;
525 }
526 #else
527 static inline int               fib6_rules_init(void)
528 {
529         return 0;
530 }
531 static inline void              fib6_rules_cleanup(void)
532 {
533         return ;
534 }
535 static inline bool fib6_rule_default(const struct fib_rule *rule)
536 {
537         return true;
538 }
539 static inline int fib6_rules_dump(struct net *net, struct notifier_block *nb)
540 {
541         return 0;
542 }
543 static inline unsigned int fib6_rules_seq_read(struct net *net)
544 {
545         return 0;
546 }
547 static inline bool fib6_rules_early_flow_dissect(struct net *net,
548                                                  struct sk_buff *skb,
549                                                  struct flowi6 *fl6,
550                                                  struct flow_keys *flkeys)
551 {
552         return false;
553 }
554 #endif
555 #endif
This page took 0.060425 seconds and 4 git commands to generate.