1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Linux INET6 implementation
7 * Pedro Roque <roque@di.fc.ul.pt>
12 * YOSHIFUJI Hideaki @USAGI
13 * reworked default router selection.
14 * - respect outgoing interface
15 * - select from (probably) reachable routers (i.e.
16 * routers in REACHABLE, STALE, DELAY or PROBE states).
17 * - always select the same router if it is (probably)
18 * reachable. otherwise, round-robin the list.
20 * Fixed routing subtrees.
23 #define pr_fmt(fmt) "IPv6: " fmt
25 #include <linux/capability.h>
26 #include <linux/errno.h>
27 #include <linux/export.h>
28 #include <linux/types.h>
29 #include <linux/times.h>
30 #include <linux/socket.h>
31 #include <linux/sockios.h>
32 #include <linux/net.h>
33 #include <linux/route.h>
34 #include <linux/netdevice.h>
35 #include <linux/in6.h>
36 #include <linux/mroute6.h>
37 #include <linux/init.h>
38 #include <linux/if_arp.h>
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
41 #include <linux/nsproxy.h>
42 #include <linux/slab.h>
43 #include <linux/jhash.h>
44 #include <linux/siphash.h>
45 #include <net/net_namespace.h>
48 #include <net/ip6_fib.h>
49 #include <net/ip6_route.h>
50 #include <net/ndisc.h>
51 #include <net/addrconf.h>
53 #include <linux/rtnetlink.h>
55 #include <net/dst_metadata.h>
57 #include <net/netevent.h>
58 #include <net/netlink.h>
60 #include <net/lwtunnel.h>
61 #include <net/ip_tunnels.h>
62 #include <net/l3mdev.h>
64 #include <linux/uaccess.h>
65 #include <linux/btf_ids.h>
68 #include <linux/sysctl.h>
71 static int ip6_rt_type_to_error(u8 fib6_type
);
73 #define CREATE_TRACE_POINTS
74 #include <trace/events/fib6.h>
75 EXPORT_TRACEPOINT_SYMBOL_GPL(fib6_table_lookup
);
76 #undef CREATE_TRACE_POINTS
79 RT6_NUD_FAIL_HARD
= -3,
80 RT6_NUD_FAIL_PROBE
= -2,
81 RT6_NUD_FAIL_DO_RR
= -1,
85 INDIRECT_CALLABLE_SCOPE
86 struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
, u32 cookie
);
87 static unsigned int ip6_default_advmss(const struct dst_entry
*dst
);
88 INDIRECT_CALLABLE_SCOPE
89 unsigned int ip6_mtu(const struct dst_entry
*dst
);
90 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*);
91 static void ip6_dst_destroy(struct dst_entry
*);
92 static void ip6_dst_ifdown(struct dst_entry
*,
93 struct net_device
*dev
, int how
);
94 static int ip6_dst_gc(struct dst_ops
*ops
);
96 static int ip6_pkt_discard(struct sk_buff
*skb
);
97 static int ip6_pkt_discard_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
);
98 static int ip6_pkt_prohibit(struct sk_buff
*skb
);
99 static int ip6_pkt_prohibit_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
);
100 static void ip6_link_failure(struct sk_buff
*skb
);
101 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
102 struct sk_buff
*skb
, u32 mtu
,
104 static void rt6_do_redirect(struct dst_entry
*dst
, struct sock
*sk
,
105 struct sk_buff
*skb
);
106 static int rt6_score_route(const struct fib6_nh
*nh
, u32 fib6_flags
, int oif
,
108 static size_t rt6_nlmsg_size(struct fib6_info
*f6i
);
109 static int rt6_fill_node(struct net
*net
, struct sk_buff
*skb
,
110 struct fib6_info
*rt
, struct dst_entry
*dst
,
111 struct in6_addr
*dest
, struct in6_addr
*src
,
112 int iif
, int type
, u32 portid
, u32 seq
,
114 static struct rt6_info
*rt6_find_cached_rt(const struct fib6_result
*res
,
115 const struct in6_addr
*daddr
,
116 const struct in6_addr
*saddr
);
118 #ifdef CONFIG_IPV6_ROUTE_INFO
119 static struct fib6_info
*rt6_add_route_info(struct net
*net
,
120 const struct in6_addr
*prefix
, int prefixlen
,
121 const struct in6_addr
*gwaddr
,
122 struct net_device
*dev
,
124 static struct fib6_info
*rt6_get_route_info(struct net
*net
,
125 const struct in6_addr
*prefix
, int prefixlen
,
126 const struct in6_addr
*gwaddr
,
127 struct net_device
*dev
);
130 struct uncached_list
{
132 struct list_head head
;
135 static DEFINE_PER_CPU_ALIGNED(struct uncached_list
, rt6_uncached_list
);
137 void rt6_uncached_list_add(struct rt6_info
*rt
)
139 struct uncached_list
*ul
= raw_cpu_ptr(&rt6_uncached_list
);
141 rt
->rt6i_uncached_list
= ul
;
143 spin_lock_bh(&ul
->lock
);
144 list_add_tail(&rt
->rt6i_uncached
, &ul
->head
);
145 spin_unlock_bh(&ul
->lock
);
148 void rt6_uncached_list_del(struct rt6_info
*rt
)
150 if (!list_empty(&rt
->rt6i_uncached
)) {
151 struct uncached_list
*ul
= rt
->rt6i_uncached_list
;
152 struct net
*net
= dev_net(rt
->dst
.dev
);
154 spin_lock_bh(&ul
->lock
);
155 list_del(&rt
->rt6i_uncached
);
156 atomic_dec(&net
->ipv6
.rt6_stats
->fib_rt_uncache
);
157 spin_unlock_bh(&ul
->lock
);
161 static void rt6_uncached_list_flush_dev(struct net
*net
, struct net_device
*dev
)
163 struct net_device
*loopback_dev
= net
->loopback_dev
;
166 if (dev
== loopback_dev
)
169 for_each_possible_cpu(cpu
) {
170 struct uncached_list
*ul
= per_cpu_ptr(&rt6_uncached_list
, cpu
);
173 spin_lock_bh(&ul
->lock
);
174 list_for_each_entry(rt
, &ul
->head
, rt6i_uncached
) {
175 struct inet6_dev
*rt_idev
= rt
->rt6i_idev
;
176 struct net_device
*rt_dev
= rt
->dst
.dev
;
178 if (rt_idev
->dev
== dev
) {
179 rt
->rt6i_idev
= in6_dev_get(loopback_dev
);
180 in6_dev_put(rt_idev
);
184 rt
->dst
.dev
= blackhole_netdev
;
185 dev_hold(rt
->dst
.dev
);
189 spin_unlock_bh(&ul
->lock
);
193 static inline const void *choose_neigh_daddr(const struct in6_addr
*p
,
197 if (!ipv6_addr_any(p
))
198 return (const void *) p
;
200 return &ipv6_hdr(skb
)->daddr
;
204 struct neighbour
*ip6_neigh_lookup(const struct in6_addr
*gw
,
205 struct net_device
*dev
,
211 daddr
= choose_neigh_daddr(gw
, skb
, daddr
);
212 n
= __ipv6_neigh_lookup(dev
, daddr
);
216 n
= neigh_create(&nd_tbl
, daddr
, dev
);
217 return IS_ERR(n
) ? NULL
: n
;
220 static struct neighbour
*ip6_dst_neigh_lookup(const struct dst_entry
*dst
,
224 const struct rt6_info
*rt
= container_of(dst
, struct rt6_info
, dst
);
226 return ip6_neigh_lookup(rt6_nexthop(rt
, &in6addr_any
),
227 dst
->dev
, skb
, daddr
);
230 static void ip6_confirm_neigh(const struct dst_entry
*dst
, const void *daddr
)
232 struct net_device
*dev
= dst
->dev
;
233 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
235 daddr
= choose_neigh_daddr(rt6_nexthop(rt
, &in6addr_any
), NULL
, daddr
);
238 if (dev
->flags
& (IFF_NOARP
| IFF_LOOPBACK
))
240 if (ipv6_addr_is_multicast((const struct in6_addr
*)daddr
))
242 __ipv6_confirm_neigh(dev
, daddr
);
245 static struct dst_ops ip6_dst_ops_template
= {
249 .check
= ip6_dst_check
,
250 .default_advmss
= ip6_default_advmss
,
252 .cow_metrics
= dst_cow_metrics_generic
,
253 .destroy
= ip6_dst_destroy
,
254 .ifdown
= ip6_dst_ifdown
,
255 .negative_advice
= ip6_negative_advice
,
256 .link_failure
= ip6_link_failure
,
257 .update_pmtu
= ip6_rt_update_pmtu
,
258 .redirect
= rt6_do_redirect
,
259 .local_out
= __ip6_local_out
,
260 .neigh_lookup
= ip6_dst_neigh_lookup
,
261 .confirm_neigh
= ip6_confirm_neigh
,
264 static struct dst_ops ip6_dst_blackhole_ops
= {
266 .default_advmss
= ip6_default_advmss
,
267 .neigh_lookup
= ip6_dst_neigh_lookup
,
268 .check
= ip6_dst_check
,
269 .destroy
= ip6_dst_destroy
,
270 .cow_metrics
= dst_cow_metrics_generic
,
271 .update_pmtu
= dst_blackhole_update_pmtu
,
272 .redirect
= dst_blackhole_redirect
,
273 .mtu
= dst_blackhole_mtu
,
276 static const u32 ip6_template_metrics
[RTAX_MAX
] = {
277 [RTAX_HOPLIMIT
- 1] = 0,
280 static const struct fib6_info fib6_null_entry_template
= {
281 .fib6_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
282 .fib6_protocol
= RTPROT_KERNEL
,
283 .fib6_metric
= ~(u32
)0,
284 .fib6_ref
= REFCOUNT_INIT(1),
285 .fib6_type
= RTN_UNREACHABLE
,
286 .fib6_metrics
= (struct dst_metrics
*)&dst_default_metrics
,
289 static const struct rt6_info ip6_null_entry_template
= {
291 .__refcnt
= ATOMIC_INIT(1),
293 .obsolete
= DST_OBSOLETE_FORCE_CHK
,
294 .error
= -ENETUNREACH
,
295 .input
= ip6_pkt_discard
,
296 .output
= ip6_pkt_discard_out
,
298 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
301 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
303 static const struct rt6_info ip6_prohibit_entry_template
= {
305 .__refcnt
= ATOMIC_INIT(1),
307 .obsolete
= DST_OBSOLETE_FORCE_CHK
,
309 .input
= ip6_pkt_prohibit
,
310 .output
= ip6_pkt_prohibit_out
,
312 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
315 static const struct rt6_info ip6_blk_hole_entry_template
= {
317 .__refcnt
= ATOMIC_INIT(1),
319 .obsolete
= DST_OBSOLETE_FORCE_CHK
,
321 .input
= dst_discard
,
322 .output
= dst_discard_out
,
324 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
329 static void rt6_info_init(struct rt6_info
*rt
)
331 struct dst_entry
*dst
= &rt
->dst
;
333 memset(dst
+ 1, 0, sizeof(*rt
) - sizeof(*dst
));
334 INIT_LIST_HEAD(&rt
->rt6i_uncached
);
337 /* allocate dst with ip6_dst_ops */
338 struct rt6_info
*ip6_dst_alloc(struct net
*net
, struct net_device
*dev
,
341 struct rt6_info
*rt
= dst_alloc(&net
->ipv6
.ip6_dst_ops
, dev
,
342 1, DST_OBSOLETE_FORCE_CHK
, flags
);
346 atomic_inc(&net
->ipv6
.rt6_stats
->fib_rt_alloc
);
351 EXPORT_SYMBOL(ip6_dst_alloc
);
353 static void ip6_dst_destroy(struct dst_entry
*dst
)
355 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
356 struct fib6_info
*from
;
357 struct inet6_dev
*idev
;
359 ip_dst_metrics_put(dst
);
360 rt6_uncached_list_del(rt
);
362 idev
= rt
->rt6i_idev
;
364 rt
->rt6i_idev
= NULL
;
368 from
= xchg((__force
struct fib6_info
**)&rt
->from
, NULL
);
369 fib6_info_release(from
);
372 static void ip6_dst_ifdown(struct dst_entry
*dst
, struct net_device
*dev
,
375 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
376 struct inet6_dev
*idev
= rt
->rt6i_idev
;
377 struct net_device
*loopback_dev
=
378 dev_net(dev
)->loopback_dev
;
380 if (idev
&& idev
->dev
!= loopback_dev
) {
381 struct inet6_dev
*loopback_idev
= in6_dev_get(loopback_dev
);
383 rt
->rt6i_idev
= loopback_idev
;
389 static bool __rt6_check_expired(const struct rt6_info
*rt
)
391 if (rt
->rt6i_flags
& RTF_EXPIRES
)
392 return time_after(jiffies
, rt
->dst
.expires
);
397 static bool rt6_check_expired(const struct rt6_info
*rt
)
399 struct fib6_info
*from
;
401 from
= rcu_dereference(rt
->from
);
403 if (rt
->rt6i_flags
& RTF_EXPIRES
) {
404 if (time_after(jiffies
, rt
->dst
.expires
))
407 return rt
->dst
.obsolete
!= DST_OBSOLETE_FORCE_CHK
||
408 fib6_check_expired(from
);
413 void fib6_select_path(const struct net
*net
, struct fib6_result
*res
,
414 struct flowi6
*fl6
, int oif
, bool have_oif_match
,
415 const struct sk_buff
*skb
, int strict
)
417 struct fib6_info
*sibling
, *next_sibling
;
418 struct fib6_info
*match
= res
->f6i
;
420 if (!match
->nh
&& (!match
->fib6_nsiblings
|| have_oif_match
))
423 if (match
->nh
&& have_oif_match
&& res
->nh
)
426 /* We might have already computed the hash for ICMPv6 errors. In such
427 * case it will always be non-zero. Otherwise now is the time to do it.
430 (!match
->nh
|| nexthop_is_multipath(match
->nh
)))
431 fl6
->mp_hash
= rt6_multipath_hash(net
, fl6
, skb
, NULL
);
433 if (unlikely(match
->nh
)) {
434 nexthop_path_fib6_result(res
, fl6
->mp_hash
);
438 if (fl6
->mp_hash
<= atomic_read(&match
->fib6_nh
->fib_nh_upper_bound
))
441 list_for_each_entry_safe(sibling
, next_sibling
, &match
->fib6_siblings
,
443 const struct fib6_nh
*nh
= sibling
->fib6_nh
;
446 nh_upper_bound
= atomic_read(&nh
->fib_nh_upper_bound
);
447 if (fl6
->mp_hash
> nh_upper_bound
)
449 if (rt6_score_route(nh
, sibling
->fib6_flags
, oif
, strict
) < 0)
457 res
->nh
= match
->fib6_nh
;
461 * Route lookup. rcu_read_lock() should be held.
464 static bool __rt6_device_match(struct net
*net
, const struct fib6_nh
*nh
,
465 const struct in6_addr
*saddr
, int oif
, int flags
)
467 const struct net_device
*dev
;
469 if (nh
->fib_nh_flags
& RTNH_F_DEAD
)
472 dev
= nh
->fib_nh_dev
;
474 if (dev
->ifindex
== oif
)
477 if (ipv6_chk_addr(net
, saddr
, dev
,
478 flags
& RT6_LOOKUP_F_IFACE
))
485 struct fib6_nh_dm_arg
{
487 const struct in6_addr
*saddr
;
493 static int __rt6_nh_dev_match(struct fib6_nh
*nh
, void *_arg
)
495 struct fib6_nh_dm_arg
*arg
= _arg
;
498 return __rt6_device_match(arg
->net
, nh
, arg
->saddr
, arg
->oif
,
502 /* returns fib6_nh from nexthop or NULL */
503 static struct fib6_nh
*rt6_nh_dev_match(struct net
*net
, struct nexthop
*nh
,
504 struct fib6_result
*res
,
505 const struct in6_addr
*saddr
,
508 struct fib6_nh_dm_arg arg
= {
515 if (nexthop_is_blackhole(nh
))
518 if (nexthop_for_each_fib6_nh(nh
, __rt6_nh_dev_match
, &arg
))
524 static void rt6_device_match(struct net
*net
, struct fib6_result
*res
,
525 const struct in6_addr
*saddr
, int oif
, int flags
)
527 struct fib6_info
*f6i
= res
->f6i
;
528 struct fib6_info
*spf6i
;
531 if (!oif
&& ipv6_addr_any(saddr
)) {
532 if (unlikely(f6i
->nh
)) {
533 nh
= nexthop_fib6_nh(f6i
->nh
);
534 if (nexthop_is_blackhole(f6i
->nh
))
539 if (!(nh
->fib_nh_flags
& RTNH_F_DEAD
))
543 for (spf6i
= f6i
; spf6i
; spf6i
= rcu_dereference(spf6i
->fib6_next
)) {
544 bool matched
= false;
546 if (unlikely(spf6i
->nh
)) {
547 nh
= rt6_nh_dev_match(net
, spf6i
->nh
, res
, saddr
,
553 if (__rt6_device_match(net
, nh
, saddr
, oif
, flags
))
562 if (oif
&& flags
& RT6_LOOKUP_F_IFACE
) {
563 res
->f6i
= net
->ipv6
.fib6_null_entry
;
564 nh
= res
->f6i
->fib6_nh
;
568 if (unlikely(f6i
->nh
)) {
569 nh
= nexthop_fib6_nh(f6i
->nh
);
570 if (nexthop_is_blackhole(f6i
->nh
))
576 if (nh
->fib_nh_flags
& RTNH_F_DEAD
) {
577 res
->f6i
= net
->ipv6
.fib6_null_entry
;
578 nh
= res
->f6i
->fib6_nh
;
582 res
->fib6_type
= res
->f6i
->fib6_type
;
583 res
->fib6_flags
= res
->f6i
->fib6_flags
;
587 res
->fib6_flags
|= RTF_REJECT
;
588 res
->fib6_type
= RTN_BLACKHOLE
;
592 #ifdef CONFIG_IPV6_ROUTER_PREF
593 struct __rt6_probe_work
{
594 struct work_struct work
;
595 struct in6_addr target
;
596 struct net_device
*dev
;
599 static void rt6_probe_deferred(struct work_struct
*w
)
601 struct in6_addr mcaddr
;
602 struct __rt6_probe_work
*work
=
603 container_of(w
, struct __rt6_probe_work
, work
);
605 addrconf_addr_solict_mult(&work
->target
, &mcaddr
);
606 ndisc_send_ns(work
->dev
, &work
->target
, &mcaddr
, NULL
, 0);
611 static void rt6_probe(struct fib6_nh
*fib6_nh
)
613 struct __rt6_probe_work
*work
= NULL
;
614 const struct in6_addr
*nh_gw
;
615 unsigned long last_probe
;
616 struct neighbour
*neigh
;
617 struct net_device
*dev
;
618 struct inet6_dev
*idev
;
621 * Okay, this does not seem to be appropriate
622 * for now, however, we need to check if it
623 * is really so; aka Router Reachability Probing.
625 * Router Reachability Probe MUST be rate-limited
626 * to no more than one per minute.
628 if (!fib6_nh
->fib_nh_gw_family
)
631 nh_gw
= &fib6_nh
->fib_nh_gw6
;
632 dev
= fib6_nh
->fib_nh_dev
;
634 last_probe
= READ_ONCE(fib6_nh
->last_probe
);
635 idev
= __in6_dev_get(dev
);
636 neigh
= __ipv6_neigh_lookup_noref(dev
, nh_gw
);
638 if (neigh
->nud_state
& NUD_VALID
)
641 write_lock(&neigh
->lock
);
642 if (!(neigh
->nud_state
& NUD_VALID
) &&
644 neigh
->updated
+ idev
->cnf
.rtr_probe_interval
)) {
645 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
647 __neigh_set_probe_once(neigh
);
649 write_unlock(&neigh
->lock
);
650 } else if (time_after(jiffies
, last_probe
+
651 idev
->cnf
.rtr_probe_interval
)) {
652 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
655 if (!work
|| cmpxchg(&fib6_nh
->last_probe
,
656 last_probe
, jiffies
) != last_probe
) {
659 INIT_WORK(&work
->work
, rt6_probe_deferred
);
660 work
->target
= *nh_gw
;
663 schedule_work(&work
->work
);
667 rcu_read_unlock_bh();
670 static inline void rt6_probe(struct fib6_nh
*fib6_nh
)
676 * Default Router Selection (RFC 2461 6.3.6)
678 static enum rt6_nud_state
rt6_check_neigh(const struct fib6_nh
*fib6_nh
)
680 enum rt6_nud_state ret
= RT6_NUD_FAIL_HARD
;
681 struct neighbour
*neigh
;
684 neigh
= __ipv6_neigh_lookup_noref(fib6_nh
->fib_nh_dev
,
685 &fib6_nh
->fib_nh_gw6
);
687 read_lock(&neigh
->lock
);
688 if (neigh
->nud_state
& NUD_VALID
)
689 ret
= RT6_NUD_SUCCEED
;
690 #ifdef CONFIG_IPV6_ROUTER_PREF
691 else if (!(neigh
->nud_state
& NUD_FAILED
))
692 ret
= RT6_NUD_SUCCEED
;
694 ret
= RT6_NUD_FAIL_PROBE
;
696 read_unlock(&neigh
->lock
);
698 ret
= IS_ENABLED(CONFIG_IPV6_ROUTER_PREF
) ?
699 RT6_NUD_SUCCEED
: RT6_NUD_FAIL_DO_RR
;
701 rcu_read_unlock_bh();
706 static int rt6_score_route(const struct fib6_nh
*nh
, u32 fib6_flags
, int oif
,
711 if (!oif
|| nh
->fib_nh_dev
->ifindex
== oif
)
714 if (!m
&& (strict
& RT6_LOOKUP_F_IFACE
))
715 return RT6_NUD_FAIL_HARD
;
716 #ifdef CONFIG_IPV6_ROUTER_PREF
717 m
|= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(fib6_flags
)) << 2;
719 if ((strict
& RT6_LOOKUP_F_REACHABLE
) &&
720 !(fib6_flags
& RTF_NONEXTHOP
) && nh
->fib_nh_gw_family
) {
721 int n
= rt6_check_neigh(nh
);
728 static bool find_match(struct fib6_nh
*nh
, u32 fib6_flags
,
729 int oif
, int strict
, int *mpri
, bool *do_rr
)
731 bool match_do_rr
= false;
735 if (nh
->fib_nh_flags
& RTNH_F_DEAD
)
738 if (ip6_ignore_linkdown(nh
->fib_nh_dev
) &&
739 nh
->fib_nh_flags
& RTNH_F_LINKDOWN
&&
740 !(strict
& RT6_LOOKUP_F_IGNORE_LINKSTATE
))
743 m
= rt6_score_route(nh
, fib6_flags
, oif
, strict
);
744 if (m
== RT6_NUD_FAIL_DO_RR
) {
746 m
= 0; /* lowest valid score */
747 } else if (m
== RT6_NUD_FAIL_HARD
) {
751 if (strict
& RT6_LOOKUP_F_REACHABLE
)
754 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
756 *do_rr
= match_do_rr
;
764 struct fib6_nh_frl_arg
{
773 static int rt6_nh_find_match(struct fib6_nh
*nh
, void *_arg
)
775 struct fib6_nh_frl_arg
*arg
= _arg
;
778 return find_match(nh
, arg
->flags
, arg
->oif
, arg
->strict
,
779 arg
->mpri
, arg
->do_rr
);
782 static void __find_rr_leaf(struct fib6_info
*f6i_start
,
783 struct fib6_info
*nomatch
, u32 metric
,
784 struct fib6_result
*res
, struct fib6_info
**cont
,
785 int oif
, int strict
, bool *do_rr
, int *mpri
)
787 struct fib6_info
*f6i
;
789 for (f6i
= f6i_start
;
790 f6i
&& f6i
!= nomatch
;
791 f6i
= rcu_dereference(f6i
->fib6_next
)) {
792 bool matched
= false;
795 if (cont
&& f6i
->fib6_metric
!= metric
) {
800 if (fib6_check_expired(f6i
))
803 if (unlikely(f6i
->nh
)) {
804 struct fib6_nh_frl_arg arg
= {
805 .flags
= f6i
->fib6_flags
,
812 if (nexthop_is_blackhole(f6i
->nh
)) {
813 res
->fib6_flags
= RTF_REJECT
;
814 res
->fib6_type
= RTN_BLACKHOLE
;
816 res
->nh
= nexthop_fib6_nh(f6i
->nh
);
819 if (nexthop_for_each_fib6_nh(f6i
->nh
, rt6_nh_find_match
,
826 if (find_match(nh
, f6i
->fib6_flags
, oif
, strict
,
833 res
->fib6_flags
= f6i
->fib6_flags
;
834 res
->fib6_type
= f6i
->fib6_type
;
839 static void find_rr_leaf(struct fib6_node
*fn
, struct fib6_info
*leaf
,
840 struct fib6_info
*rr_head
, int oif
, int strict
,
841 bool *do_rr
, struct fib6_result
*res
)
843 u32 metric
= rr_head
->fib6_metric
;
844 struct fib6_info
*cont
= NULL
;
847 __find_rr_leaf(rr_head
, NULL
, metric
, res
, &cont
,
848 oif
, strict
, do_rr
, &mpri
);
850 __find_rr_leaf(leaf
, rr_head
, metric
, res
, &cont
,
851 oif
, strict
, do_rr
, &mpri
);
853 if (res
->f6i
|| !cont
)
856 __find_rr_leaf(cont
, NULL
, metric
, res
, NULL
,
857 oif
, strict
, do_rr
, &mpri
);
860 static void rt6_select(struct net
*net
, struct fib6_node
*fn
, int oif
,
861 struct fib6_result
*res
, int strict
)
863 struct fib6_info
*leaf
= rcu_dereference(fn
->leaf
);
864 struct fib6_info
*rt0
;
868 /* make sure this function or its helpers sets f6i */
871 if (!leaf
|| leaf
== net
->ipv6
.fib6_null_entry
)
874 rt0
= rcu_dereference(fn
->rr_ptr
);
878 /* Double check to make sure fn is not an intermediate node
879 * and fn->leaf does not points to its child's leaf
880 * (This might happen if all routes under fn are deleted from
881 * the tree and fib6_repair_tree() is called on the node.)
883 key_plen
= rt0
->fib6_dst
.plen
;
884 #ifdef CONFIG_IPV6_SUBTREES
885 if (rt0
->fib6_src
.plen
)
886 key_plen
= rt0
->fib6_src
.plen
;
888 if (fn
->fn_bit
!= key_plen
)
891 find_rr_leaf(fn
, leaf
, rt0
, oif
, strict
, &do_rr
, res
);
893 struct fib6_info
*next
= rcu_dereference(rt0
->fib6_next
);
895 /* no entries matched; do round-robin */
896 if (!next
|| next
->fib6_metric
!= rt0
->fib6_metric
)
900 spin_lock_bh(&leaf
->fib6_table
->tb6_lock
);
901 /* make sure next is not being deleted from the tree */
903 rcu_assign_pointer(fn
->rr_ptr
, next
);
904 spin_unlock_bh(&leaf
->fib6_table
->tb6_lock
);
910 res
->f6i
= net
->ipv6
.fib6_null_entry
;
911 res
->nh
= res
->f6i
->fib6_nh
;
912 res
->fib6_flags
= res
->f6i
->fib6_flags
;
913 res
->fib6_type
= res
->f6i
->fib6_type
;
917 static bool rt6_is_gw_or_nonexthop(const struct fib6_result
*res
)
919 return (res
->f6i
->fib6_flags
& RTF_NONEXTHOP
) ||
920 res
->nh
->fib_nh_gw_family
;
923 #ifdef CONFIG_IPV6_ROUTE_INFO
924 int rt6_route_rcv(struct net_device
*dev
, u8
*opt
, int len
,
925 const struct in6_addr
*gwaddr
)
927 struct net
*net
= dev_net(dev
);
928 struct route_info
*rinfo
= (struct route_info
*) opt
;
929 struct in6_addr prefix_buf
, *prefix
;
931 unsigned long lifetime
;
932 struct fib6_info
*rt
;
934 if (len
< sizeof(struct route_info
)) {
938 /* Sanity check for prefix_len and length */
939 if (rinfo
->length
> 3) {
941 } else if (rinfo
->prefix_len
> 128) {
943 } else if (rinfo
->prefix_len
> 64) {
944 if (rinfo
->length
< 2) {
947 } else if (rinfo
->prefix_len
> 0) {
948 if (rinfo
->length
< 1) {
953 pref
= rinfo
->route_pref
;
954 if (pref
== ICMPV6_ROUTER_PREF_INVALID
)
957 lifetime
= addrconf_timeout_fixup(ntohl(rinfo
->lifetime
), HZ
);
959 if (rinfo
->length
== 3)
960 prefix
= (struct in6_addr
*)rinfo
->prefix
;
962 /* this function is safe */
963 ipv6_addr_prefix(&prefix_buf
,
964 (struct in6_addr
*)rinfo
->prefix
,
966 prefix
= &prefix_buf
;
969 if (rinfo
->prefix_len
== 0)
970 rt
= rt6_get_dflt_router(net
, gwaddr
, dev
);
972 rt
= rt6_get_route_info(net
, prefix
, rinfo
->prefix_len
,
975 if (rt
&& !lifetime
) {
976 ip6_del_rt(net
, rt
, false);
981 rt
= rt6_add_route_info(net
, prefix
, rinfo
->prefix_len
, gwaddr
,
984 rt
->fib6_flags
= RTF_ROUTEINFO
|
985 (rt
->fib6_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
988 if (!addrconf_finite_timeout(lifetime
))
989 fib6_clean_expires(rt
);
991 fib6_set_expires(rt
, jiffies
+ HZ
* lifetime
);
993 fib6_info_release(rt
);
1000 * Misc support functions
1003 /* called with rcu_lock held */
1004 static struct net_device
*ip6_rt_get_dev_rcu(const struct fib6_result
*res
)
1006 struct net_device
*dev
= res
->nh
->fib_nh_dev
;
1008 if (res
->fib6_flags
& (RTF_LOCAL
| RTF_ANYCAST
)) {
1009 /* for copies of local routes, dst->dev needs to be the
1010 * device if it is a master device, the master device if
1011 * device is enslaved, and the loopback as the default
1013 if (netif_is_l3_slave(dev
) &&
1014 !rt6_need_strict(&res
->f6i
->fib6_dst
.addr
))
1015 dev
= l3mdev_master_dev_rcu(dev
);
1016 else if (!netif_is_l3_master(dev
))
1017 dev
= dev_net(dev
)->loopback_dev
;
1018 /* last case is netif_is_l3_master(dev) is true in which
1019 * case we want dev returned to be dev
1026 static const int fib6_prop
[RTN_MAX
+ 1] = {
1030 [RTN_BROADCAST
] = 0,
1032 [RTN_MULTICAST
] = 0,
1033 [RTN_BLACKHOLE
] = -EINVAL
,
1034 [RTN_UNREACHABLE
] = -EHOSTUNREACH
,
1035 [RTN_PROHIBIT
] = -EACCES
,
1036 [RTN_THROW
] = -EAGAIN
,
1037 [RTN_NAT
] = -EINVAL
,
1038 [RTN_XRESOLVE
] = -EINVAL
,
1041 static int ip6_rt_type_to_error(u8 fib6_type
)
1043 return fib6_prop
[fib6_type
];
1046 static unsigned short fib6_info_dst_flags(struct fib6_info
*rt
)
1048 unsigned short flags
= 0;
1050 if (rt
->dst_nocount
)
1051 flags
|= DST_NOCOUNT
;
1052 if (rt
->dst_nopolicy
)
1053 flags
|= DST_NOPOLICY
;
1058 static void ip6_rt_init_dst_reject(struct rt6_info
*rt
, u8 fib6_type
)
1060 rt
->dst
.error
= ip6_rt_type_to_error(fib6_type
);
1062 switch (fib6_type
) {
1064 rt
->dst
.output
= dst_discard_out
;
1065 rt
->dst
.input
= dst_discard
;
1068 rt
->dst
.output
= ip6_pkt_prohibit_out
;
1069 rt
->dst
.input
= ip6_pkt_prohibit
;
1072 case RTN_UNREACHABLE
:
1074 rt
->dst
.output
= ip6_pkt_discard_out
;
1075 rt
->dst
.input
= ip6_pkt_discard
;
1080 static void ip6_rt_init_dst(struct rt6_info
*rt
, const struct fib6_result
*res
)
1082 struct fib6_info
*f6i
= res
->f6i
;
1084 if (res
->fib6_flags
& RTF_REJECT
) {
1085 ip6_rt_init_dst_reject(rt
, res
->fib6_type
);
1090 rt
->dst
.output
= ip6_output
;
1092 if (res
->fib6_type
== RTN_LOCAL
|| res
->fib6_type
== RTN_ANYCAST
) {
1093 rt
->dst
.input
= ip6_input
;
1094 } else if (ipv6_addr_type(&f6i
->fib6_dst
.addr
) & IPV6_ADDR_MULTICAST
) {
1095 rt
->dst
.input
= ip6_mc_input
;
1097 rt
->dst
.input
= ip6_forward
;
1100 if (res
->nh
->fib_nh_lws
) {
1101 rt
->dst
.lwtstate
= lwtstate_get(res
->nh
->fib_nh_lws
);
1102 lwtunnel_set_redirect(&rt
->dst
);
1105 rt
->dst
.lastuse
= jiffies
;
1108 /* Caller must already hold reference to @from */
1109 static void rt6_set_from(struct rt6_info
*rt
, struct fib6_info
*from
)
1111 rt
->rt6i_flags
&= ~RTF_EXPIRES
;
1112 rcu_assign_pointer(rt
->from
, from
);
1113 ip_dst_init_metrics(&rt
->dst
, from
->fib6_metrics
);
1116 /* Caller must already hold reference to f6i in result */
1117 static void ip6_rt_copy_init(struct rt6_info
*rt
, const struct fib6_result
*res
)
1119 const struct fib6_nh
*nh
= res
->nh
;
1120 const struct net_device
*dev
= nh
->fib_nh_dev
;
1121 struct fib6_info
*f6i
= res
->f6i
;
1123 ip6_rt_init_dst(rt
, res
);
1125 rt
->rt6i_dst
= f6i
->fib6_dst
;
1126 rt
->rt6i_idev
= dev
? in6_dev_get(dev
) : NULL
;
1127 rt
->rt6i_flags
= res
->fib6_flags
;
1128 if (nh
->fib_nh_gw_family
) {
1129 rt
->rt6i_gateway
= nh
->fib_nh_gw6
;
1130 rt
->rt6i_flags
|= RTF_GATEWAY
;
1132 rt6_set_from(rt
, f6i
);
1133 #ifdef CONFIG_IPV6_SUBTREES
1134 rt
->rt6i_src
= f6i
->fib6_src
;
1138 static struct fib6_node
* fib6_backtrack(struct fib6_node
*fn
,
1139 struct in6_addr
*saddr
)
1141 struct fib6_node
*pn
, *sn
;
1143 if (fn
->fn_flags
& RTN_TL_ROOT
)
1145 pn
= rcu_dereference(fn
->parent
);
1146 sn
= FIB6_SUBTREE(pn
);
1148 fn
= fib6_node_lookup(sn
, NULL
, saddr
);
1151 if (fn
->fn_flags
& RTN_RTINFO
)
1156 static bool ip6_hold_safe(struct net
*net
, struct rt6_info
**prt
)
1158 struct rt6_info
*rt
= *prt
;
1160 if (dst_hold_safe(&rt
->dst
))
1163 rt
= net
->ipv6
.ip6_null_entry
;
1172 /* called with rcu_lock held */
1173 static struct rt6_info
*ip6_create_rt_rcu(const struct fib6_result
*res
)
1175 struct net_device
*dev
= res
->nh
->fib_nh_dev
;
1176 struct fib6_info
*f6i
= res
->f6i
;
1177 unsigned short flags
;
1178 struct rt6_info
*nrt
;
1180 if (!fib6_info_hold_safe(f6i
))
1183 flags
= fib6_info_dst_flags(f6i
);
1184 nrt
= ip6_dst_alloc(dev_net(dev
), dev
, flags
);
1186 fib6_info_release(f6i
);
1190 ip6_rt_copy_init(nrt
, res
);
1194 nrt
= dev_net(dev
)->ipv6
.ip6_null_entry
;
1195 dst_hold(&nrt
->dst
);
1199 INDIRECT_CALLABLE_SCOPE
struct rt6_info
*ip6_pol_route_lookup(struct net
*net
,
1200 struct fib6_table
*table
,
1202 const struct sk_buff
*skb
,
1205 struct fib6_result res
= {};
1206 struct fib6_node
*fn
;
1207 struct rt6_info
*rt
;
1209 if (fl6
->flowi6_flags
& FLOWI_FLAG_SKIP_NH_OIF
)
1210 flags
&= ~RT6_LOOKUP_F_IFACE
;
1213 fn
= fib6_node_lookup(&table
->tb6_root
, &fl6
->daddr
, &fl6
->saddr
);
1215 res
.f6i
= rcu_dereference(fn
->leaf
);
1217 res
.f6i
= net
->ipv6
.fib6_null_entry
;
1219 rt6_device_match(net
, &res
, &fl6
->saddr
, fl6
->flowi6_oif
,
1222 if (res
.f6i
== net
->ipv6
.fib6_null_entry
) {
1223 fn
= fib6_backtrack(fn
, &fl6
->saddr
);
1227 rt
= net
->ipv6
.ip6_null_entry
;
1230 } else if (res
.fib6_flags
& RTF_REJECT
) {
1234 fib6_select_path(net
, &res
, fl6
, fl6
->flowi6_oif
,
1235 fl6
->flowi6_oif
!= 0, skb
, flags
);
1237 /* Search through exception table */
1238 rt
= rt6_find_cached_rt(&res
, &fl6
->daddr
, &fl6
->saddr
);
1240 if (ip6_hold_safe(net
, &rt
))
1241 dst_use_noref(&rt
->dst
, jiffies
);
1244 rt
= ip6_create_rt_rcu(&res
);
1248 trace_fib6_table_lookup(net
, &res
, table
, fl6
);
1255 struct dst_entry
*ip6_route_lookup(struct net
*net
, struct flowi6
*fl6
,
1256 const struct sk_buff
*skb
, int flags
)
1258 return fib6_rule_lookup(net
, fl6
, skb
, flags
, ip6_pol_route_lookup
);
1260 EXPORT_SYMBOL_GPL(ip6_route_lookup
);
1262 struct rt6_info
*rt6_lookup(struct net
*net
, const struct in6_addr
*daddr
,
1263 const struct in6_addr
*saddr
, int oif
,
1264 const struct sk_buff
*skb
, int strict
)
1266 struct flowi6 fl6
= {
1270 struct dst_entry
*dst
;
1271 int flags
= strict
? RT6_LOOKUP_F_IFACE
: 0;
1274 memcpy(&fl6
.saddr
, saddr
, sizeof(*saddr
));
1275 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
1278 dst
= fib6_rule_lookup(net
, &fl6
, skb
, flags
, ip6_pol_route_lookup
);
1279 if (dst
->error
== 0)
1280 return (struct rt6_info
*) dst
;
1286 EXPORT_SYMBOL(rt6_lookup
);
1288 /* ip6_ins_rt is called with FREE table->tb6_lock.
1289 * It takes new route entry, the addition fails by any reason the
1290 * route is released.
1291 * Caller must hold dst before calling it.
1294 static int __ip6_ins_rt(struct fib6_info
*rt
, struct nl_info
*info
,
1295 struct netlink_ext_ack
*extack
)
1298 struct fib6_table
*table
;
1300 table
= rt
->fib6_table
;
1301 spin_lock_bh(&table
->tb6_lock
);
1302 err
= fib6_add(&table
->tb6_root
, rt
, info
, extack
);
1303 spin_unlock_bh(&table
->tb6_lock
);
1308 int ip6_ins_rt(struct net
*net
, struct fib6_info
*rt
)
1310 struct nl_info info
= { .nl_net
= net
, };
1312 return __ip6_ins_rt(rt
, &info
, NULL
);
1315 static struct rt6_info
*ip6_rt_cache_alloc(const struct fib6_result
*res
,
1316 const struct in6_addr
*daddr
,
1317 const struct in6_addr
*saddr
)
1319 struct fib6_info
*f6i
= res
->f6i
;
1320 struct net_device
*dev
;
1321 struct rt6_info
*rt
;
1327 if (!fib6_info_hold_safe(f6i
))
1330 dev
= ip6_rt_get_dev_rcu(res
);
1331 rt
= ip6_dst_alloc(dev_net(dev
), dev
, 0);
1333 fib6_info_release(f6i
);
1337 ip6_rt_copy_init(rt
, res
);
1338 rt
->rt6i_flags
|= RTF_CACHE
;
1339 rt
->rt6i_dst
.addr
= *daddr
;
1340 rt
->rt6i_dst
.plen
= 128;
1342 if (!rt6_is_gw_or_nonexthop(res
)) {
1343 if (f6i
->fib6_dst
.plen
!= 128 &&
1344 ipv6_addr_equal(&f6i
->fib6_dst
.addr
, daddr
))
1345 rt
->rt6i_flags
|= RTF_ANYCAST
;
1346 #ifdef CONFIG_IPV6_SUBTREES
1347 if (rt
->rt6i_src
.plen
&& saddr
) {
1348 rt
->rt6i_src
.addr
= *saddr
;
1349 rt
->rt6i_src
.plen
= 128;
1357 static struct rt6_info
*ip6_rt_pcpu_alloc(const struct fib6_result
*res
)
1359 struct fib6_info
*f6i
= res
->f6i
;
1360 unsigned short flags
= fib6_info_dst_flags(f6i
);
1361 struct net_device
*dev
;
1362 struct rt6_info
*pcpu_rt
;
1364 if (!fib6_info_hold_safe(f6i
))
1368 dev
= ip6_rt_get_dev_rcu(res
);
1369 pcpu_rt
= ip6_dst_alloc(dev_net(dev
), dev
, flags
| DST_NOCOUNT
);
1372 fib6_info_release(f6i
);
1375 ip6_rt_copy_init(pcpu_rt
, res
);
1376 pcpu_rt
->rt6i_flags
|= RTF_PCPU
;
1379 pcpu_rt
->sernum
= rt_genid_ipv6(dev_net(dev
));
1384 static bool rt6_is_valid(const struct rt6_info
*rt6
)
1386 return rt6
->sernum
== rt_genid_ipv6(dev_net(rt6
->dst
.dev
));
1389 /* It should be called with rcu_read_lock() acquired */
1390 static struct rt6_info
*rt6_get_pcpu_route(const struct fib6_result
*res
)
1392 struct rt6_info
*pcpu_rt
;
1394 pcpu_rt
= this_cpu_read(*res
->nh
->rt6i_pcpu
);
1396 if (pcpu_rt
&& pcpu_rt
->sernum
&& !rt6_is_valid(pcpu_rt
)) {
1397 struct rt6_info
*prev
, **p
;
1399 p
= this_cpu_ptr(res
->nh
->rt6i_pcpu
);
1400 prev
= xchg(p
, NULL
);
1402 dst_dev_put(&prev
->dst
);
1403 dst_release(&prev
->dst
);
1412 static struct rt6_info
*rt6_make_pcpu_route(struct net
*net
,
1413 const struct fib6_result
*res
)
1415 struct rt6_info
*pcpu_rt
, *prev
, **p
;
1417 pcpu_rt
= ip6_rt_pcpu_alloc(res
);
1421 p
= this_cpu_ptr(res
->nh
->rt6i_pcpu
);
1422 prev
= cmpxchg(p
, NULL
, pcpu_rt
);
1425 if (res
->f6i
->fib6_destroying
) {
1426 struct fib6_info
*from
;
1428 from
= xchg((__force
struct fib6_info
**)&pcpu_rt
->from
, NULL
);
1429 fib6_info_release(from
);
1435 /* exception hash table implementation
1437 static DEFINE_SPINLOCK(rt6_exception_lock
);
1439 /* Remove rt6_ex from hash table and free the memory
1440 * Caller must hold rt6_exception_lock
1442 static void rt6_remove_exception(struct rt6_exception_bucket
*bucket
,
1443 struct rt6_exception
*rt6_ex
)
1445 struct fib6_info
*from
;
1448 if (!bucket
|| !rt6_ex
)
1451 net
= dev_net(rt6_ex
->rt6i
->dst
.dev
);
1452 net
->ipv6
.rt6_stats
->fib_rt_cache
--;
1454 /* purge completely the exception to allow releasing the held resources:
1455 * some [sk] cache may keep the dst around for unlimited time
1457 from
= xchg((__force
struct fib6_info
**)&rt6_ex
->rt6i
->from
, NULL
);
1458 fib6_info_release(from
);
1459 dst_dev_put(&rt6_ex
->rt6i
->dst
);
1461 hlist_del_rcu(&rt6_ex
->hlist
);
1462 dst_release(&rt6_ex
->rt6i
->dst
);
1463 kfree_rcu(rt6_ex
, rcu
);
1464 WARN_ON_ONCE(!bucket
->depth
);
1468 /* Remove oldest rt6_ex in bucket and free the memory
1469 * Caller must hold rt6_exception_lock
1471 static void rt6_exception_remove_oldest(struct rt6_exception_bucket
*bucket
)
1473 struct rt6_exception
*rt6_ex
, *oldest
= NULL
;
1478 hlist_for_each_entry(rt6_ex
, &bucket
->chain
, hlist
) {
1479 if (!oldest
|| time_before(rt6_ex
->stamp
, oldest
->stamp
))
1482 rt6_remove_exception(bucket
, oldest
);
1485 static u32
rt6_exception_hash(const struct in6_addr
*dst
,
1486 const struct in6_addr
*src
)
1488 static siphash_key_t rt6_exception_key __read_mostly
;
1490 struct in6_addr dst
;
1491 struct in6_addr src
;
1492 } __aligned(SIPHASH_ALIGNMENT
) combined
= {
1497 net_get_random_once(&rt6_exception_key
, sizeof(rt6_exception_key
));
1499 #ifdef CONFIG_IPV6_SUBTREES
1501 combined
.src
= *src
;
1503 val
= siphash(&combined
, sizeof(combined
), &rt6_exception_key
);
1505 return hash_64(val
, FIB6_EXCEPTION_BUCKET_SIZE_SHIFT
);
1508 /* Helper function to find the cached rt in the hash table
1509 * and update bucket pointer to point to the bucket for this
1510 * (daddr, saddr) pair
1511 * Caller must hold rt6_exception_lock
1513 static struct rt6_exception
*
1514 __rt6_find_exception_spinlock(struct rt6_exception_bucket
**bucket
,
1515 const struct in6_addr
*daddr
,
1516 const struct in6_addr
*saddr
)
1518 struct rt6_exception
*rt6_ex
;
1521 if (!(*bucket
) || !daddr
)
1524 hval
= rt6_exception_hash(daddr
, saddr
);
1527 hlist_for_each_entry(rt6_ex
, &(*bucket
)->chain
, hlist
) {
1528 struct rt6_info
*rt6
= rt6_ex
->rt6i
;
1529 bool matched
= ipv6_addr_equal(daddr
, &rt6
->rt6i_dst
.addr
);
1531 #ifdef CONFIG_IPV6_SUBTREES
1532 if (matched
&& saddr
)
1533 matched
= ipv6_addr_equal(saddr
, &rt6
->rt6i_src
.addr
);
1541 /* Helper function to find the cached rt in the hash table
1542 * and update bucket pointer to point to the bucket for this
1543 * (daddr, saddr) pair
1544 * Caller must hold rcu_read_lock()
1546 static struct rt6_exception
*
1547 __rt6_find_exception_rcu(struct rt6_exception_bucket
**bucket
,
1548 const struct in6_addr
*daddr
,
1549 const struct in6_addr
*saddr
)
1551 struct rt6_exception
*rt6_ex
;
1554 WARN_ON_ONCE(!rcu_read_lock_held());
1556 if (!(*bucket
) || !daddr
)
1559 hval
= rt6_exception_hash(daddr
, saddr
);
1562 hlist_for_each_entry_rcu(rt6_ex
, &(*bucket
)->chain
, hlist
) {
1563 struct rt6_info
*rt6
= rt6_ex
->rt6i
;
1564 bool matched
= ipv6_addr_equal(daddr
, &rt6
->rt6i_dst
.addr
);
1566 #ifdef CONFIG_IPV6_SUBTREES
1567 if (matched
&& saddr
)
1568 matched
= ipv6_addr_equal(saddr
, &rt6
->rt6i_src
.addr
);
1576 static unsigned int fib6_mtu(const struct fib6_result
*res
)
1578 const struct fib6_nh
*nh
= res
->nh
;
1581 if (res
->f6i
->fib6_pmtu
) {
1582 mtu
= res
->f6i
->fib6_pmtu
;
1584 struct net_device
*dev
= nh
->fib_nh_dev
;
1585 struct inet6_dev
*idev
;
1588 idev
= __in6_dev_get(dev
);
1589 mtu
= idev
->cnf
.mtu6
;
1593 mtu
= min_t(unsigned int, mtu
, IP6_MAX_MTU
);
1595 return mtu
- lwtunnel_headroom(nh
->fib_nh_lws
, mtu
);
1598 #define FIB6_EXCEPTION_BUCKET_FLUSHED 0x1UL
1600 /* used when the flushed bit is not relevant, only access to the bucket
1601 * (ie., all bucket users except rt6_insert_exception);
1603 * called under rcu lock; sometimes called with rt6_exception_lock held
1606 struct rt6_exception_bucket
*fib6_nh_get_excptn_bucket(const struct fib6_nh
*nh
,
1609 struct rt6_exception_bucket
*bucket
;
1612 bucket
= rcu_dereference_protected(nh
->rt6i_exception_bucket
,
1613 lockdep_is_held(lock
));
1615 bucket
= rcu_dereference(nh
->rt6i_exception_bucket
);
1617 /* remove bucket flushed bit if set */
1619 unsigned long p
= (unsigned long)bucket
;
1621 p
&= ~FIB6_EXCEPTION_BUCKET_FLUSHED
;
1622 bucket
= (struct rt6_exception_bucket
*)p
;
1628 static bool fib6_nh_excptn_bucket_flushed(struct rt6_exception_bucket
*bucket
)
1630 unsigned long p
= (unsigned long)bucket
;
1632 return !!(p
& FIB6_EXCEPTION_BUCKET_FLUSHED
);
1635 /* called with rt6_exception_lock held */
1636 static void fib6_nh_excptn_bucket_set_flushed(struct fib6_nh
*nh
,
1639 struct rt6_exception_bucket
*bucket
;
1642 bucket
= rcu_dereference_protected(nh
->rt6i_exception_bucket
,
1643 lockdep_is_held(lock
));
1645 p
= (unsigned long)bucket
;
1646 p
|= FIB6_EXCEPTION_BUCKET_FLUSHED
;
1647 bucket
= (struct rt6_exception_bucket
*)p
;
1648 rcu_assign_pointer(nh
->rt6i_exception_bucket
, bucket
);
1651 static int rt6_insert_exception(struct rt6_info
*nrt
,
1652 const struct fib6_result
*res
)
1654 struct net
*net
= dev_net(nrt
->dst
.dev
);
1655 struct rt6_exception_bucket
*bucket
;
1656 struct fib6_info
*f6i
= res
->f6i
;
1657 struct in6_addr
*src_key
= NULL
;
1658 struct rt6_exception
*rt6_ex
;
1659 struct fib6_nh
*nh
= res
->nh
;
1663 spin_lock_bh(&rt6_exception_lock
);
1665 bucket
= rcu_dereference_protected(nh
->rt6i_exception_bucket
,
1666 lockdep_is_held(&rt6_exception_lock
));
1668 bucket
= kcalloc(FIB6_EXCEPTION_BUCKET_SIZE
, sizeof(*bucket
),
1674 rcu_assign_pointer(nh
->rt6i_exception_bucket
, bucket
);
1675 } else if (fib6_nh_excptn_bucket_flushed(bucket
)) {
1680 #ifdef CONFIG_IPV6_SUBTREES
1681 /* fib6_src.plen != 0 indicates f6i is in subtree
1682 * and exception table is indexed by a hash of
1683 * both fib6_dst and fib6_src.
1684 * Otherwise, the exception table is indexed by
1685 * a hash of only fib6_dst.
1687 if (f6i
->fib6_src
.plen
)
1688 src_key
= &nrt
->rt6i_src
.addr
;
1690 /* rt6_mtu_change() might lower mtu on f6i.
1691 * Only insert this exception route if its mtu
1692 * is less than f6i's mtu value.
1694 if (dst_metric_raw(&nrt
->dst
, RTAX_MTU
) >= fib6_mtu(res
)) {
1699 rt6_ex
= __rt6_find_exception_spinlock(&bucket
, &nrt
->rt6i_dst
.addr
,
1702 rt6_remove_exception(bucket
, rt6_ex
);
1704 rt6_ex
= kzalloc(sizeof(*rt6_ex
), GFP_ATOMIC
);
1710 rt6_ex
->stamp
= jiffies
;
1711 hlist_add_head_rcu(&rt6_ex
->hlist
, &bucket
->chain
);
1713 net
->ipv6
.rt6_stats
->fib_rt_cache
++;
1715 /* Randomize max depth to avoid some side channels attacks. */
1716 max_depth
= FIB6_MAX_DEPTH
+ prandom_u32_max(FIB6_MAX_DEPTH
);
1717 while (bucket
->depth
> max_depth
)
1718 rt6_exception_remove_oldest(bucket
);
1721 spin_unlock_bh(&rt6_exception_lock
);
1723 /* Update fn->fn_sernum to invalidate all cached dst */
1725 spin_lock_bh(&f6i
->fib6_table
->tb6_lock
);
1726 fib6_update_sernum(net
, f6i
);
1727 spin_unlock_bh(&f6i
->fib6_table
->tb6_lock
);
1728 fib6_force_start_gc(net
);
1734 static void fib6_nh_flush_exceptions(struct fib6_nh
*nh
, struct fib6_info
*from
)
1736 struct rt6_exception_bucket
*bucket
;
1737 struct rt6_exception
*rt6_ex
;
1738 struct hlist_node
*tmp
;
1741 spin_lock_bh(&rt6_exception_lock
);
1743 bucket
= fib6_nh_get_excptn_bucket(nh
, &rt6_exception_lock
);
1747 /* Prevent rt6_insert_exception() to recreate the bucket list */
1749 fib6_nh_excptn_bucket_set_flushed(nh
, &rt6_exception_lock
);
1751 for (i
= 0; i
< FIB6_EXCEPTION_BUCKET_SIZE
; i
++) {
1752 hlist_for_each_entry_safe(rt6_ex
, tmp
, &bucket
->chain
, hlist
) {
1754 rcu_access_pointer(rt6_ex
->rt6i
->from
) == from
)
1755 rt6_remove_exception(bucket
, rt6_ex
);
1757 WARN_ON_ONCE(!from
&& bucket
->depth
);
1761 spin_unlock_bh(&rt6_exception_lock
);
1764 static int rt6_nh_flush_exceptions(struct fib6_nh
*nh
, void *arg
)
1766 struct fib6_info
*f6i
= arg
;
1768 fib6_nh_flush_exceptions(nh
, f6i
);
1773 void rt6_flush_exceptions(struct fib6_info
*f6i
)
1776 nexthop_for_each_fib6_nh(f6i
->nh
, rt6_nh_flush_exceptions
,
1779 fib6_nh_flush_exceptions(f6i
->fib6_nh
, f6i
);
1782 /* Find cached rt in the hash table inside passed in rt
1783 * Caller has to hold rcu_read_lock()
1785 static struct rt6_info
*rt6_find_cached_rt(const struct fib6_result
*res
,
1786 const struct in6_addr
*daddr
,
1787 const struct in6_addr
*saddr
)
1789 const struct in6_addr
*src_key
= NULL
;
1790 struct rt6_exception_bucket
*bucket
;
1791 struct rt6_exception
*rt6_ex
;
1792 struct rt6_info
*ret
= NULL
;
1794 #ifdef CONFIG_IPV6_SUBTREES
1795 /* fib6i_src.plen != 0 indicates f6i is in subtree
1796 * and exception table is indexed by a hash of
1797 * both fib6_dst and fib6_src.
1798 * However, the src addr used to create the hash
1799 * might not be exactly the passed in saddr which
1800 * is a /128 addr from the flow.
1801 * So we need to use f6i->fib6_src to redo lookup
1802 * if the passed in saddr does not find anything.
1803 * (See the logic in ip6_rt_cache_alloc() on how
1804 * rt->rt6i_src is updated.)
1806 if (res
->f6i
->fib6_src
.plen
)
1810 bucket
= fib6_nh_get_excptn_bucket(res
->nh
, NULL
);
1811 rt6_ex
= __rt6_find_exception_rcu(&bucket
, daddr
, src_key
);
1813 if (rt6_ex
&& !rt6_check_expired(rt6_ex
->rt6i
))
1816 #ifdef CONFIG_IPV6_SUBTREES
1817 /* Use fib6_src as src_key and redo lookup */
1818 if (!ret
&& src_key
&& src_key
!= &res
->f6i
->fib6_src
.addr
) {
1819 src_key
= &res
->f6i
->fib6_src
.addr
;
1827 /* Remove the passed in cached rt from the hash table that contains it */
1828 static int fib6_nh_remove_exception(const struct fib6_nh
*nh
, int plen
,
1829 const struct rt6_info
*rt
)
1831 const struct in6_addr
*src_key
= NULL
;
1832 struct rt6_exception_bucket
*bucket
;
1833 struct rt6_exception
*rt6_ex
;
1836 if (!rcu_access_pointer(nh
->rt6i_exception_bucket
))
1839 spin_lock_bh(&rt6_exception_lock
);
1840 bucket
= fib6_nh_get_excptn_bucket(nh
, &rt6_exception_lock
);
1842 #ifdef CONFIG_IPV6_SUBTREES
1843 /* rt6i_src.plen != 0 indicates 'from' is in subtree
1844 * and exception table is indexed by a hash of
1845 * both rt6i_dst and rt6i_src.
1846 * Otherwise, the exception table is indexed by
1847 * a hash of only rt6i_dst.
1850 src_key
= &rt
->rt6i_src
.addr
;
1852 rt6_ex
= __rt6_find_exception_spinlock(&bucket
,
1856 rt6_remove_exception(bucket
, rt6_ex
);
1862 spin_unlock_bh(&rt6_exception_lock
);
1866 struct fib6_nh_excptn_arg
{
1867 struct rt6_info
*rt
;
1871 static int rt6_nh_remove_exception_rt(struct fib6_nh
*nh
, void *_arg
)
1873 struct fib6_nh_excptn_arg
*arg
= _arg
;
1876 err
= fib6_nh_remove_exception(nh
, arg
->plen
, arg
->rt
);
1883 static int rt6_remove_exception_rt(struct rt6_info
*rt
)
1885 struct fib6_info
*from
;
1887 from
= rcu_dereference(rt
->from
);
1888 if (!from
|| !(rt
->rt6i_flags
& RTF_CACHE
))
1892 struct fib6_nh_excptn_arg arg
= {
1894 .plen
= from
->fib6_src
.plen
1898 /* rc = 1 means an entry was found */
1899 rc
= nexthop_for_each_fib6_nh(from
->nh
,
1900 rt6_nh_remove_exception_rt
,
1902 return rc
? 0 : -ENOENT
;
1905 return fib6_nh_remove_exception(from
->fib6_nh
,
1906 from
->fib6_src
.plen
, rt
);
1909 /* Find rt6_ex which contains the passed in rt cache and
1912 static void fib6_nh_update_exception(const struct fib6_nh
*nh
, int plen
,
1913 const struct rt6_info
*rt
)
1915 const struct in6_addr
*src_key
= NULL
;
1916 struct rt6_exception_bucket
*bucket
;
1917 struct rt6_exception
*rt6_ex
;
1919 bucket
= fib6_nh_get_excptn_bucket(nh
, NULL
);
1920 #ifdef CONFIG_IPV6_SUBTREES
1921 /* rt6i_src.plen != 0 indicates 'from' is in subtree
1922 * and exception table is indexed by a hash of
1923 * both rt6i_dst and rt6i_src.
1924 * Otherwise, the exception table is indexed by
1925 * a hash of only rt6i_dst.
1928 src_key
= &rt
->rt6i_src
.addr
;
1930 rt6_ex
= __rt6_find_exception_rcu(&bucket
, &rt
->rt6i_dst
.addr
, src_key
);
1932 rt6_ex
->stamp
= jiffies
;
1935 struct fib6_nh_match_arg
{
1936 const struct net_device
*dev
;
1937 const struct in6_addr
*gw
;
1938 struct fib6_nh
*match
;
1941 /* determine if fib6_nh has given device and gateway */
1942 static int fib6_nh_find_match(struct fib6_nh
*nh
, void *_arg
)
1944 struct fib6_nh_match_arg
*arg
= _arg
;
1946 if (arg
->dev
!= nh
->fib_nh_dev
||
1947 (arg
->gw
&& !nh
->fib_nh_gw_family
) ||
1948 (!arg
->gw
&& nh
->fib_nh_gw_family
) ||
1949 (arg
->gw
&& !ipv6_addr_equal(arg
->gw
, &nh
->fib_nh_gw6
)))
1954 /* found a match, break the loop */
1958 static void rt6_update_exception_stamp_rt(struct rt6_info
*rt
)
1960 struct fib6_info
*from
;
1961 struct fib6_nh
*fib6_nh
;
1965 from
= rcu_dereference(rt
->from
);
1966 if (!from
|| !(rt
->rt6i_flags
& RTF_CACHE
))
1970 struct fib6_nh_match_arg arg
= {
1972 .gw
= &rt
->rt6i_gateway
,
1975 nexthop_for_each_fib6_nh(from
->nh
, fib6_nh_find_match
, &arg
);
1979 fib6_nh
= arg
.match
;
1981 fib6_nh
= from
->fib6_nh
;
1983 fib6_nh_update_exception(fib6_nh
, from
->fib6_src
.plen
, rt
);
1988 static bool rt6_mtu_change_route_allowed(struct inet6_dev
*idev
,
1989 struct rt6_info
*rt
, int mtu
)
1991 /* If the new MTU is lower than the route PMTU, this new MTU will be the
1992 * lowest MTU in the path: always allow updating the route PMTU to
1993 * reflect PMTU decreases.
1995 * If the new MTU is higher, and the route PMTU is equal to the local
1996 * MTU, this means the old MTU is the lowest in the path, so allow
1997 * updating it: if other nodes now have lower MTUs, PMTU discovery will
2001 if (dst_mtu(&rt
->dst
) >= mtu
)
2004 if (dst_mtu(&rt
->dst
) == idev
->cnf
.mtu6
)
2010 static void rt6_exceptions_update_pmtu(struct inet6_dev
*idev
,
2011 const struct fib6_nh
*nh
, int mtu
)
2013 struct rt6_exception_bucket
*bucket
;
2014 struct rt6_exception
*rt6_ex
;
2017 bucket
= fib6_nh_get_excptn_bucket(nh
, &rt6_exception_lock
);
2021 for (i
= 0; i
< FIB6_EXCEPTION_BUCKET_SIZE
; i
++) {
2022 hlist_for_each_entry(rt6_ex
, &bucket
->chain
, hlist
) {
2023 struct rt6_info
*entry
= rt6_ex
->rt6i
;
2025 /* For RTF_CACHE with rt6i_pmtu == 0 (i.e. a redirected
2026 * route), the metrics of its rt->from have already
2029 if (dst_metric_raw(&entry
->dst
, RTAX_MTU
) &&
2030 rt6_mtu_change_route_allowed(idev
, entry
, mtu
))
2031 dst_metric_set(&entry
->dst
, RTAX_MTU
, mtu
);
2037 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2039 static void fib6_nh_exceptions_clean_tohost(const struct fib6_nh
*nh
,
2040 const struct in6_addr
*gateway
)
2042 struct rt6_exception_bucket
*bucket
;
2043 struct rt6_exception
*rt6_ex
;
2044 struct hlist_node
*tmp
;
2047 if (!rcu_access_pointer(nh
->rt6i_exception_bucket
))
2050 spin_lock_bh(&rt6_exception_lock
);
2051 bucket
= fib6_nh_get_excptn_bucket(nh
, &rt6_exception_lock
);
2053 for (i
= 0; i
< FIB6_EXCEPTION_BUCKET_SIZE
; i
++) {
2054 hlist_for_each_entry_safe(rt6_ex
, tmp
,
2055 &bucket
->chain
, hlist
) {
2056 struct rt6_info
*entry
= rt6_ex
->rt6i
;
2058 if ((entry
->rt6i_flags
& RTF_CACHE_GATEWAY
) ==
2059 RTF_CACHE_GATEWAY
&&
2060 ipv6_addr_equal(gateway
,
2061 &entry
->rt6i_gateway
)) {
2062 rt6_remove_exception(bucket
, rt6_ex
);
2069 spin_unlock_bh(&rt6_exception_lock
);
2072 static void rt6_age_examine_exception(struct rt6_exception_bucket
*bucket
,
2073 struct rt6_exception
*rt6_ex
,
2074 struct fib6_gc_args
*gc_args
,
2077 struct rt6_info
*rt
= rt6_ex
->rt6i
;
2079 /* we are pruning and obsoleting aged-out and non gateway exceptions
2080 * even if others have still references to them, so that on next
2081 * dst_check() such references can be dropped.
2082 * EXPIRES exceptions - e.g. pmtu-generated ones are pruned when
2083 * expired, independently from their aging, as per RFC 8201 section 4
2085 if (!(rt
->rt6i_flags
& RTF_EXPIRES
)) {
2086 if (time_after_eq(now
, rt
->dst
.lastuse
+ gc_args
->timeout
)) {
2087 RT6_TRACE("aging clone %p\n", rt
);
2088 rt6_remove_exception(bucket
, rt6_ex
);
2091 } else if (time_after(jiffies
, rt
->dst
.expires
)) {
2092 RT6_TRACE("purging expired route %p\n", rt
);
2093 rt6_remove_exception(bucket
, rt6_ex
);
2097 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
2098 struct neighbour
*neigh
;
2100 neigh
= __ipv6_neigh_lookup_noref(rt
->dst
.dev
, &rt
->rt6i_gateway
);
2102 if (!(neigh
&& (neigh
->flags
& NTF_ROUTER
))) {
2103 RT6_TRACE("purging route %p via non-router but gateway\n",
2105 rt6_remove_exception(bucket
, rt6_ex
);
2113 static void fib6_nh_age_exceptions(const struct fib6_nh
*nh
,
2114 struct fib6_gc_args
*gc_args
,
2117 struct rt6_exception_bucket
*bucket
;
2118 struct rt6_exception
*rt6_ex
;
2119 struct hlist_node
*tmp
;
2122 if (!rcu_access_pointer(nh
->rt6i_exception_bucket
))
2126 spin_lock(&rt6_exception_lock
);
2127 bucket
= fib6_nh_get_excptn_bucket(nh
, &rt6_exception_lock
);
2129 for (i
= 0; i
< FIB6_EXCEPTION_BUCKET_SIZE
; i
++) {
2130 hlist_for_each_entry_safe(rt6_ex
, tmp
,
2131 &bucket
->chain
, hlist
) {
2132 rt6_age_examine_exception(bucket
, rt6_ex
,
2138 spin_unlock(&rt6_exception_lock
);
2139 rcu_read_unlock_bh();
2142 struct fib6_nh_age_excptn_arg
{
2143 struct fib6_gc_args
*gc_args
;
2147 static int rt6_nh_age_exceptions(struct fib6_nh
*nh
, void *_arg
)
2149 struct fib6_nh_age_excptn_arg
*arg
= _arg
;
2151 fib6_nh_age_exceptions(nh
, arg
->gc_args
, arg
->now
);
2155 void rt6_age_exceptions(struct fib6_info
*f6i
,
2156 struct fib6_gc_args
*gc_args
,
2160 struct fib6_nh_age_excptn_arg arg
= {
2165 nexthop_for_each_fib6_nh(f6i
->nh
, rt6_nh_age_exceptions
,
2168 fib6_nh_age_exceptions(f6i
->fib6_nh
, gc_args
, now
);
2172 /* must be called with rcu lock held */
2173 int fib6_table_lookup(struct net
*net
, struct fib6_table
*table
, int oif
,
2174 struct flowi6
*fl6
, struct fib6_result
*res
, int strict
)
2176 struct fib6_node
*fn
, *saved_fn
;
2178 fn
= fib6_node_lookup(&table
->tb6_root
, &fl6
->daddr
, &fl6
->saddr
);
2181 if (fl6
->flowi6_flags
& FLOWI_FLAG_SKIP_NH_OIF
)
2185 rt6_select(net
, fn
, oif
, res
, strict
);
2186 if (res
->f6i
== net
->ipv6
.fib6_null_entry
) {
2187 fn
= fib6_backtrack(fn
, &fl6
->saddr
);
2189 goto redo_rt6_select
;
2190 else if (strict
& RT6_LOOKUP_F_REACHABLE
) {
2191 /* also consider unreachable route */
2192 strict
&= ~RT6_LOOKUP_F_REACHABLE
;
2194 goto redo_rt6_select
;
2198 trace_fib6_table_lookup(net
, res
, table
, fl6
);
2203 struct rt6_info
*ip6_pol_route(struct net
*net
, struct fib6_table
*table
,
2204 int oif
, struct flowi6
*fl6
,
2205 const struct sk_buff
*skb
, int flags
)
2207 struct fib6_result res
= {};
2208 struct rt6_info
*rt
= NULL
;
2211 WARN_ON_ONCE((flags
& RT6_LOOKUP_F_DST_NOREF
) &&
2212 !rcu_read_lock_held());
2214 strict
|= flags
& RT6_LOOKUP_F_IFACE
;
2215 strict
|= flags
& RT6_LOOKUP_F_IGNORE_LINKSTATE
;
2216 if (net
->ipv6
.devconf_all
->forwarding
== 0)
2217 strict
|= RT6_LOOKUP_F_REACHABLE
;
2221 fib6_table_lookup(net
, table
, oif
, fl6
, &res
, strict
);
2222 if (res
.f6i
== net
->ipv6
.fib6_null_entry
)
2225 fib6_select_path(net
, &res
, fl6
, oif
, false, skb
, strict
);
2227 /*Search through exception table */
2228 rt
= rt6_find_cached_rt(&res
, &fl6
->daddr
, &fl6
->saddr
);
2231 } else if (unlikely((fl6
->flowi6_flags
& FLOWI_FLAG_KNOWN_NH
) &&
2232 !res
.nh
->fib_nh_gw_family
)) {
2233 /* Create a RTF_CACHE clone which will not be
2234 * owned by the fib6 tree. It is for the special case where
2235 * the daddr in the skb during the neighbor look-up is different
2236 * from the fl6->daddr used to look-up route here.
2238 rt
= ip6_rt_cache_alloc(&res
, &fl6
->daddr
, NULL
);
2241 /* 1 refcnt is taken during ip6_rt_cache_alloc().
2242 * As rt6_uncached_list_add() does not consume refcnt,
2243 * this refcnt is always returned to the caller even
2244 * if caller sets RT6_LOOKUP_F_DST_NOREF flag.
2246 rt6_uncached_list_add(rt
);
2247 atomic_inc(&net
->ipv6
.rt6_stats
->fib_rt_uncache
);
2253 /* Get a percpu copy */
2255 rt
= rt6_get_pcpu_route(&res
);
2258 rt
= rt6_make_pcpu_route(net
, &res
);
2264 rt
= net
->ipv6
.ip6_null_entry
;
2265 if (!(flags
& RT6_LOOKUP_F_DST_NOREF
))
2266 ip6_hold_safe(net
, &rt
);
2271 EXPORT_SYMBOL_GPL(ip6_pol_route
);
2273 INDIRECT_CALLABLE_SCOPE
struct rt6_info
*ip6_pol_route_input(struct net
*net
,
2274 struct fib6_table
*table
,
2276 const struct sk_buff
*skb
,
2279 return ip6_pol_route(net
, table
, fl6
->flowi6_iif
, fl6
, skb
, flags
);
2282 struct dst_entry
*ip6_route_input_lookup(struct net
*net
,
2283 struct net_device
*dev
,
2285 const struct sk_buff
*skb
,
2288 if (rt6_need_strict(&fl6
->daddr
) && dev
->type
!= ARPHRD_PIMREG
)
2289 flags
|= RT6_LOOKUP_F_IFACE
;
2291 return fib6_rule_lookup(net
, fl6
, skb
, flags
, ip6_pol_route_input
);
2293 EXPORT_SYMBOL_GPL(ip6_route_input_lookup
);
2295 static void ip6_multipath_l3_keys(const struct sk_buff
*skb
,
2296 struct flow_keys
*keys
,
2297 struct flow_keys
*flkeys
)
2299 const struct ipv6hdr
*outer_iph
= ipv6_hdr(skb
);
2300 const struct ipv6hdr
*key_iph
= outer_iph
;
2301 struct flow_keys
*_flkeys
= flkeys
;
2302 const struct ipv6hdr
*inner_iph
;
2303 const struct icmp6hdr
*icmph
;
2304 struct ipv6hdr _inner_iph
;
2305 struct icmp6hdr _icmph
;
2307 if (likely(outer_iph
->nexthdr
!= IPPROTO_ICMPV6
))
2310 icmph
= skb_header_pointer(skb
, skb_transport_offset(skb
),
2311 sizeof(_icmph
), &_icmph
);
2315 if (!icmpv6_is_err(icmph
->icmp6_type
))
2318 inner_iph
= skb_header_pointer(skb
,
2319 skb_transport_offset(skb
) + sizeof(*icmph
),
2320 sizeof(_inner_iph
), &_inner_iph
);
2324 key_iph
= inner_iph
;
2328 keys
->addrs
.v6addrs
.src
= _flkeys
->addrs
.v6addrs
.src
;
2329 keys
->addrs
.v6addrs
.dst
= _flkeys
->addrs
.v6addrs
.dst
;
2330 keys
->tags
.flow_label
= _flkeys
->tags
.flow_label
;
2331 keys
->basic
.ip_proto
= _flkeys
->basic
.ip_proto
;
2333 keys
->addrs
.v6addrs
.src
= key_iph
->saddr
;
2334 keys
->addrs
.v6addrs
.dst
= key_iph
->daddr
;
2335 keys
->tags
.flow_label
= ip6_flowlabel(key_iph
);
2336 keys
->basic
.ip_proto
= key_iph
->nexthdr
;
2340 static u32
rt6_multipath_custom_hash_outer(const struct net
*net
,
2341 const struct sk_buff
*skb
,
2344 u32 hash_fields
= ip6_multipath_hash_fields(net
);
2345 struct flow_keys keys
, hash_keys
;
2347 if (!(hash_fields
& FIB_MULTIPATH_HASH_FIELD_OUTER_MASK
))
2350 memset(&hash_keys
, 0, sizeof(hash_keys
));
2351 skb_flow_dissect_flow_keys(skb
, &keys
, FLOW_DISSECTOR_F_STOP_AT_ENCAP
);
2353 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2354 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_SRC_IP
)
2355 hash_keys
.addrs
.v6addrs
.src
= keys
.addrs
.v6addrs
.src
;
2356 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_DST_IP
)
2357 hash_keys
.addrs
.v6addrs
.dst
= keys
.addrs
.v6addrs
.dst
;
2358 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_IP_PROTO
)
2359 hash_keys
.basic
.ip_proto
= keys
.basic
.ip_proto
;
2360 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_FLOWLABEL
)
2361 hash_keys
.tags
.flow_label
= keys
.tags
.flow_label
;
2362 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_SRC_PORT
)
2363 hash_keys
.ports
.src
= keys
.ports
.src
;
2364 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_DST_PORT
)
2365 hash_keys
.ports
.dst
= keys
.ports
.dst
;
2367 *p_has_inner
= !!(keys
.control
.flags
& FLOW_DIS_ENCAPSULATION
);
2368 return flow_hash_from_keys(&hash_keys
);
2371 static u32
rt6_multipath_custom_hash_inner(const struct net
*net
,
2372 const struct sk_buff
*skb
,
2375 u32 hash_fields
= ip6_multipath_hash_fields(net
);
2376 struct flow_keys keys
, hash_keys
;
2378 /* We assume the packet carries an encapsulation, but if none was
2379 * encountered during dissection of the outer flow, then there is no
2380 * point in calling the flow dissector again.
2385 if (!(hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_MASK
))
2388 memset(&hash_keys
, 0, sizeof(hash_keys
));
2389 skb_flow_dissect_flow_keys(skb
, &keys
, 0);
2391 if (!(keys
.control
.flags
& FLOW_DIS_ENCAPSULATION
))
2394 if (keys
.control
.addr_type
== FLOW_DISSECTOR_KEY_IPV4_ADDRS
) {
2395 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
2396 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP
)
2397 hash_keys
.addrs
.v4addrs
.src
= keys
.addrs
.v4addrs
.src
;
2398 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP
)
2399 hash_keys
.addrs
.v4addrs
.dst
= keys
.addrs
.v4addrs
.dst
;
2400 } else if (keys
.control
.addr_type
== FLOW_DISSECTOR_KEY_IPV6_ADDRS
) {
2401 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2402 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP
)
2403 hash_keys
.addrs
.v6addrs
.src
= keys
.addrs
.v6addrs
.src
;
2404 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP
)
2405 hash_keys
.addrs
.v6addrs
.dst
= keys
.addrs
.v6addrs
.dst
;
2406 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_FLOWLABEL
)
2407 hash_keys
.tags
.flow_label
= keys
.tags
.flow_label
;
2410 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO
)
2411 hash_keys
.basic
.ip_proto
= keys
.basic
.ip_proto
;
2412 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_SRC_PORT
)
2413 hash_keys
.ports
.src
= keys
.ports
.src
;
2414 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_INNER_DST_PORT
)
2415 hash_keys
.ports
.dst
= keys
.ports
.dst
;
2417 return flow_hash_from_keys(&hash_keys
);
2420 static u32
rt6_multipath_custom_hash_skb(const struct net
*net
,
2421 const struct sk_buff
*skb
)
2423 u32 mhash
, mhash_inner
;
2424 bool has_inner
= true;
2426 mhash
= rt6_multipath_custom_hash_outer(net
, skb
, &has_inner
);
2427 mhash_inner
= rt6_multipath_custom_hash_inner(net
, skb
, has_inner
);
2429 return jhash_2words(mhash
, mhash_inner
, 0);
2432 static u32
rt6_multipath_custom_hash_fl6(const struct net
*net
,
2433 const struct flowi6
*fl6
)
2435 u32 hash_fields
= ip6_multipath_hash_fields(net
);
2436 struct flow_keys hash_keys
;
2438 if (!(hash_fields
& FIB_MULTIPATH_HASH_FIELD_OUTER_MASK
))
2441 memset(&hash_keys
, 0, sizeof(hash_keys
));
2442 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2443 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_SRC_IP
)
2444 hash_keys
.addrs
.v6addrs
.src
= fl6
->saddr
;
2445 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_DST_IP
)
2446 hash_keys
.addrs
.v6addrs
.dst
= fl6
->daddr
;
2447 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_IP_PROTO
)
2448 hash_keys
.basic
.ip_proto
= fl6
->flowi6_proto
;
2449 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_FLOWLABEL
)
2450 hash_keys
.tags
.flow_label
= (__force u32
)flowi6_get_flowlabel(fl6
);
2451 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_SRC_PORT
)
2452 hash_keys
.ports
.src
= fl6
->fl6_sport
;
2453 if (hash_fields
& FIB_MULTIPATH_HASH_FIELD_DST_PORT
)
2454 hash_keys
.ports
.dst
= fl6
->fl6_dport
;
2456 return flow_hash_from_keys(&hash_keys
);
2459 /* if skb is set it will be used and fl6 can be NULL */
2460 u32
rt6_multipath_hash(const struct net
*net
, const struct flowi6
*fl6
,
2461 const struct sk_buff
*skb
, struct flow_keys
*flkeys
)
2463 struct flow_keys hash_keys
;
2466 switch (ip6_multipath_hash_policy(net
)) {
2468 memset(&hash_keys
, 0, sizeof(hash_keys
));
2469 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2471 ip6_multipath_l3_keys(skb
, &hash_keys
, flkeys
);
2473 hash_keys
.addrs
.v6addrs
.src
= fl6
->saddr
;
2474 hash_keys
.addrs
.v6addrs
.dst
= fl6
->daddr
;
2475 hash_keys
.tags
.flow_label
= (__force u32
)flowi6_get_flowlabel(fl6
);
2476 hash_keys
.basic
.ip_proto
= fl6
->flowi6_proto
;
2478 mhash
= flow_hash_from_keys(&hash_keys
);
2482 unsigned int flag
= FLOW_DISSECTOR_F_STOP_AT_ENCAP
;
2483 struct flow_keys keys
;
2485 /* short-circuit if we already have L4 hash present */
2487 return skb_get_hash_raw(skb
) >> 1;
2489 memset(&hash_keys
, 0, sizeof(hash_keys
));
2492 skb_flow_dissect_flow_keys(skb
, &keys
, flag
);
2495 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2496 hash_keys
.addrs
.v6addrs
.src
= flkeys
->addrs
.v6addrs
.src
;
2497 hash_keys
.addrs
.v6addrs
.dst
= flkeys
->addrs
.v6addrs
.dst
;
2498 hash_keys
.ports
.src
= flkeys
->ports
.src
;
2499 hash_keys
.ports
.dst
= flkeys
->ports
.dst
;
2500 hash_keys
.basic
.ip_proto
= flkeys
->basic
.ip_proto
;
2502 memset(&hash_keys
, 0, sizeof(hash_keys
));
2503 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2504 hash_keys
.addrs
.v6addrs
.src
= fl6
->saddr
;
2505 hash_keys
.addrs
.v6addrs
.dst
= fl6
->daddr
;
2506 hash_keys
.ports
.src
= fl6
->fl6_sport
;
2507 hash_keys
.ports
.dst
= fl6
->fl6_dport
;
2508 hash_keys
.basic
.ip_proto
= fl6
->flowi6_proto
;
2510 mhash
= flow_hash_from_keys(&hash_keys
);
2513 memset(&hash_keys
, 0, sizeof(hash_keys
));
2514 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2516 struct flow_keys keys
;
2519 skb_flow_dissect_flow_keys(skb
, &keys
, 0);
2523 /* Inner can be v4 or v6 */
2524 if (flkeys
->control
.addr_type
== FLOW_DISSECTOR_KEY_IPV4_ADDRS
) {
2525 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
2526 hash_keys
.addrs
.v4addrs
.src
= flkeys
->addrs
.v4addrs
.src
;
2527 hash_keys
.addrs
.v4addrs
.dst
= flkeys
->addrs
.v4addrs
.dst
;
2528 } else if (flkeys
->control
.addr_type
== FLOW_DISSECTOR_KEY_IPV6_ADDRS
) {
2529 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2530 hash_keys
.addrs
.v6addrs
.src
= flkeys
->addrs
.v6addrs
.src
;
2531 hash_keys
.addrs
.v6addrs
.dst
= flkeys
->addrs
.v6addrs
.dst
;
2532 hash_keys
.tags
.flow_label
= flkeys
->tags
.flow_label
;
2533 hash_keys
.basic
.ip_proto
= flkeys
->basic
.ip_proto
;
2535 /* Same as case 0 */
2536 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2537 ip6_multipath_l3_keys(skb
, &hash_keys
, flkeys
);
2540 /* Same as case 0 */
2541 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
2542 hash_keys
.addrs
.v6addrs
.src
= fl6
->saddr
;
2543 hash_keys
.addrs
.v6addrs
.dst
= fl6
->daddr
;
2544 hash_keys
.tags
.flow_label
= (__force u32
)flowi6_get_flowlabel(fl6
);
2545 hash_keys
.basic
.ip_proto
= fl6
->flowi6_proto
;
2547 mhash
= flow_hash_from_keys(&hash_keys
);
2551 mhash
= rt6_multipath_custom_hash_skb(net
, skb
);
2553 mhash
= rt6_multipath_custom_hash_fl6(net
, fl6
);
2560 /* Called with rcu held */
2561 void ip6_route_input(struct sk_buff
*skb
)
2563 const struct ipv6hdr
*iph
= ipv6_hdr(skb
);
2564 struct net
*net
= dev_net(skb
->dev
);
2565 int flags
= RT6_LOOKUP_F_HAS_SADDR
| RT6_LOOKUP_F_DST_NOREF
;
2566 struct ip_tunnel_info
*tun_info
;
2567 struct flowi6 fl6
= {
2568 .flowi6_iif
= skb
->dev
->ifindex
,
2569 .daddr
= iph
->daddr
,
2570 .saddr
= iph
->saddr
,
2571 .flowlabel
= ip6_flowinfo(iph
),
2572 .flowi6_mark
= skb
->mark
,
2573 .flowi6_proto
= iph
->nexthdr
,
2575 struct flow_keys
*flkeys
= NULL
, _flkeys
;
2577 tun_info
= skb_tunnel_info(skb
);
2578 if (tun_info
&& !(tun_info
->mode
& IP_TUNNEL_INFO_TX
))
2579 fl6
.flowi6_tun_key
.tun_id
= tun_info
->key
.tun_id
;
2581 if (fib6_rules_early_flow_dissect(net
, skb
, &fl6
, &_flkeys
))
2584 if (unlikely(fl6
.flowi6_proto
== IPPROTO_ICMPV6
))
2585 fl6
.mp_hash
= rt6_multipath_hash(net
, &fl6
, skb
, flkeys
);
2587 skb_dst_set_noref(skb
, ip6_route_input_lookup(net
, skb
->dev
,
2591 INDIRECT_CALLABLE_SCOPE
struct rt6_info
*ip6_pol_route_output(struct net
*net
,
2592 struct fib6_table
*table
,
2594 const struct sk_buff
*skb
,
2597 return ip6_pol_route(net
, table
, fl6
->flowi6_oif
, fl6
, skb
, flags
);
2600 struct dst_entry
*ip6_route_output_flags_noref(struct net
*net
,
2601 const struct sock
*sk
,
2602 struct flowi6
*fl6
, int flags
)
2606 if (ipv6_addr_type(&fl6
->daddr
) &
2607 (IPV6_ADDR_MULTICAST
| IPV6_ADDR_LINKLOCAL
)) {
2608 struct dst_entry
*dst
;
2610 /* This function does not take refcnt on the dst */
2611 dst
= l3mdev_link_scope_lookup(net
, fl6
);
2616 fl6
->flowi6_iif
= LOOPBACK_IFINDEX
;
2618 flags
|= RT6_LOOKUP_F_DST_NOREF
;
2619 any_src
= ipv6_addr_any(&fl6
->saddr
);
2620 if ((sk
&& sk
->sk_bound_dev_if
) || rt6_need_strict(&fl6
->daddr
) ||
2621 (fl6
->flowi6_oif
&& any_src
))
2622 flags
|= RT6_LOOKUP_F_IFACE
;
2625 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
2627 flags
|= rt6_srcprefs2flags(inet6_sk(sk
)->srcprefs
);
2629 return fib6_rule_lookup(net
, fl6
, NULL
, flags
, ip6_pol_route_output
);
2631 EXPORT_SYMBOL_GPL(ip6_route_output_flags_noref
);
2633 struct dst_entry
*ip6_route_output_flags(struct net
*net
,
2634 const struct sock
*sk
,
2638 struct dst_entry
*dst
;
2639 struct rt6_info
*rt6
;
2642 dst
= ip6_route_output_flags_noref(net
, sk
, fl6
, flags
);
2643 rt6
= (struct rt6_info
*)dst
;
2644 /* For dst cached in uncached_list, refcnt is already taken. */
2645 if (list_empty(&rt6
->rt6i_uncached
) && !dst_hold_safe(dst
)) {
2646 dst
= &net
->ipv6
.ip6_null_entry
->dst
;
2653 EXPORT_SYMBOL_GPL(ip6_route_output_flags
);
2655 struct dst_entry
*ip6_blackhole_route(struct net
*net
, struct dst_entry
*dst_orig
)
2657 struct rt6_info
*rt
, *ort
= (struct rt6_info
*) dst_orig
;
2658 struct net_device
*loopback_dev
= net
->loopback_dev
;
2659 struct dst_entry
*new = NULL
;
2661 rt
= dst_alloc(&ip6_dst_blackhole_ops
, loopback_dev
, 1,
2662 DST_OBSOLETE_DEAD
, 0);
2665 atomic_inc(&net
->ipv6
.rt6_stats
->fib_rt_alloc
);
2669 new->input
= dst_discard
;
2670 new->output
= dst_discard_out
;
2672 dst_copy_metrics(new, &ort
->dst
);
2674 rt
->rt6i_idev
= in6_dev_get(loopback_dev
);
2675 rt
->rt6i_gateway
= ort
->rt6i_gateway
;
2676 rt
->rt6i_flags
= ort
->rt6i_flags
& ~RTF_PCPU
;
2678 memcpy(&rt
->rt6i_dst
, &ort
->rt6i_dst
, sizeof(struct rt6key
));
2679 #ifdef CONFIG_IPV6_SUBTREES
2680 memcpy(&rt
->rt6i_src
, &ort
->rt6i_src
, sizeof(struct rt6key
));
2684 dst_release(dst_orig
);
2685 return new ? new : ERR_PTR(-ENOMEM
);
2689 * Destination cache support functions
2692 static bool fib6_check(struct fib6_info
*f6i
, u32 cookie
)
2696 if (!fib6_get_cookie_safe(f6i
, &rt_cookie
) || rt_cookie
!= cookie
)
2699 if (fib6_check_expired(f6i
))
2705 static struct dst_entry
*rt6_check(struct rt6_info
*rt
,
2706 struct fib6_info
*from
,
2711 if (!from
|| !fib6_get_cookie_safe(from
, &rt_cookie
) ||
2712 rt_cookie
!= cookie
)
2715 if (rt6_check_expired(rt
))
2721 static struct dst_entry
*rt6_dst_from_check(struct rt6_info
*rt
,
2722 struct fib6_info
*from
,
2725 if (!__rt6_check_expired(rt
) &&
2726 rt
->dst
.obsolete
== DST_OBSOLETE_FORCE_CHK
&&
2727 fib6_check(from
, cookie
))
2733 INDIRECT_CALLABLE_SCOPE
struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
,
2736 struct dst_entry
*dst_ret
;
2737 struct fib6_info
*from
;
2738 struct rt6_info
*rt
;
2740 rt
= container_of(dst
, struct rt6_info
, dst
);
2743 return rt6_is_valid(rt
) ? dst
: NULL
;
2747 /* All IPV6 dsts are created with ->obsolete set to the value
2748 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
2749 * into this function always.
2752 from
= rcu_dereference(rt
->from
);
2754 if (from
&& (rt
->rt6i_flags
& RTF_PCPU
||
2755 unlikely(!list_empty(&rt
->rt6i_uncached
))))
2756 dst_ret
= rt6_dst_from_check(rt
, from
, cookie
);
2758 dst_ret
= rt6_check(rt
, from
, cookie
);
2764 EXPORT_INDIRECT_CALLABLE(ip6_dst_check
);
2766 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*dst
)
2768 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
2771 if (rt
->rt6i_flags
& RTF_CACHE
) {
2773 if (rt6_check_expired(rt
)) {
2774 rt6_remove_exception_rt(rt
);
2786 static void ip6_link_failure(struct sk_buff
*skb
)
2788 struct rt6_info
*rt
;
2790 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_ADDR_UNREACH
, 0);
2792 rt
= (struct rt6_info
*) skb_dst(skb
);
2795 if (rt
->rt6i_flags
& RTF_CACHE
) {
2796 rt6_remove_exception_rt(rt
);
2798 struct fib6_info
*from
;
2799 struct fib6_node
*fn
;
2801 from
= rcu_dereference(rt
->from
);
2803 fn
= rcu_dereference(from
->fib6_node
);
2804 if (fn
&& (rt
->rt6i_flags
& RTF_DEFAULT
))
2812 static void rt6_update_expires(struct rt6_info
*rt0
, int timeout
)
2814 if (!(rt0
->rt6i_flags
& RTF_EXPIRES
)) {
2815 struct fib6_info
*from
;
2818 from
= rcu_dereference(rt0
->from
);
2820 rt0
->dst
.expires
= from
->expires
;
2824 dst_set_expires(&rt0
->dst
, timeout
);
2825 rt0
->rt6i_flags
|= RTF_EXPIRES
;
2828 static void rt6_do_update_pmtu(struct rt6_info
*rt
, u32 mtu
)
2830 struct net
*net
= dev_net(rt
->dst
.dev
);
2832 dst_metric_set(&rt
->dst
, RTAX_MTU
, mtu
);
2833 rt
->rt6i_flags
|= RTF_MODIFIED
;
2834 rt6_update_expires(rt
, net
->ipv6
.sysctl
.ip6_rt_mtu_expires
);
2837 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info
*rt
)
2839 return !(rt
->rt6i_flags
& RTF_CACHE
) &&
2840 (rt
->rt6i_flags
& RTF_PCPU
|| rcu_access_pointer(rt
->from
));
2843 static void __ip6_rt_update_pmtu(struct dst_entry
*dst
, const struct sock
*sk
,
2844 const struct ipv6hdr
*iph
, u32 mtu
,
2847 const struct in6_addr
*daddr
, *saddr
;
2848 struct rt6_info
*rt6
= (struct rt6_info
*)dst
;
2850 /* Note: do *NOT* check dst_metric_locked(dst, RTAX_MTU)
2851 * IPv6 pmtu discovery isn't optional, so 'mtu lock' cannot disable it.
2852 * [see also comment in rt6_mtu_change_route()]
2856 daddr
= &iph
->daddr
;
2857 saddr
= &iph
->saddr
;
2859 daddr
= &sk
->sk_v6_daddr
;
2860 saddr
= &inet6_sk(sk
)->saddr
;
2867 dst_confirm_neigh(dst
, daddr
);
2869 if (mtu
< IPV6_MIN_MTU
)
2871 if (mtu
>= dst_mtu(dst
))
2874 if (!rt6_cache_allowed_for_pmtu(rt6
)) {
2875 rt6_do_update_pmtu(rt6
, mtu
);
2876 /* update rt6_ex->stamp for cache */
2877 if (rt6
->rt6i_flags
& RTF_CACHE
)
2878 rt6_update_exception_stamp_rt(rt6
);
2880 struct fib6_result res
= {};
2881 struct rt6_info
*nrt6
;
2884 res
.f6i
= rcu_dereference(rt6
->from
);
2888 res
.fib6_flags
= res
.f6i
->fib6_flags
;
2889 res
.fib6_type
= res
.f6i
->fib6_type
;
2892 struct fib6_nh_match_arg arg
= {
2894 .gw
= &rt6
->rt6i_gateway
,
2897 nexthop_for_each_fib6_nh(res
.f6i
->nh
,
2898 fib6_nh_find_match
, &arg
);
2900 /* fib6_info uses a nexthop that does not have fib6_nh
2901 * using the dst->dev + gw. Should be impossible.
2908 res
.nh
= res
.f6i
->fib6_nh
;
2911 nrt6
= ip6_rt_cache_alloc(&res
, daddr
, saddr
);
2913 rt6_do_update_pmtu(nrt6
, mtu
);
2914 if (rt6_insert_exception(nrt6
, &res
))
2915 dst_release_immediate(&nrt6
->dst
);
2922 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
2923 struct sk_buff
*skb
, u32 mtu
,
2926 __ip6_rt_update_pmtu(dst
, sk
, skb
? ipv6_hdr(skb
) : NULL
, mtu
,
2930 void ip6_update_pmtu(struct sk_buff
*skb
, struct net
*net
, __be32 mtu
,
2931 int oif
, u32 mark
, kuid_t uid
)
2933 const struct ipv6hdr
*iph
= (struct ipv6hdr
*) skb
->data
;
2934 struct dst_entry
*dst
;
2935 struct flowi6 fl6
= {
2937 .flowi6_mark
= mark
? mark
: IP6_REPLY_MARK(net
, skb
->mark
),
2938 .daddr
= iph
->daddr
,
2939 .saddr
= iph
->saddr
,
2940 .flowlabel
= ip6_flowinfo(iph
),
2944 dst
= ip6_route_output(net
, NULL
, &fl6
);
2946 __ip6_rt_update_pmtu(dst
, NULL
, iph
, ntohl(mtu
), true);
2949 EXPORT_SYMBOL_GPL(ip6_update_pmtu
);
2951 void ip6_sk_update_pmtu(struct sk_buff
*skb
, struct sock
*sk
, __be32 mtu
)
2953 int oif
= sk
->sk_bound_dev_if
;
2954 struct dst_entry
*dst
;
2956 if (!oif
&& skb
->dev
)
2957 oif
= l3mdev_master_ifindex(skb
->dev
);
2959 ip6_update_pmtu(skb
, sock_net(sk
), mtu
, oif
, sk
->sk_mark
, sk
->sk_uid
);
2961 dst
= __sk_dst_get(sk
);
2962 if (!dst
|| !dst
->obsolete
||
2963 dst
->ops
->check(dst
, inet6_sk(sk
)->dst_cookie
))
2967 if (!sock_owned_by_user(sk
) && !ipv6_addr_v4mapped(&sk
->sk_v6_daddr
))
2968 ip6_datagram_dst_update(sk
, false);
2971 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu
);
2973 void ip6_sk_dst_store_flow(struct sock
*sk
, struct dst_entry
*dst
,
2974 const struct flowi6
*fl6
)
2976 #ifdef CONFIG_IPV6_SUBTREES
2977 struct ipv6_pinfo
*np
= inet6_sk(sk
);
2980 ip6_dst_store(sk
, dst
,
2981 ipv6_addr_equal(&fl6
->daddr
, &sk
->sk_v6_daddr
) ?
2982 &sk
->sk_v6_daddr
: NULL
,
2983 #ifdef CONFIG_IPV6_SUBTREES
2984 ipv6_addr_equal(&fl6
->saddr
, &np
->saddr
) ?
2990 static bool ip6_redirect_nh_match(const struct fib6_result
*res
,
2992 const struct in6_addr
*gw
,
2993 struct rt6_info
**ret
)
2995 const struct fib6_nh
*nh
= res
->nh
;
2997 if (nh
->fib_nh_flags
& RTNH_F_DEAD
|| !nh
->fib_nh_gw_family
||
2998 fl6
->flowi6_oif
!= nh
->fib_nh_dev
->ifindex
)
3001 /* rt_cache's gateway might be different from its 'parent'
3002 * in the case of an ip redirect.
3003 * So we keep searching in the exception table if the gateway
3006 if (!ipv6_addr_equal(gw
, &nh
->fib_nh_gw6
)) {
3007 struct rt6_info
*rt_cache
;
3009 rt_cache
= rt6_find_cached_rt(res
, &fl6
->daddr
, &fl6
->saddr
);
3011 ipv6_addr_equal(gw
, &rt_cache
->rt6i_gateway
)) {
3020 struct fib6_nh_rd_arg
{
3021 struct fib6_result
*res
;
3023 const struct in6_addr
*gw
;
3024 struct rt6_info
**ret
;
3027 static int fib6_nh_redirect_match(struct fib6_nh
*nh
, void *_arg
)
3029 struct fib6_nh_rd_arg
*arg
= _arg
;
3032 return ip6_redirect_nh_match(arg
->res
, arg
->fl6
, arg
->gw
, arg
->ret
);
3035 /* Handle redirects */
3036 struct ip6rd_flowi
{
3038 struct in6_addr gateway
;
3041 INDIRECT_CALLABLE_SCOPE
struct rt6_info
*__ip6_route_redirect(struct net
*net
,
3042 struct fib6_table
*table
,
3044 const struct sk_buff
*skb
,
3047 struct ip6rd_flowi
*rdfl
= (struct ip6rd_flowi
*)fl6
;
3048 struct rt6_info
*ret
= NULL
;
3049 struct fib6_result res
= {};
3050 struct fib6_nh_rd_arg arg
= {
3053 .gw
= &rdfl
->gateway
,
3056 struct fib6_info
*rt
;
3057 struct fib6_node
*fn
;
3059 /* l3mdev_update_flow overrides oif if the device is enslaved; in
3060 * this case we must match on the real ingress device, so reset it
3062 if (fl6
->flowi6_flags
& FLOWI_FLAG_SKIP_NH_OIF
)
3063 fl6
->flowi6_oif
= skb
->dev
->ifindex
;
3065 /* Get the "current" route for this destination and
3066 * check if the redirect has come from appropriate router.
3068 * RFC 4861 specifies that redirects should only be
3069 * accepted if they come from the nexthop to the target.
3070 * Due to the way the routes are chosen, this notion
3071 * is a bit fuzzy and one might need to check all possible
3076 fn
= fib6_node_lookup(&table
->tb6_root
, &fl6
->daddr
, &fl6
->saddr
);
3078 for_each_fib6_node_rt_rcu(fn
) {
3080 if (fib6_check_expired(rt
))
3082 if (rt
->fib6_flags
& RTF_REJECT
)
3084 if (unlikely(rt
->nh
)) {
3085 if (nexthop_is_blackhole(rt
->nh
))
3087 /* on match, res->nh is filled in and potentially ret */
3088 if (nexthop_for_each_fib6_nh(rt
->nh
,
3089 fib6_nh_redirect_match
,
3093 res
.nh
= rt
->fib6_nh
;
3094 if (ip6_redirect_nh_match(&res
, fl6
, &rdfl
->gateway
,
3101 rt
= net
->ipv6
.fib6_null_entry
;
3102 else if (rt
->fib6_flags
& RTF_REJECT
) {
3103 ret
= net
->ipv6
.ip6_null_entry
;
3107 if (rt
== net
->ipv6
.fib6_null_entry
) {
3108 fn
= fib6_backtrack(fn
, &fl6
->saddr
);
3114 res
.nh
= rt
->fib6_nh
;
3117 ip6_hold_safe(net
, &ret
);
3119 res
.fib6_flags
= res
.f6i
->fib6_flags
;
3120 res
.fib6_type
= res
.f6i
->fib6_type
;
3121 ret
= ip6_create_rt_rcu(&res
);
3126 trace_fib6_table_lookup(net
, &res
, table
, fl6
);
3130 static struct dst_entry
*ip6_route_redirect(struct net
*net
,
3131 const struct flowi6
*fl6
,
3132 const struct sk_buff
*skb
,
3133 const struct in6_addr
*gateway
)
3135 int flags
= RT6_LOOKUP_F_HAS_SADDR
;
3136 struct ip6rd_flowi rdfl
;
3139 rdfl
.gateway
= *gateway
;
3141 return fib6_rule_lookup(net
, &rdfl
.fl6
, skb
,
3142 flags
, __ip6_route_redirect
);
3145 void ip6_redirect(struct sk_buff
*skb
, struct net
*net
, int oif
, u32 mark
,
3148 const struct ipv6hdr
*iph
= (struct ipv6hdr
*) skb
->data
;
3149 struct dst_entry
*dst
;
3150 struct flowi6 fl6
= {
3151 .flowi6_iif
= LOOPBACK_IFINDEX
,
3153 .flowi6_mark
= mark
,
3154 .daddr
= iph
->daddr
,
3155 .saddr
= iph
->saddr
,
3156 .flowlabel
= ip6_flowinfo(iph
),
3160 dst
= ip6_route_redirect(net
, &fl6
, skb
, &ipv6_hdr(skb
)->saddr
);
3161 rt6_do_redirect(dst
, NULL
, skb
);
3164 EXPORT_SYMBOL_GPL(ip6_redirect
);
3166 void ip6_redirect_no_header(struct sk_buff
*skb
, struct net
*net
, int oif
)
3168 const struct ipv6hdr
*iph
= ipv6_hdr(skb
);
3169 const struct rd_msg
*msg
= (struct rd_msg
*)icmp6_hdr(skb
);
3170 struct dst_entry
*dst
;
3171 struct flowi6 fl6
= {
3172 .flowi6_iif
= LOOPBACK_IFINDEX
,
3175 .saddr
= iph
->daddr
,
3176 .flowi6_uid
= sock_net_uid(net
, NULL
),
3179 dst
= ip6_route_redirect(net
, &fl6
, skb
, &iph
->saddr
);
3180 rt6_do_redirect(dst
, NULL
, skb
);
3184 void ip6_sk_redirect(struct sk_buff
*skb
, struct sock
*sk
)
3186 ip6_redirect(skb
, sock_net(sk
), sk
->sk_bound_dev_if
, sk
->sk_mark
,
3189 EXPORT_SYMBOL_GPL(ip6_sk_redirect
);
3191 static unsigned int ip6_default_advmss(const struct dst_entry
*dst
)
3193 struct net_device
*dev
= dst
->dev
;
3194 unsigned int mtu
= dst_mtu(dst
);
3195 struct net
*net
= dev_net(dev
);
3197 mtu
-= sizeof(struct ipv6hdr
) + sizeof(struct tcphdr
);
3199 if (mtu
< net
->ipv6
.sysctl
.ip6_rt_min_advmss
)
3200 mtu
= net
->ipv6
.sysctl
.ip6_rt_min_advmss
;
3203 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
3204 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
3205 * IPV6_MAXPLEN is also valid and means: "any MSS,
3206 * rely only on pmtu discovery"
3208 if (mtu
> IPV6_MAXPLEN
- sizeof(struct tcphdr
))
3213 INDIRECT_CALLABLE_SCOPE
unsigned int ip6_mtu(const struct dst_entry
*dst
)
3215 return ip6_dst_mtu_maybe_forward(dst
, false);
3217 EXPORT_INDIRECT_CALLABLE(ip6_mtu
);
3220 * 1. mtu on route is locked - use it
3221 * 2. mtu from nexthop exception
3222 * 3. mtu from egress device
3224 * based on ip6_dst_mtu_forward and exception logic of
3225 * rt6_find_cached_rt; called with rcu_read_lock
3227 u32
ip6_mtu_from_fib6(const struct fib6_result
*res
,
3228 const struct in6_addr
*daddr
,
3229 const struct in6_addr
*saddr
)
3231 const struct fib6_nh
*nh
= res
->nh
;
3232 struct fib6_info
*f6i
= res
->f6i
;
3233 struct inet6_dev
*idev
;
3234 struct rt6_info
*rt
;
3237 if (unlikely(fib6_metric_locked(f6i
, RTAX_MTU
))) {
3238 mtu
= f6i
->fib6_pmtu
;
3243 rt
= rt6_find_cached_rt(res
, daddr
, saddr
);
3245 mtu
= dst_metric_raw(&rt
->dst
, RTAX_MTU
);
3247 struct net_device
*dev
= nh
->fib_nh_dev
;
3250 idev
= __in6_dev_get(dev
);
3251 if (idev
&& idev
->cnf
.mtu6
> mtu
)
3252 mtu
= idev
->cnf
.mtu6
;
3255 mtu
= min_t(unsigned int, mtu
, IP6_MAX_MTU
);
3257 return mtu
- lwtunnel_headroom(nh
->fib_nh_lws
, mtu
);
3260 struct dst_entry
*icmp6_dst_alloc(struct net_device
*dev
,
3263 struct dst_entry
*dst
;
3264 struct rt6_info
*rt
;
3265 struct inet6_dev
*idev
= in6_dev_get(dev
);
3266 struct net
*net
= dev_net(dev
);
3268 if (unlikely(!idev
))
3269 return ERR_PTR(-ENODEV
);
3271 rt
= ip6_dst_alloc(net
, dev
, 0);
3272 if (unlikely(!rt
)) {
3274 dst
= ERR_PTR(-ENOMEM
);
3278 rt
->dst
.input
= ip6_input
;
3279 rt
->dst
.output
= ip6_output
;
3280 rt
->rt6i_gateway
= fl6
->daddr
;
3281 rt
->rt6i_dst
.addr
= fl6
->daddr
;
3282 rt
->rt6i_dst
.plen
= 128;
3283 rt
->rt6i_idev
= idev
;
3284 dst_metric_set(&rt
->dst
, RTAX_HOPLIMIT
, 0);
3286 /* Add this dst into uncached_list so that rt6_disable_ip() can
3287 * do proper release of the net_device
3289 rt6_uncached_list_add(rt
);
3290 atomic_inc(&net
->ipv6
.rt6_stats
->fib_rt_uncache
);
3292 dst
= xfrm_lookup(net
, &rt
->dst
, flowi6_to_flowi(fl6
), NULL
, 0);
3298 static int ip6_dst_gc(struct dst_ops
*ops
)
3300 struct net
*net
= container_of(ops
, struct net
, ipv6
.ip6_dst_ops
);
3301 int rt_min_interval
= net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
;
3302 int rt_max_size
= net
->ipv6
.sysctl
.ip6_rt_max_size
;
3303 int rt_elasticity
= net
->ipv6
.sysctl
.ip6_rt_gc_elasticity
;
3304 int rt_gc_timeout
= net
->ipv6
.sysctl
.ip6_rt_gc_timeout
;
3305 unsigned long rt_last_gc
= net
->ipv6
.ip6_rt_last_gc
;
3308 entries
= dst_entries_get_fast(ops
);
3309 if (entries
> rt_max_size
)
3310 entries
= dst_entries_get_slow(ops
);
3312 if (time_after(rt_last_gc
+ rt_min_interval
, jiffies
) &&
3313 entries
<= rt_max_size
)
3316 net
->ipv6
.ip6_rt_gc_expire
++;
3317 fib6_run_gc(net
->ipv6
.ip6_rt_gc_expire
, net
, true);
3318 entries
= dst_entries_get_slow(ops
);
3319 if (entries
< ops
->gc_thresh
)
3320 net
->ipv6
.ip6_rt_gc_expire
= rt_gc_timeout
>>1;
3322 net
->ipv6
.ip6_rt_gc_expire
-= net
->ipv6
.ip6_rt_gc_expire
>>rt_elasticity
;
3323 return entries
> rt_max_size
;
3326 static int ip6_nh_lookup_table(struct net
*net
, struct fib6_config
*cfg
,
3327 const struct in6_addr
*gw_addr
, u32 tbid
,
3328 int flags
, struct fib6_result
*res
)
3330 struct flowi6 fl6
= {
3331 .flowi6_oif
= cfg
->fc_ifindex
,
3333 .saddr
= cfg
->fc_prefsrc
,
3335 struct fib6_table
*table
;
3338 table
= fib6_get_table(net
, tbid
);
3342 if (!ipv6_addr_any(&cfg
->fc_prefsrc
))
3343 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
3345 flags
|= RT6_LOOKUP_F_IGNORE_LINKSTATE
;
3347 err
= fib6_table_lookup(net
, table
, cfg
->fc_ifindex
, &fl6
, res
, flags
);
3348 if (!err
&& res
->f6i
!= net
->ipv6
.fib6_null_entry
)
3349 fib6_select_path(net
, res
, &fl6
, cfg
->fc_ifindex
,
3350 cfg
->fc_ifindex
!= 0, NULL
, flags
);
3355 static int ip6_route_check_nh_onlink(struct net
*net
,
3356 struct fib6_config
*cfg
,
3357 const struct net_device
*dev
,
3358 struct netlink_ext_ack
*extack
)
3360 u32 tbid
= l3mdev_fib_table_rcu(dev
) ? : RT_TABLE_MAIN
;
3361 const struct in6_addr
*gw_addr
= &cfg
->fc_gateway
;
3362 struct fib6_result res
= {};
3365 err
= ip6_nh_lookup_table(net
, cfg
, gw_addr
, tbid
, 0, &res
);
3366 if (!err
&& !(res
.fib6_flags
& RTF_REJECT
) &&
3367 /* ignore match if it is the default route */
3368 !ipv6_addr_any(&res
.f6i
->fib6_dst
.addr
) &&
3369 (res
.fib6_type
!= RTN_UNICAST
|| dev
!= res
.nh
->fib_nh_dev
)) {
3370 NL_SET_ERR_MSG(extack
,
3371 "Nexthop has invalid gateway or device mismatch");
3378 static int ip6_route_check_nh(struct net
*net
,
3379 struct fib6_config
*cfg
,
3380 struct net_device
**_dev
,
3381 struct inet6_dev
**idev
)
3383 const struct in6_addr
*gw_addr
= &cfg
->fc_gateway
;
3384 struct net_device
*dev
= _dev
? *_dev
: NULL
;
3385 int flags
= RT6_LOOKUP_F_IFACE
;
3386 struct fib6_result res
= {};
3387 int err
= -EHOSTUNREACH
;
3389 if (cfg
->fc_table
) {
3390 err
= ip6_nh_lookup_table(net
, cfg
, gw_addr
,
3391 cfg
->fc_table
, flags
, &res
);
3392 /* gw_addr can not require a gateway or resolve to a reject
3393 * route. If a device is given, it must match the result.
3395 if (err
|| res
.fib6_flags
& RTF_REJECT
||
3396 res
.nh
->fib_nh_gw_family
||
3397 (dev
&& dev
!= res
.nh
->fib_nh_dev
))
3398 err
= -EHOSTUNREACH
;
3402 struct flowi6 fl6
= {
3403 .flowi6_oif
= cfg
->fc_ifindex
,
3407 err
= fib6_lookup(net
, cfg
->fc_ifindex
, &fl6
, &res
, flags
);
3408 if (err
|| res
.fib6_flags
& RTF_REJECT
||
3409 res
.nh
->fib_nh_gw_family
)
3410 err
= -EHOSTUNREACH
;
3415 fib6_select_path(net
, &res
, &fl6
, cfg
->fc_ifindex
,
3416 cfg
->fc_ifindex
!= 0, NULL
, flags
);
3421 if (dev
!= res
.nh
->fib_nh_dev
)
3422 err
= -EHOSTUNREACH
;
3424 *_dev
= dev
= res
.nh
->fib_nh_dev
;
3426 *idev
= in6_dev_get(dev
);
3432 static int ip6_validate_gw(struct net
*net
, struct fib6_config
*cfg
,
3433 struct net_device
**_dev
, struct inet6_dev
**idev
,
3434 struct netlink_ext_ack
*extack
)
3436 const struct in6_addr
*gw_addr
= &cfg
->fc_gateway
;
3437 int gwa_type
= ipv6_addr_type(gw_addr
);
3438 bool skip_dev
= gwa_type
& IPV6_ADDR_LINKLOCAL
? false : true;
3439 const struct net_device
*dev
= *_dev
;
3440 bool need_addr_check
= !dev
;
3443 /* if gw_addr is local we will fail to detect this in case
3444 * address is still TENTATIVE (DAD in progress). rt6_lookup()
3445 * will return already-added prefix route via interface that
3446 * prefix route was assigned to, which might be non-loopback.
3449 ipv6_chk_addr_and_flags(net
, gw_addr
, dev
, skip_dev
, 0, 0)) {
3450 NL_SET_ERR_MSG(extack
, "Gateway can not be a local address");
3454 if (gwa_type
!= (IPV6_ADDR_LINKLOCAL
| IPV6_ADDR_UNICAST
)) {
3455 /* IPv6 strictly inhibits using not link-local
3456 * addresses as nexthop address.
3457 * Otherwise, router will not able to send redirects.
3458 * It is very good, but in some (rare!) circumstances
3459 * (SIT, PtP, NBMA NOARP links) it is handy to allow
3460 * some exceptions. --ANK
3461 * We allow IPv4-mapped nexthops to support RFC4798-type
3464 if (!(gwa_type
& (IPV6_ADDR_UNICAST
| IPV6_ADDR_MAPPED
))) {
3465 NL_SET_ERR_MSG(extack
, "Invalid gateway address");
3471 if (cfg
->fc_flags
& RTNH_F_ONLINK
)
3472 err
= ip6_route_check_nh_onlink(net
, cfg
, dev
, extack
);
3474 err
= ip6_route_check_nh(net
, cfg
, _dev
, idev
);
3482 /* reload in case device was changed */
3487 NL_SET_ERR_MSG(extack
, "Egress device not specified");
3489 } else if (dev
->flags
& IFF_LOOPBACK
) {
3490 NL_SET_ERR_MSG(extack
,
3491 "Egress device can not be loopback device for this route");
3495 /* if we did not check gw_addr above, do so now that the
3496 * egress device has been resolved.
3498 if (need_addr_check
&&
3499 ipv6_chk_addr_and_flags(net
, gw_addr
, dev
, skip_dev
, 0, 0)) {
3500 NL_SET_ERR_MSG(extack
, "Gateway can not be a local address");
3509 static bool fib6_is_reject(u32 flags
, struct net_device
*dev
, int addr_type
)
3511 if ((flags
& RTF_REJECT
) ||
3512 (dev
&& (dev
->flags
& IFF_LOOPBACK
) &&
3513 !(addr_type
& IPV6_ADDR_LOOPBACK
) &&
3514 !(flags
& (RTF_ANYCAST
| RTF_LOCAL
))))
3520 int fib6_nh_init(struct net
*net
, struct fib6_nh
*fib6_nh
,
3521 struct fib6_config
*cfg
, gfp_t gfp_flags
,
3522 struct netlink_ext_ack
*extack
)
3524 struct net_device
*dev
= NULL
;
3525 struct inet6_dev
*idev
= NULL
;
3529 fib6_nh
->fib_nh_family
= AF_INET6
;
3530 #ifdef CONFIG_IPV6_ROUTER_PREF
3531 fib6_nh
->last_probe
= jiffies
;
3533 if (cfg
->fc_is_fdb
) {
3534 fib6_nh
->fib_nh_gw6
= cfg
->fc_gateway
;
3535 fib6_nh
->fib_nh_gw_family
= AF_INET6
;
3540 if (cfg
->fc_ifindex
) {
3541 dev
= dev_get_by_index(net
, cfg
->fc_ifindex
);
3544 idev
= in6_dev_get(dev
);
3549 if (cfg
->fc_flags
& RTNH_F_ONLINK
) {
3551 NL_SET_ERR_MSG(extack
,
3552 "Nexthop device required for onlink");
3556 if (!(dev
->flags
& IFF_UP
)) {
3557 NL_SET_ERR_MSG(extack
, "Nexthop device is not up");
3562 fib6_nh
->fib_nh_flags
|= RTNH_F_ONLINK
;
3565 fib6_nh
->fib_nh_weight
= 1;
3567 /* We cannot add true routes via loopback here,
3568 * they would result in kernel looping; promote them to reject routes
3570 addr_type
= ipv6_addr_type(&cfg
->fc_dst
);
3571 if (fib6_is_reject(cfg
->fc_flags
, dev
, addr_type
)) {
3572 /* hold loopback dev/idev if we haven't done so. */
3573 if (dev
!= net
->loopback_dev
) {
3578 dev
= net
->loopback_dev
;
3580 idev
= in6_dev_get(dev
);
3589 if (cfg
->fc_flags
& RTF_GATEWAY
) {
3590 err
= ip6_validate_gw(net
, cfg
, &dev
, &idev
, extack
);
3594 fib6_nh
->fib_nh_gw6
= cfg
->fc_gateway
;
3595 fib6_nh
->fib_nh_gw_family
= AF_INET6
;
3602 if (idev
->cnf
.disable_ipv6
) {
3603 NL_SET_ERR_MSG(extack
, "IPv6 is disabled on nexthop device");
3608 if (!(dev
->flags
& IFF_UP
) && !cfg
->fc_ignore_dev_down
) {
3609 NL_SET_ERR_MSG(extack
, "Nexthop device is not up");
3614 if (!(cfg
->fc_flags
& (RTF_LOCAL
| RTF_ANYCAST
)) &&
3615 !netif_carrier_ok(dev
))
3616 fib6_nh
->fib_nh_flags
|= RTNH_F_LINKDOWN
;
3618 err
= fib_nh_common_init(net
, &fib6_nh
->nh_common
, cfg
->fc_encap
,
3619 cfg
->fc_encap_type
, cfg
, gfp_flags
, extack
);
3624 fib6_nh
->rt6i_pcpu
= alloc_percpu_gfp(struct rt6_info
*, gfp_flags
);
3625 if (!fib6_nh
->rt6i_pcpu
) {
3630 fib6_nh
->fib_nh_dev
= dev
;
3631 fib6_nh
->fib_nh_oif
= dev
->ifindex
;
3638 lwtstate_put(fib6_nh
->fib_nh_lws
);
3639 fib6_nh
->fib_nh_lws
= NULL
;
3646 void fib6_nh_release(struct fib6_nh
*fib6_nh
)
3648 struct rt6_exception_bucket
*bucket
;
3652 fib6_nh_flush_exceptions(fib6_nh
, NULL
);
3653 bucket
= fib6_nh_get_excptn_bucket(fib6_nh
, NULL
);
3655 rcu_assign_pointer(fib6_nh
->rt6i_exception_bucket
, NULL
);
3661 if (fib6_nh
->rt6i_pcpu
) {
3664 for_each_possible_cpu(cpu
) {
3665 struct rt6_info
**ppcpu_rt
;
3666 struct rt6_info
*pcpu_rt
;
3668 ppcpu_rt
= per_cpu_ptr(fib6_nh
->rt6i_pcpu
, cpu
);
3669 pcpu_rt
= *ppcpu_rt
;
3671 dst_dev_put(&pcpu_rt
->dst
);
3672 dst_release(&pcpu_rt
->dst
);
3677 free_percpu(fib6_nh
->rt6i_pcpu
);
3680 fib_nh_common_release(&fib6_nh
->nh_common
);
3683 void fib6_nh_release_dsts(struct fib6_nh
*fib6_nh
)
3687 if (!fib6_nh
->rt6i_pcpu
)
3690 for_each_possible_cpu(cpu
) {
3691 struct rt6_info
*pcpu_rt
, **ppcpu_rt
;
3693 ppcpu_rt
= per_cpu_ptr(fib6_nh
->rt6i_pcpu
, cpu
);
3694 pcpu_rt
= xchg(ppcpu_rt
, NULL
);
3696 dst_dev_put(&pcpu_rt
->dst
);
3697 dst_release(&pcpu_rt
->dst
);
3702 static struct fib6_info
*ip6_route_info_create(struct fib6_config
*cfg
,
3704 struct netlink_ext_ack
*extack
)
3706 struct net
*net
= cfg
->fc_nlinfo
.nl_net
;
3707 struct fib6_info
*rt
= NULL
;
3708 struct nexthop
*nh
= NULL
;
3709 struct fib6_table
*table
;
3710 struct fib6_nh
*fib6_nh
;
3714 /* RTF_PCPU is an internal flag; can not be set by userspace */
3715 if (cfg
->fc_flags
& RTF_PCPU
) {
3716 NL_SET_ERR_MSG(extack
, "Userspace can not set RTF_PCPU");
3720 /* RTF_CACHE is an internal flag; can not be set by userspace */
3721 if (cfg
->fc_flags
& RTF_CACHE
) {
3722 NL_SET_ERR_MSG(extack
, "Userspace can not set RTF_CACHE");
3726 if (cfg
->fc_type
> RTN_MAX
) {
3727 NL_SET_ERR_MSG(extack
, "Invalid route type");
3731 if (cfg
->fc_dst_len
> 128) {
3732 NL_SET_ERR_MSG(extack
, "Invalid prefix length");
3735 if (cfg
->fc_src_len
> 128) {
3736 NL_SET_ERR_MSG(extack
, "Invalid source address length");
3739 #ifndef CONFIG_IPV6_SUBTREES
3740 if (cfg
->fc_src_len
) {
3741 NL_SET_ERR_MSG(extack
,
3742 "Specifying source address requires IPV6_SUBTREES to be enabled");
3746 if (cfg
->fc_nh_id
) {
3747 nh
= nexthop_find_by_id(net
, cfg
->fc_nh_id
);
3749 NL_SET_ERR_MSG(extack
, "Nexthop id does not exist");
3752 err
= fib6_check_nexthop(nh
, cfg
, extack
);
3758 if (cfg
->fc_nlinfo
.nlh
&&
3759 !(cfg
->fc_nlinfo
.nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
3760 table
= fib6_get_table(net
, cfg
->fc_table
);
3762 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
3763 table
= fib6_new_table(net
, cfg
->fc_table
);
3766 table
= fib6_new_table(net
, cfg
->fc_table
);
3773 rt
= fib6_info_alloc(gfp_flags
, !nh
);
3777 rt
->fib6_metrics
= ip_fib_metrics_init(net
, cfg
->fc_mx
, cfg
->fc_mx_len
,
3779 if (IS_ERR(rt
->fib6_metrics
)) {
3780 err
= PTR_ERR(rt
->fib6_metrics
);
3781 /* Do not leave garbage there. */
3782 rt
->fib6_metrics
= (struct dst_metrics
*)&dst_default_metrics
;
3786 if (cfg
->fc_flags
& RTF_ADDRCONF
)
3787 rt
->dst_nocount
= true;
3789 if (cfg
->fc_flags
& RTF_EXPIRES
)
3790 fib6_set_expires(rt
, jiffies
+
3791 clock_t_to_jiffies(cfg
->fc_expires
));
3793 fib6_clean_expires(rt
);
3795 if (cfg
->fc_protocol
== RTPROT_UNSPEC
)
3796 cfg
->fc_protocol
= RTPROT_BOOT
;
3797 rt
->fib6_protocol
= cfg
->fc_protocol
;
3799 rt
->fib6_table
= table
;
3800 rt
->fib6_metric
= cfg
->fc_metric
;
3801 rt
->fib6_type
= cfg
->fc_type
? : RTN_UNICAST
;
3802 rt
->fib6_flags
= cfg
->fc_flags
& ~RTF_GATEWAY
;
3804 ipv6_addr_prefix(&rt
->fib6_dst
.addr
, &cfg
->fc_dst
, cfg
->fc_dst_len
);
3805 rt
->fib6_dst
.plen
= cfg
->fc_dst_len
;
3807 #ifdef CONFIG_IPV6_SUBTREES
3808 ipv6_addr_prefix(&rt
->fib6_src
.addr
, &cfg
->fc_src
, cfg
->fc_src_len
);
3809 rt
->fib6_src
.plen
= cfg
->fc_src_len
;
3812 if (rt
->fib6_src
.plen
) {
3813 NL_SET_ERR_MSG(extack
, "Nexthops can not be used with source routing");
3816 if (!nexthop_get(nh
)) {
3817 NL_SET_ERR_MSG(extack
, "Nexthop has been deleted");
3821 fib6_nh
= nexthop_fib6_nh(rt
->nh
);
3823 err
= fib6_nh_init(net
, rt
->fib6_nh
, cfg
, gfp_flags
, extack
);
3827 fib6_nh
= rt
->fib6_nh
;
3829 /* We cannot add true routes via loopback here, they would
3830 * result in kernel looping; promote them to reject routes
3832 addr_type
= ipv6_addr_type(&cfg
->fc_dst
);
3833 if (fib6_is_reject(cfg
->fc_flags
, rt
->fib6_nh
->fib_nh_dev
,
3835 rt
->fib6_flags
= RTF_REJECT
| RTF_NONEXTHOP
;
3838 if (!ipv6_addr_any(&cfg
->fc_prefsrc
)) {
3839 struct net_device
*dev
= fib6_nh
->fib_nh_dev
;
3841 if (!ipv6_chk_addr(net
, &cfg
->fc_prefsrc
, dev
, 0)) {
3842 NL_SET_ERR_MSG(extack
, "Invalid source address");
3846 rt
->fib6_prefsrc
.addr
= cfg
->fc_prefsrc
;
3847 rt
->fib6_prefsrc
.plen
= 128;
3849 rt
->fib6_prefsrc
.plen
= 0;
3853 fib6_info_release(rt
);
3854 return ERR_PTR(err
);
3856 ip_fib_metrics_put(rt
->fib6_metrics
);
3858 return ERR_PTR(err
);
3861 int ip6_route_add(struct fib6_config
*cfg
, gfp_t gfp_flags
,
3862 struct netlink_ext_ack
*extack
)
3864 struct fib6_info
*rt
;
3867 rt
= ip6_route_info_create(cfg
, gfp_flags
, extack
);
3871 err
= __ip6_ins_rt(rt
, &cfg
->fc_nlinfo
, extack
);
3872 fib6_info_release(rt
);
3877 static int __ip6_del_rt(struct fib6_info
*rt
, struct nl_info
*info
)
3879 struct net
*net
= info
->nl_net
;
3880 struct fib6_table
*table
;
3883 if (rt
== net
->ipv6
.fib6_null_entry
) {
3888 table
= rt
->fib6_table
;
3889 spin_lock_bh(&table
->tb6_lock
);
3890 err
= fib6_del(rt
, info
);
3891 spin_unlock_bh(&table
->tb6_lock
);
3894 fib6_info_release(rt
);
3898 int ip6_del_rt(struct net
*net
, struct fib6_info
*rt
, bool skip_notify
)
3900 struct nl_info info
= {
3902 .skip_notify
= skip_notify
3905 return __ip6_del_rt(rt
, &info
);
3908 static int __ip6_del_rt_siblings(struct fib6_info
*rt
, struct fib6_config
*cfg
)
3910 struct nl_info
*info
= &cfg
->fc_nlinfo
;
3911 struct net
*net
= info
->nl_net
;
3912 struct sk_buff
*skb
= NULL
;
3913 struct fib6_table
*table
;
3916 if (rt
== net
->ipv6
.fib6_null_entry
)
3918 table
= rt
->fib6_table
;
3919 spin_lock_bh(&table
->tb6_lock
);
3921 if (rt
->fib6_nsiblings
&& cfg
->fc_delete_all_nh
) {
3922 struct fib6_info
*sibling
, *next_sibling
;
3923 struct fib6_node
*fn
;
3925 /* prefer to send a single notification with all hops */
3926 skb
= nlmsg_new(rt6_nlmsg_size(rt
), gfp_any());
3928 u32 seq
= info
->nlh
? info
->nlh
->nlmsg_seq
: 0;
3930 if (rt6_fill_node(net
, skb
, rt
, NULL
,
3931 NULL
, NULL
, 0, RTM_DELROUTE
,
3932 info
->portid
, seq
, 0) < 0) {
3936 info
->skip_notify
= 1;
3939 /* 'rt' points to the first sibling route. If it is not the
3940 * leaf, then we do not need to send a notification. Otherwise,
3941 * we need to check if the last sibling has a next route or not
3942 * and emit a replace or delete notification, respectively.
3944 info
->skip_notify_kernel
= 1;
3945 fn
= rcu_dereference_protected(rt
->fib6_node
,
3946 lockdep_is_held(&table
->tb6_lock
));
3947 if (rcu_access_pointer(fn
->leaf
) == rt
) {
3948 struct fib6_info
*last_sibling
, *replace_rt
;
3950 last_sibling
= list_last_entry(&rt
->fib6_siblings
,
3953 replace_rt
= rcu_dereference_protected(
3954 last_sibling
->fib6_next
,
3955 lockdep_is_held(&table
->tb6_lock
));
3957 call_fib6_entry_notifiers_replace(net
,
3960 call_fib6_multipath_entry_notifiers(net
,
3961 FIB_EVENT_ENTRY_DEL
,
3962 rt
, rt
->fib6_nsiblings
,
3965 list_for_each_entry_safe(sibling
, next_sibling
,
3968 err
= fib6_del(sibling
, info
);
3974 err
= fib6_del(rt
, info
);
3976 spin_unlock_bh(&table
->tb6_lock
);
3978 fib6_info_release(rt
);
3981 rtnl_notify(skb
, net
, info
->portid
, RTNLGRP_IPV6_ROUTE
,
3982 info
->nlh
, gfp_any());
3987 static int __ip6_del_cached_rt(struct rt6_info
*rt
, struct fib6_config
*cfg
)
3991 if (cfg
->fc_ifindex
&& rt
->dst
.dev
->ifindex
!= cfg
->fc_ifindex
)
3994 if (cfg
->fc_flags
& RTF_GATEWAY
&&
3995 !ipv6_addr_equal(&cfg
->fc_gateway
, &rt
->rt6i_gateway
))
3998 rc
= rt6_remove_exception_rt(rt
);
4003 static int ip6_del_cached_rt(struct fib6_config
*cfg
, struct fib6_info
*rt
,
4006 struct fib6_result res
= {
4010 struct rt6_info
*rt_cache
;
4012 rt_cache
= rt6_find_cached_rt(&res
, &cfg
->fc_dst
, &cfg
->fc_src
);
4014 return __ip6_del_cached_rt(rt_cache
, cfg
);
4019 struct fib6_nh_del_cached_rt_arg
{
4020 struct fib6_config
*cfg
;
4021 struct fib6_info
*f6i
;
4024 static int fib6_nh_del_cached_rt(struct fib6_nh
*nh
, void *_arg
)
4026 struct fib6_nh_del_cached_rt_arg
*arg
= _arg
;
4029 rc
= ip6_del_cached_rt(arg
->cfg
, arg
->f6i
, nh
);
4030 return rc
!= -ESRCH
? rc
: 0;
4033 static int ip6_del_cached_rt_nh(struct fib6_config
*cfg
, struct fib6_info
*f6i
)
4035 struct fib6_nh_del_cached_rt_arg arg
= {
4040 return nexthop_for_each_fib6_nh(f6i
->nh
, fib6_nh_del_cached_rt
, &arg
);
4043 static int ip6_route_del(struct fib6_config
*cfg
,
4044 struct netlink_ext_ack
*extack
)
4046 struct fib6_table
*table
;
4047 struct fib6_info
*rt
;
4048 struct fib6_node
*fn
;
4051 table
= fib6_get_table(cfg
->fc_nlinfo
.nl_net
, cfg
->fc_table
);
4053 NL_SET_ERR_MSG(extack
, "FIB table does not exist");
4059 fn
= fib6_locate(&table
->tb6_root
,
4060 &cfg
->fc_dst
, cfg
->fc_dst_len
,
4061 &cfg
->fc_src
, cfg
->fc_src_len
,
4062 !(cfg
->fc_flags
& RTF_CACHE
));
4065 for_each_fib6_node_rt_rcu(fn
) {
4068 if (rt
->nh
&& cfg
->fc_nh_id
&&
4069 rt
->nh
->id
!= cfg
->fc_nh_id
)
4072 if (cfg
->fc_flags
& RTF_CACHE
) {
4076 rc
= ip6_del_cached_rt_nh(cfg
, rt
);
4077 } else if (cfg
->fc_nh_id
) {
4081 rc
= ip6_del_cached_rt(cfg
, rt
, nh
);
4090 if (cfg
->fc_metric
&& cfg
->fc_metric
!= rt
->fib6_metric
)
4092 if (cfg
->fc_protocol
&&
4093 cfg
->fc_protocol
!= rt
->fib6_protocol
)
4097 if (!fib6_info_hold_safe(rt
))
4101 return __ip6_del_rt(rt
, &cfg
->fc_nlinfo
);
4107 if (cfg
->fc_ifindex
&&
4109 nh
->fib_nh_dev
->ifindex
!= cfg
->fc_ifindex
))
4111 if (cfg
->fc_flags
& RTF_GATEWAY
&&
4112 !ipv6_addr_equal(&cfg
->fc_gateway
, &nh
->fib_nh_gw6
))
4114 if (!fib6_info_hold_safe(rt
))
4118 /* if gateway was specified only delete the one hop */
4119 if (cfg
->fc_flags
& RTF_GATEWAY
)
4120 return __ip6_del_rt(rt
, &cfg
->fc_nlinfo
);
4122 return __ip6_del_rt_siblings(rt
, cfg
);
4130 static void rt6_do_redirect(struct dst_entry
*dst
, struct sock
*sk
, struct sk_buff
*skb
)
4132 struct netevent_redirect netevent
;
4133 struct rt6_info
*rt
, *nrt
= NULL
;
4134 struct fib6_result res
= {};
4135 struct ndisc_options ndopts
;
4136 struct inet6_dev
*in6_dev
;
4137 struct neighbour
*neigh
;
4139 int optlen
, on_link
;
4142 optlen
= skb_tail_pointer(skb
) - skb_transport_header(skb
);
4143 optlen
-= sizeof(*msg
);
4146 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
4150 msg
= (struct rd_msg
*)icmp6_hdr(skb
);
4152 if (ipv6_addr_is_multicast(&msg
->dest
)) {
4153 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
4158 if (ipv6_addr_equal(&msg
->dest
, &msg
->target
)) {
4160 } else if (ipv6_addr_type(&msg
->target
) !=
4161 (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
4162 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
4166 in6_dev
= __in6_dev_get(skb
->dev
);
4169 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
)
4173 * The IP source address of the Redirect MUST be the same as the current
4174 * first-hop router for the specified ICMP Destination Address.
4177 if (!ndisc_parse_options(skb
->dev
, msg
->opt
, optlen
, &ndopts
)) {
4178 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
4183 if (ndopts
.nd_opts_tgt_lladdr
) {
4184 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
4187 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
4192 rt
= (struct rt6_info
*) dst
;
4193 if (rt
->rt6i_flags
& RTF_REJECT
) {
4194 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
4198 /* Redirect received -> path was valid.
4199 * Look, redirects are sent only in response to data packets,
4200 * so that this nexthop apparently is reachable. --ANK
4202 dst_confirm_neigh(&rt
->dst
, &ipv6_hdr(skb
)->saddr
);
4204 neigh
= __neigh_lookup(&nd_tbl
, &msg
->target
, skb
->dev
, 1);
4209 * We have finally decided to accept it.
4212 ndisc_update(skb
->dev
, neigh
, lladdr
, NUD_STALE
,
4213 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
4214 NEIGH_UPDATE_F_OVERRIDE
|
4215 (on_link
? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
4216 NEIGH_UPDATE_F_ISROUTER
)),
4217 NDISC_REDIRECT
, &ndopts
);
4220 res
.f6i
= rcu_dereference(rt
->from
);
4225 struct fib6_nh_match_arg arg
= {
4227 .gw
= &rt
->rt6i_gateway
,
4230 nexthop_for_each_fib6_nh(res
.f6i
->nh
,
4231 fib6_nh_find_match
, &arg
);
4233 /* fib6_info uses a nexthop that does not have fib6_nh
4234 * using the dst->dev. Should be impossible
4240 res
.nh
= res
.f6i
->fib6_nh
;
4243 res
.fib6_flags
= res
.f6i
->fib6_flags
;
4244 res
.fib6_type
= res
.f6i
->fib6_type
;
4245 nrt
= ip6_rt_cache_alloc(&res
, &msg
->dest
, NULL
);
4249 nrt
->rt6i_flags
= RTF_GATEWAY
|RTF_UP
|RTF_DYNAMIC
|RTF_CACHE
;
4251 nrt
->rt6i_flags
&= ~RTF_GATEWAY
;
4253 nrt
->rt6i_gateway
= *(struct in6_addr
*)neigh
->primary_key
;
4255 /* rt6_insert_exception() will take care of duplicated exceptions */
4256 if (rt6_insert_exception(nrt
, &res
)) {
4257 dst_release_immediate(&nrt
->dst
);
4261 netevent
.old
= &rt
->dst
;
4262 netevent
.new = &nrt
->dst
;
4263 netevent
.daddr
= &msg
->dest
;
4264 netevent
.neigh
= neigh
;
4265 call_netevent_notifiers(NETEVENT_REDIRECT
, &netevent
);
4269 neigh_release(neigh
);
4272 #ifdef CONFIG_IPV6_ROUTE_INFO
4273 static struct fib6_info
*rt6_get_route_info(struct net
*net
,
4274 const struct in6_addr
*prefix
, int prefixlen
,
4275 const struct in6_addr
*gwaddr
,
4276 struct net_device
*dev
)
4278 u32 tb_id
= l3mdev_fib_table(dev
) ? : RT6_TABLE_INFO
;
4279 int ifindex
= dev
->ifindex
;
4280 struct fib6_node
*fn
;
4281 struct fib6_info
*rt
= NULL
;
4282 struct fib6_table
*table
;
4284 table
= fib6_get_table(net
, tb_id
);
4289 fn
= fib6_locate(&table
->tb6_root
, prefix
, prefixlen
, NULL
, 0, true);
4293 for_each_fib6_node_rt_rcu(fn
) {
4294 /* these routes do not use nexthops */
4297 if (rt
->fib6_nh
->fib_nh_dev
->ifindex
!= ifindex
)
4299 if (!(rt
->fib6_flags
& RTF_ROUTEINFO
) ||
4300 !rt
->fib6_nh
->fib_nh_gw_family
)
4302 if (!ipv6_addr_equal(&rt
->fib6_nh
->fib_nh_gw6
, gwaddr
))
4304 if (!fib6_info_hold_safe(rt
))
4313 static struct fib6_info
*rt6_add_route_info(struct net
*net
,
4314 const struct in6_addr
*prefix
, int prefixlen
,
4315 const struct in6_addr
*gwaddr
,
4316 struct net_device
*dev
,
4319 struct fib6_config cfg
= {
4320 .fc_metric
= IP6_RT_PRIO_USER
,
4321 .fc_ifindex
= dev
->ifindex
,
4322 .fc_dst_len
= prefixlen
,
4323 .fc_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_ROUTEINFO
|
4324 RTF_UP
| RTF_PREF(pref
),
4325 .fc_protocol
= RTPROT_RA
,
4326 .fc_type
= RTN_UNICAST
,
4327 .fc_nlinfo
.portid
= 0,
4328 .fc_nlinfo
.nlh
= NULL
,
4329 .fc_nlinfo
.nl_net
= net
,
4332 cfg
.fc_table
= l3mdev_fib_table(dev
) ? : RT6_TABLE_INFO
;
4333 cfg
.fc_dst
= *prefix
;
4334 cfg
.fc_gateway
= *gwaddr
;
4336 /* We should treat it as a default route if prefix length is 0. */
4338 cfg
.fc_flags
|= RTF_DEFAULT
;
4340 ip6_route_add(&cfg
, GFP_ATOMIC
, NULL
);
4342 return rt6_get_route_info(net
, prefix
, prefixlen
, gwaddr
, dev
);
4346 struct fib6_info
*rt6_get_dflt_router(struct net
*net
,
4347 const struct in6_addr
*addr
,
4348 struct net_device
*dev
)
4350 u32 tb_id
= l3mdev_fib_table(dev
) ? : RT6_TABLE_DFLT
;
4351 struct fib6_info
*rt
;
4352 struct fib6_table
*table
;
4354 table
= fib6_get_table(net
, tb_id
);
4359 for_each_fib6_node_rt_rcu(&table
->tb6_root
) {
4362 /* RA routes do not use nexthops */
4367 if (dev
== nh
->fib_nh_dev
&&
4368 ((rt
->fib6_flags
& (RTF_ADDRCONF
| RTF_DEFAULT
)) == (RTF_ADDRCONF
| RTF_DEFAULT
)) &&
4369 ipv6_addr_equal(&nh
->fib_nh_gw6
, addr
))
4372 if (rt
&& !fib6_info_hold_safe(rt
))
4378 struct fib6_info
*rt6_add_dflt_router(struct net
*net
,
4379 const struct in6_addr
*gwaddr
,
4380 struct net_device
*dev
,
4382 u32 defrtr_usr_metric
)
4384 struct fib6_config cfg
= {
4385 .fc_table
= l3mdev_fib_table(dev
) ? : RT6_TABLE_DFLT
,
4386 .fc_metric
= defrtr_usr_metric
,
4387 .fc_ifindex
= dev
->ifindex
,
4388 .fc_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_DEFAULT
|
4389 RTF_UP
| RTF_EXPIRES
| RTF_PREF(pref
),
4390 .fc_protocol
= RTPROT_RA
,
4391 .fc_type
= RTN_UNICAST
,
4392 .fc_nlinfo
.portid
= 0,
4393 .fc_nlinfo
.nlh
= NULL
,
4394 .fc_nlinfo
.nl_net
= net
,
4397 cfg
.fc_gateway
= *gwaddr
;
4399 if (!ip6_route_add(&cfg
, GFP_ATOMIC
, NULL
)) {
4400 struct fib6_table
*table
;
4402 table
= fib6_get_table(dev_net(dev
), cfg
.fc_table
);
4404 table
->flags
|= RT6_TABLE_HAS_DFLT_ROUTER
;
4407 return rt6_get_dflt_router(net
, gwaddr
, dev
);
4410 static void __rt6_purge_dflt_routers(struct net
*net
,
4411 struct fib6_table
*table
)
4413 struct fib6_info
*rt
;
4417 for_each_fib6_node_rt_rcu(&table
->tb6_root
) {
4418 struct net_device
*dev
= fib6_info_nh_dev(rt
);
4419 struct inet6_dev
*idev
= dev
? __in6_dev_get(dev
) : NULL
;
4421 if (rt
->fib6_flags
& (RTF_DEFAULT
| RTF_ADDRCONF
) &&
4422 (!idev
|| idev
->cnf
.accept_ra
!= 2) &&
4423 fib6_info_hold_safe(rt
)) {
4425 ip6_del_rt(net
, rt
, false);
4431 table
->flags
&= ~RT6_TABLE_HAS_DFLT_ROUTER
;
4434 void rt6_purge_dflt_routers(struct net
*net
)
4436 struct fib6_table
*table
;
4437 struct hlist_head
*head
;
4442 for (h
= 0; h
< FIB6_TABLE_HASHSZ
; h
++) {
4443 head
= &net
->ipv6
.fib_table_hash
[h
];
4444 hlist_for_each_entry_rcu(table
, head
, tb6_hlist
) {
4445 if (table
->flags
& RT6_TABLE_HAS_DFLT_ROUTER
)
4446 __rt6_purge_dflt_routers(net
, table
);
4453 static void rtmsg_to_fib6_config(struct net
*net
,
4454 struct in6_rtmsg
*rtmsg
,
4455 struct fib6_config
*cfg
)
4457 *cfg
= (struct fib6_config
){
4458 .fc_table
= l3mdev_fib_table_by_index(net
, rtmsg
->rtmsg_ifindex
) ?
4460 .fc_ifindex
= rtmsg
->rtmsg_ifindex
,
4461 .fc_metric
= rtmsg
->rtmsg_metric
? : IP6_RT_PRIO_USER
,
4462 .fc_expires
= rtmsg
->rtmsg_info
,
4463 .fc_dst_len
= rtmsg
->rtmsg_dst_len
,
4464 .fc_src_len
= rtmsg
->rtmsg_src_len
,
4465 .fc_flags
= rtmsg
->rtmsg_flags
,
4466 .fc_type
= rtmsg
->rtmsg_type
,
4468 .fc_nlinfo
.nl_net
= net
,
4470 .fc_dst
= rtmsg
->rtmsg_dst
,
4471 .fc_src
= rtmsg
->rtmsg_src
,
4472 .fc_gateway
= rtmsg
->rtmsg_gateway
,
4476 int ipv6_route_ioctl(struct net
*net
, unsigned int cmd
, struct in6_rtmsg
*rtmsg
)
4478 struct fib6_config cfg
;
4481 if (cmd
!= SIOCADDRT
&& cmd
!= SIOCDELRT
)
4483 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
4486 rtmsg_to_fib6_config(net
, rtmsg
, &cfg
);
4491 err
= ip6_route_add(&cfg
, GFP_KERNEL
, NULL
);
4494 err
= ip6_route_del(&cfg
, NULL
);
4502 * Drop the packet on the floor
4505 static int ip6_pkt_drop(struct sk_buff
*skb
, u8 code
, int ipstats_mib_noroutes
)
4507 struct dst_entry
*dst
= skb_dst(skb
);
4508 struct net
*net
= dev_net(dst
->dev
);
4509 struct inet6_dev
*idev
;
4512 if (netif_is_l3_master(skb
->dev
) &&
4513 dst
->dev
== net
->loopback_dev
)
4514 idev
= __in6_dev_get_safely(dev_get_by_index_rcu(net
, IP6CB(skb
)->iif
));
4516 idev
= ip6_dst_idev(dst
);
4518 switch (ipstats_mib_noroutes
) {
4519 case IPSTATS_MIB_INNOROUTES
:
4520 type
= ipv6_addr_type(&ipv6_hdr(skb
)->daddr
);
4521 if (type
== IPV6_ADDR_ANY
) {
4522 IP6_INC_STATS(net
, idev
, IPSTATS_MIB_INADDRERRORS
);
4526 case IPSTATS_MIB_OUTNOROUTES
:
4527 IP6_INC_STATS(net
, idev
, ipstats_mib_noroutes
);
4531 /* Start over by dropping the dst for l3mdev case */
4532 if (netif_is_l3_master(skb
->dev
))
4535 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, code
, 0);
4540 static int ip6_pkt_discard(struct sk_buff
*skb
)
4542 return ip6_pkt_drop(skb
, ICMPV6_NOROUTE
, IPSTATS_MIB_INNOROUTES
);
4545 static int ip6_pkt_discard_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
)
4547 skb
->dev
= skb_dst(skb
)->dev
;
4548 return ip6_pkt_drop(skb
, ICMPV6_NOROUTE
, IPSTATS_MIB_OUTNOROUTES
);
4551 static int ip6_pkt_prohibit(struct sk_buff
*skb
)
4553 return ip6_pkt_drop(skb
, ICMPV6_ADM_PROHIBITED
, IPSTATS_MIB_INNOROUTES
);
4556 static int ip6_pkt_prohibit_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
)
4558 skb
->dev
= skb_dst(skb
)->dev
;
4559 return ip6_pkt_drop(skb
, ICMPV6_ADM_PROHIBITED
, IPSTATS_MIB_OUTNOROUTES
);
4563 * Allocate a dst for local (unicast / anycast) address.
4566 struct fib6_info
*addrconf_f6i_alloc(struct net
*net
,
4567 struct inet6_dev
*idev
,
4568 const struct in6_addr
*addr
,
4569 bool anycast
, gfp_t gfp_flags
)
4571 struct fib6_config cfg
= {
4572 .fc_table
= l3mdev_fib_table(idev
->dev
) ? : RT6_TABLE_LOCAL
,
4573 .fc_ifindex
= idev
->dev
->ifindex
,
4574 .fc_flags
= RTF_UP
| RTF_NONEXTHOP
,
4577 .fc_protocol
= RTPROT_KERNEL
,
4578 .fc_nlinfo
.nl_net
= net
,
4579 .fc_ignore_dev_down
= true,
4581 struct fib6_info
*f6i
;
4584 cfg
.fc_type
= RTN_ANYCAST
;
4585 cfg
.fc_flags
|= RTF_ANYCAST
;
4587 cfg
.fc_type
= RTN_LOCAL
;
4588 cfg
.fc_flags
|= RTF_LOCAL
;
4591 f6i
= ip6_route_info_create(&cfg
, gfp_flags
, NULL
);
4593 f6i
->dst_nocount
= true;
4597 /* remove deleted ip from prefsrc entries */
4598 struct arg_dev_net_ip
{
4599 struct net_device
*dev
;
4601 struct in6_addr
*addr
;
4604 static int fib6_remove_prefsrc(struct fib6_info
*rt
, void *arg
)
4606 struct net_device
*dev
= ((struct arg_dev_net_ip
*)arg
)->dev
;
4607 struct net
*net
= ((struct arg_dev_net_ip
*)arg
)->net
;
4608 struct in6_addr
*addr
= ((struct arg_dev_net_ip
*)arg
)->addr
;
4611 ((void *)rt
->fib6_nh
->fib_nh_dev
== dev
|| !dev
) &&
4612 rt
!= net
->ipv6
.fib6_null_entry
&&
4613 ipv6_addr_equal(addr
, &rt
->fib6_prefsrc
.addr
)) {
4614 spin_lock_bh(&rt6_exception_lock
);
4615 /* remove prefsrc entry */
4616 rt
->fib6_prefsrc
.plen
= 0;
4617 spin_unlock_bh(&rt6_exception_lock
);
4622 void rt6_remove_prefsrc(struct inet6_ifaddr
*ifp
)
4624 struct net
*net
= dev_net(ifp
->idev
->dev
);
4625 struct arg_dev_net_ip adni
= {
4626 .dev
= ifp
->idev
->dev
,
4630 fib6_clean_all(net
, fib6_remove_prefsrc
, &adni
);
4633 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT)
4635 /* Remove routers and update dst entries when gateway turn into host. */
4636 static int fib6_clean_tohost(struct fib6_info
*rt
, void *arg
)
4638 struct in6_addr
*gateway
= (struct in6_addr
*)arg
;
4641 /* RA routes do not use nexthops */
4646 if (((rt
->fib6_flags
& RTF_RA_ROUTER
) == RTF_RA_ROUTER
) &&
4647 nh
->fib_nh_gw_family
&& ipv6_addr_equal(gateway
, &nh
->fib_nh_gw6
))
4650 /* Further clean up cached routes in exception table.
4651 * This is needed because cached route may have a different
4652 * gateway than its 'parent' in the case of an ip redirect.
4654 fib6_nh_exceptions_clean_tohost(nh
, gateway
);
4659 void rt6_clean_tohost(struct net
*net
, struct in6_addr
*gateway
)
4661 fib6_clean_all(net
, fib6_clean_tohost
, gateway
);
4664 struct arg_netdev_event
{
4665 const struct net_device
*dev
;
4667 unsigned char nh_flags
;
4668 unsigned long event
;
4672 static struct fib6_info
*rt6_multipath_first_sibling(const struct fib6_info
*rt
)
4674 struct fib6_info
*iter
;
4675 struct fib6_node
*fn
;
4677 fn
= rcu_dereference_protected(rt
->fib6_node
,
4678 lockdep_is_held(&rt
->fib6_table
->tb6_lock
));
4679 iter
= rcu_dereference_protected(fn
->leaf
,
4680 lockdep_is_held(&rt
->fib6_table
->tb6_lock
));
4682 if (iter
->fib6_metric
== rt
->fib6_metric
&&
4683 rt6_qualify_for_ecmp(iter
))
4685 iter
= rcu_dereference_protected(iter
->fib6_next
,
4686 lockdep_is_held(&rt
->fib6_table
->tb6_lock
));
4692 /* only called for fib entries with builtin fib6_nh */
4693 static bool rt6_is_dead(const struct fib6_info
*rt
)
4695 if (rt
->fib6_nh
->fib_nh_flags
& RTNH_F_DEAD
||
4696 (rt
->fib6_nh
->fib_nh_flags
& RTNH_F_LINKDOWN
&&
4697 ip6_ignore_linkdown(rt
->fib6_nh
->fib_nh_dev
)))
4703 static int rt6_multipath_total_weight(const struct fib6_info
*rt
)
4705 struct fib6_info
*iter
;
4708 if (!rt6_is_dead(rt
))
4709 total
+= rt
->fib6_nh
->fib_nh_weight
;
4711 list_for_each_entry(iter
, &rt
->fib6_siblings
, fib6_siblings
) {
4712 if (!rt6_is_dead(iter
))
4713 total
+= iter
->fib6_nh
->fib_nh_weight
;
4719 static void rt6_upper_bound_set(struct fib6_info
*rt
, int *weight
, int total
)
4721 int upper_bound
= -1;
4723 if (!rt6_is_dead(rt
)) {
4724 *weight
+= rt
->fib6_nh
->fib_nh_weight
;
4725 upper_bound
= DIV_ROUND_CLOSEST_ULL((u64
) (*weight
) << 31,
4728 atomic_set(&rt
->fib6_nh
->fib_nh_upper_bound
, upper_bound
);
4731 static void rt6_multipath_upper_bound_set(struct fib6_info
*rt
, int total
)
4733 struct fib6_info
*iter
;
4736 rt6_upper_bound_set(rt
, &weight
, total
);
4738 list_for_each_entry(iter
, &rt
->fib6_siblings
, fib6_siblings
)
4739 rt6_upper_bound_set(iter
, &weight
, total
);
4742 void rt6_multipath_rebalance(struct fib6_info
*rt
)
4744 struct fib6_info
*first
;
4747 /* In case the entire multipath route was marked for flushing,
4748 * then there is no need to rebalance upon the removal of every
4751 if (!rt
->fib6_nsiblings
|| rt
->should_flush
)
4754 /* During lookup routes are evaluated in order, so we need to
4755 * make sure upper bounds are assigned from the first sibling
4758 first
= rt6_multipath_first_sibling(rt
);
4759 if (WARN_ON_ONCE(!first
))
4762 total
= rt6_multipath_total_weight(first
);
4763 rt6_multipath_upper_bound_set(first
, total
);
4766 static int fib6_ifup(struct fib6_info
*rt
, void *p_arg
)
4768 const struct arg_netdev_event
*arg
= p_arg
;
4769 struct net
*net
= dev_net(arg
->dev
);
4771 if (rt
!= net
->ipv6
.fib6_null_entry
&& !rt
->nh
&&
4772 rt
->fib6_nh
->fib_nh_dev
== arg
->dev
) {
4773 rt
->fib6_nh
->fib_nh_flags
&= ~arg
->nh_flags
;
4774 fib6_update_sernum_upto_root(net
, rt
);
4775 rt6_multipath_rebalance(rt
);
4781 void rt6_sync_up(struct net_device
*dev
, unsigned char nh_flags
)
4783 struct arg_netdev_event arg
= {
4786 .nh_flags
= nh_flags
,
4790 if (nh_flags
& RTNH_F_DEAD
&& netif_carrier_ok(dev
))
4791 arg
.nh_flags
|= RTNH_F_LINKDOWN
;
4793 fib6_clean_all(dev_net(dev
), fib6_ifup
, &arg
);
4796 /* only called for fib entries with inline fib6_nh */
4797 static bool rt6_multipath_uses_dev(const struct fib6_info
*rt
,
4798 const struct net_device
*dev
)
4800 struct fib6_info
*iter
;
4802 if (rt
->fib6_nh
->fib_nh_dev
== dev
)
4804 list_for_each_entry(iter
, &rt
->fib6_siblings
, fib6_siblings
)
4805 if (iter
->fib6_nh
->fib_nh_dev
== dev
)
4811 static void rt6_multipath_flush(struct fib6_info
*rt
)
4813 struct fib6_info
*iter
;
4815 rt
->should_flush
= 1;
4816 list_for_each_entry(iter
, &rt
->fib6_siblings
, fib6_siblings
)
4817 iter
->should_flush
= 1;
4820 static unsigned int rt6_multipath_dead_count(const struct fib6_info
*rt
,
4821 const struct net_device
*down_dev
)
4823 struct fib6_info
*iter
;
4824 unsigned int dead
= 0;
4826 if (rt
->fib6_nh
->fib_nh_dev
== down_dev
||
4827 rt
->fib6_nh
->fib_nh_flags
& RTNH_F_DEAD
)
4829 list_for_each_entry(iter
, &rt
->fib6_siblings
, fib6_siblings
)
4830 if (iter
->fib6_nh
->fib_nh_dev
== down_dev
||
4831 iter
->fib6_nh
->fib_nh_flags
& RTNH_F_DEAD
)
4837 static void rt6_multipath_nh_flags_set(struct fib6_info
*rt
,
4838 const struct net_device
*dev
,
4839 unsigned char nh_flags
)
4841 struct fib6_info
*iter
;
4843 if (rt
->fib6_nh
->fib_nh_dev
== dev
)
4844 rt
->fib6_nh
->fib_nh_flags
|= nh_flags
;
4845 list_for_each_entry(iter
, &rt
->fib6_siblings
, fib6_siblings
)
4846 if (iter
->fib6_nh
->fib_nh_dev
== dev
)
4847 iter
->fib6_nh
->fib_nh_flags
|= nh_flags
;
4850 /* called with write lock held for table with rt */
4851 static int fib6_ifdown(struct fib6_info
*rt
, void *p_arg
)
4853 const struct arg_netdev_event
*arg
= p_arg
;
4854 const struct net_device
*dev
= arg
->dev
;
4855 struct net
*net
= dev_net(dev
);
4857 if (rt
== net
->ipv6
.fib6_null_entry
|| rt
->nh
)
4860 switch (arg
->event
) {
4861 case NETDEV_UNREGISTER
:
4862 return rt
->fib6_nh
->fib_nh_dev
== dev
? -1 : 0;
4864 if (rt
->should_flush
)
4866 if (!rt
->fib6_nsiblings
)
4867 return rt
->fib6_nh
->fib_nh_dev
== dev
? -1 : 0;
4868 if (rt6_multipath_uses_dev(rt
, dev
)) {
4871 count
= rt6_multipath_dead_count(rt
, dev
);
4872 if (rt
->fib6_nsiblings
+ 1 == count
) {
4873 rt6_multipath_flush(rt
);
4876 rt6_multipath_nh_flags_set(rt
, dev
, RTNH_F_DEAD
|
4878 fib6_update_sernum(net
, rt
);
4879 rt6_multipath_rebalance(rt
);
4883 if (rt
->fib6_nh
->fib_nh_dev
!= dev
||
4884 rt
->fib6_flags
& (RTF_LOCAL
| RTF_ANYCAST
))
4886 rt
->fib6_nh
->fib_nh_flags
|= RTNH_F_LINKDOWN
;
4887 rt6_multipath_rebalance(rt
);
4894 void rt6_sync_down_dev(struct net_device
*dev
, unsigned long event
)
4896 struct arg_netdev_event arg
= {
4902 struct net
*net
= dev_net(dev
);
4904 if (net
->ipv6
.sysctl
.skip_notify_on_dev_down
)
4905 fib6_clean_all_skip_notify(net
, fib6_ifdown
, &arg
);
4907 fib6_clean_all(net
, fib6_ifdown
, &arg
);
4910 void rt6_disable_ip(struct net_device
*dev
, unsigned long event
)
4912 rt6_sync_down_dev(dev
, event
);
4913 rt6_uncached_list_flush_dev(dev_net(dev
), dev
);
4914 neigh_ifdown(&nd_tbl
, dev
);
4917 struct rt6_mtu_change_arg
{
4918 struct net_device
*dev
;
4920 struct fib6_info
*f6i
;
4923 static int fib6_nh_mtu_change(struct fib6_nh
*nh
, void *_arg
)
4925 struct rt6_mtu_change_arg
*arg
= (struct rt6_mtu_change_arg
*)_arg
;
4926 struct fib6_info
*f6i
= arg
->f6i
;
4928 /* For administrative MTU increase, there is no way to discover
4929 * IPv6 PMTU increase, so PMTU increase should be updated here.
4930 * Since RFC 1981 doesn't include administrative MTU increase
4931 * update PMTU increase is a MUST. (i.e. jumbo frame)
4933 if (nh
->fib_nh_dev
== arg
->dev
) {
4934 struct inet6_dev
*idev
= __in6_dev_get(arg
->dev
);
4935 u32 mtu
= f6i
->fib6_pmtu
;
4937 if (mtu
>= arg
->mtu
||
4938 (mtu
< arg
->mtu
&& mtu
== idev
->cnf
.mtu6
))
4939 fib6_metric_set(f6i
, RTAX_MTU
, arg
->mtu
);
4941 spin_lock_bh(&rt6_exception_lock
);
4942 rt6_exceptions_update_pmtu(idev
, nh
, arg
->mtu
);
4943 spin_unlock_bh(&rt6_exception_lock
);
4949 static int rt6_mtu_change_route(struct fib6_info
*f6i
, void *p_arg
)
4951 struct rt6_mtu_change_arg
*arg
= (struct rt6_mtu_change_arg
*) p_arg
;
4952 struct inet6_dev
*idev
;
4954 /* In IPv6 pmtu discovery is not optional,
4955 so that RTAX_MTU lock cannot disable it.
4956 We still use this lock to block changes
4957 caused by addrconf/ndisc.
4960 idev
= __in6_dev_get(arg
->dev
);
4964 if (fib6_metric_locked(f6i
, RTAX_MTU
))
4969 /* fib6_nh_mtu_change only returns 0, so this is safe */
4970 return nexthop_for_each_fib6_nh(f6i
->nh
, fib6_nh_mtu_change
,
4974 return fib6_nh_mtu_change(f6i
->fib6_nh
, arg
);
4977 void rt6_mtu_change(struct net_device
*dev
, unsigned int mtu
)
4979 struct rt6_mtu_change_arg arg
= {
4984 fib6_clean_all(dev_net(dev
), rt6_mtu_change_route
, &arg
);
4987 static const struct nla_policy rtm_ipv6_policy
[RTA_MAX
+1] = {
4988 [RTA_UNSPEC
] = { .strict_start_type
= RTA_DPORT
+ 1 },
4989 [RTA_GATEWAY
] = { .len
= sizeof(struct in6_addr
) },
4990 [RTA_PREFSRC
] = { .len
= sizeof(struct in6_addr
) },
4991 [RTA_OIF
] = { .type
= NLA_U32
},
4992 [RTA_IIF
] = { .type
= NLA_U32
},
4993 [RTA_PRIORITY
] = { .type
= NLA_U32
},
4994 [RTA_METRICS
] = { .type
= NLA_NESTED
},
4995 [RTA_MULTIPATH
] = { .len
= sizeof(struct rtnexthop
) },
4996 [RTA_PREF
] = { .type
= NLA_U8
},
4997 [RTA_ENCAP_TYPE
] = { .type
= NLA_U16
},
4998 [RTA_ENCAP
] = { .type
= NLA_NESTED
},
4999 [RTA_EXPIRES
] = { .type
= NLA_U32
},
5000 [RTA_UID
] = { .type
= NLA_U32
},
5001 [RTA_MARK
] = { .type
= NLA_U32
},
5002 [RTA_TABLE
] = { .type
= NLA_U32
},
5003 [RTA_IP_PROTO
] = { .type
= NLA_U8
},
5004 [RTA_SPORT
] = { .type
= NLA_U16
},
5005 [RTA_DPORT
] = { .type
= NLA_U16
},
5006 [RTA_NH_ID
] = { .type
= NLA_U32
},
5009 static int rtm_to_fib6_config(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
5010 struct fib6_config
*cfg
,
5011 struct netlink_ext_ack
*extack
)
5014 struct nlattr
*tb
[RTA_MAX
+1];
5018 err
= nlmsg_parse_deprecated(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
5019 rtm_ipv6_policy
, extack
);
5024 rtm
= nlmsg_data(nlh
);
5026 *cfg
= (struct fib6_config
){
5027 .fc_table
= rtm
->rtm_table
,
5028 .fc_dst_len
= rtm
->rtm_dst_len
,
5029 .fc_src_len
= rtm
->rtm_src_len
,
5031 .fc_protocol
= rtm
->rtm_protocol
,
5032 .fc_type
= rtm
->rtm_type
,
5034 .fc_nlinfo
.portid
= NETLINK_CB(skb
).portid
,
5035 .fc_nlinfo
.nlh
= nlh
,
5036 .fc_nlinfo
.nl_net
= sock_net(skb
->sk
),
5039 if (rtm
->rtm_type
== RTN_UNREACHABLE
||
5040 rtm
->rtm_type
== RTN_BLACKHOLE
||
5041 rtm
->rtm_type
== RTN_PROHIBIT
||
5042 rtm
->rtm_type
== RTN_THROW
)
5043 cfg
->fc_flags
|= RTF_REJECT
;
5045 if (rtm
->rtm_type
== RTN_LOCAL
)
5046 cfg
->fc_flags
|= RTF_LOCAL
;
5048 if (rtm
->rtm_flags
& RTM_F_CLONED
)
5049 cfg
->fc_flags
|= RTF_CACHE
;
5051 cfg
->fc_flags
|= (rtm
->rtm_flags
& RTNH_F_ONLINK
);
5053 if (tb
[RTA_NH_ID
]) {
5054 if (tb
[RTA_GATEWAY
] || tb
[RTA_OIF
] ||
5055 tb
[RTA_MULTIPATH
] || tb
[RTA_ENCAP
]) {
5056 NL_SET_ERR_MSG(extack
,
5057 "Nexthop specification and nexthop id are mutually exclusive");
5060 cfg
->fc_nh_id
= nla_get_u32(tb
[RTA_NH_ID
]);
5063 if (tb
[RTA_GATEWAY
]) {
5064 cfg
->fc_gateway
= nla_get_in6_addr(tb
[RTA_GATEWAY
]);
5065 cfg
->fc_flags
|= RTF_GATEWAY
;
5068 NL_SET_ERR_MSG(extack
, "IPv6 does not support RTA_VIA attribute");
5073 int plen
= (rtm
->rtm_dst_len
+ 7) >> 3;
5075 if (nla_len(tb
[RTA_DST
]) < plen
)
5078 nla_memcpy(&cfg
->fc_dst
, tb
[RTA_DST
], plen
);
5082 int plen
= (rtm
->rtm_src_len
+ 7) >> 3;
5084 if (nla_len(tb
[RTA_SRC
]) < plen
)
5087 nla_memcpy(&cfg
->fc_src
, tb
[RTA_SRC
], plen
);
5090 if (tb
[RTA_PREFSRC
])
5091 cfg
->fc_prefsrc
= nla_get_in6_addr(tb
[RTA_PREFSRC
]);
5094 cfg
->fc_ifindex
= nla_get_u32(tb
[RTA_OIF
]);
5096 if (tb
[RTA_PRIORITY
])
5097 cfg
->fc_metric
= nla_get_u32(tb
[RTA_PRIORITY
]);
5099 if (tb
[RTA_METRICS
]) {
5100 cfg
->fc_mx
= nla_data(tb
[RTA_METRICS
]);
5101 cfg
->fc_mx_len
= nla_len(tb
[RTA_METRICS
]);
5105 cfg
->fc_table
= nla_get_u32(tb
[RTA_TABLE
]);
5107 if (tb
[RTA_MULTIPATH
]) {
5108 cfg
->fc_mp
= nla_data(tb
[RTA_MULTIPATH
]);
5109 cfg
->fc_mp_len
= nla_len(tb
[RTA_MULTIPATH
]);
5111 err
= lwtunnel_valid_encap_type_attr(cfg
->fc_mp
,
5112 cfg
->fc_mp_len
, extack
);
5118 pref
= nla_get_u8(tb
[RTA_PREF
]);
5119 if (pref
!= ICMPV6_ROUTER_PREF_LOW
&&
5120 pref
!= ICMPV6_ROUTER_PREF_HIGH
)
5121 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
5122 cfg
->fc_flags
|= RTF_PREF(pref
);
5126 cfg
->fc_encap
= tb
[RTA_ENCAP
];
5128 if (tb
[RTA_ENCAP_TYPE
]) {
5129 cfg
->fc_encap_type
= nla_get_u16(tb
[RTA_ENCAP_TYPE
]);
5131 err
= lwtunnel_valid_encap_type(cfg
->fc_encap_type
, extack
);
5136 if (tb
[RTA_EXPIRES
]) {
5137 unsigned long timeout
= addrconf_timeout_fixup(nla_get_u32(tb
[RTA_EXPIRES
]), HZ
);
5139 if (addrconf_finite_timeout(timeout
)) {
5140 cfg
->fc_expires
= jiffies_to_clock_t(timeout
* HZ
);
5141 cfg
->fc_flags
|= RTF_EXPIRES
;
5151 struct fib6_info
*fib6_info
;
5152 struct fib6_config r_cfg
;
5153 struct list_head next
;
5156 static int ip6_route_info_append(struct net
*net
,
5157 struct list_head
*rt6_nh_list
,
5158 struct fib6_info
*rt
,
5159 struct fib6_config
*r_cfg
)
5164 list_for_each_entry(nh
, rt6_nh_list
, next
) {
5165 /* check if fib6_info already exists */
5166 if (rt6_duplicate_nexthop(nh
->fib6_info
, rt
))
5170 nh
= kzalloc(sizeof(*nh
), GFP_KERNEL
);
5174 memcpy(&nh
->r_cfg
, r_cfg
, sizeof(*r_cfg
));
5175 list_add_tail(&nh
->next
, rt6_nh_list
);
5180 static void ip6_route_mpath_notify(struct fib6_info
*rt
,
5181 struct fib6_info
*rt_last
,
5182 struct nl_info
*info
,
5185 /* if this is an APPEND route, then rt points to the first route
5186 * inserted and rt_last points to last route inserted. Userspace
5187 * wants a consistent dump of the route which starts at the first
5188 * nexthop. Since sibling routes are always added at the end of
5189 * the list, find the first sibling of the last route appended
5191 if ((nlflags
& NLM_F_APPEND
) && rt_last
&& rt_last
->fib6_nsiblings
) {
5192 rt
= list_first_entry(&rt_last
->fib6_siblings
,
5198 inet6_rt_notify(RTM_NEWROUTE
, rt
, info
, nlflags
);
5201 static bool ip6_route_mpath_should_notify(const struct fib6_info
*rt
)
5203 bool rt_can_ecmp
= rt6_qualify_for_ecmp(rt
);
5204 bool should_notify
= false;
5205 struct fib6_info
*leaf
;
5206 struct fib6_node
*fn
;
5209 fn
= rcu_dereference(rt
->fib6_node
);
5213 leaf
= rcu_dereference(fn
->leaf
);
5218 (rt_can_ecmp
&& rt
->fib6_metric
== leaf
->fib6_metric
&&
5219 rt6_qualify_for_ecmp(leaf
)))
5220 should_notify
= true;
5224 return should_notify
;
5227 static int fib6_gw_from_attr(struct in6_addr
*gw
, struct nlattr
*nla
,
5228 struct netlink_ext_ack
*extack
)
5230 if (nla_len(nla
) < sizeof(*gw
)) {
5231 NL_SET_ERR_MSG(extack
, "Invalid IPv6 address in RTA_GATEWAY");
5235 *gw
= nla_get_in6_addr(nla
);
5240 static int ip6_route_multipath_add(struct fib6_config
*cfg
,
5241 struct netlink_ext_ack
*extack
)
5243 struct fib6_info
*rt_notif
= NULL
, *rt_last
= NULL
;
5244 struct nl_info
*info
= &cfg
->fc_nlinfo
;
5245 struct fib6_config r_cfg
;
5246 struct rtnexthop
*rtnh
;
5247 struct fib6_info
*rt
;
5248 struct rt6_nh
*err_nh
;
5249 struct rt6_nh
*nh
, *nh_safe
;
5255 int replace
= (cfg
->fc_nlinfo
.nlh
&&
5256 (cfg
->fc_nlinfo
.nlh
->nlmsg_flags
& NLM_F_REPLACE
));
5257 LIST_HEAD(rt6_nh_list
);
5259 nlflags
= replace
? NLM_F_REPLACE
: NLM_F_CREATE
;
5260 if (info
->nlh
&& info
->nlh
->nlmsg_flags
& NLM_F_APPEND
)
5261 nlflags
|= NLM_F_APPEND
;
5263 remaining
= cfg
->fc_mp_len
;
5264 rtnh
= (struct rtnexthop
*)cfg
->fc_mp
;
5266 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
5267 * fib6_info structs per nexthop
5269 while (rtnh_ok(rtnh
, remaining
)) {
5270 memcpy(&r_cfg
, cfg
, sizeof(*cfg
));
5271 if (rtnh
->rtnh_ifindex
)
5272 r_cfg
.fc_ifindex
= rtnh
->rtnh_ifindex
;
5274 attrlen
= rtnh_attrlen(rtnh
);
5276 struct nlattr
*nla
, *attrs
= rtnh_attrs(rtnh
);
5278 nla
= nla_find(attrs
, attrlen
, RTA_GATEWAY
);
5280 err
= fib6_gw_from_attr(&r_cfg
.fc_gateway
, nla
,
5285 r_cfg
.fc_flags
|= RTF_GATEWAY
;
5287 r_cfg
.fc_encap
= nla_find(attrs
, attrlen
, RTA_ENCAP
);
5289 /* RTA_ENCAP_TYPE length checked in
5290 * lwtunnel_valid_encap_type_attr
5292 nla
= nla_find(attrs
, attrlen
, RTA_ENCAP_TYPE
);
5294 r_cfg
.fc_encap_type
= nla_get_u16(nla
);
5297 r_cfg
.fc_flags
|= (rtnh
->rtnh_flags
& RTNH_F_ONLINK
);
5298 rt
= ip6_route_info_create(&r_cfg
, GFP_KERNEL
, extack
);
5304 if (!rt6_qualify_for_ecmp(rt
)) {
5306 NL_SET_ERR_MSG(extack
,
5307 "Device only routes can not be added for IPv6 using the multipath API.");
5308 fib6_info_release(rt
);
5312 rt
->fib6_nh
->fib_nh_weight
= rtnh
->rtnh_hops
+ 1;
5314 err
= ip6_route_info_append(info
->nl_net
, &rt6_nh_list
,
5317 fib6_info_release(rt
);
5321 rtnh
= rtnh_next(rtnh
, &remaining
);
5324 if (list_empty(&rt6_nh_list
)) {
5325 NL_SET_ERR_MSG(extack
,
5326 "Invalid nexthop configuration - no valid nexthops");
5330 /* for add and replace send one notification with all nexthops.
5331 * Skip the notification in fib6_add_rt2node and send one with
5332 * the full route when done
5334 info
->skip_notify
= 1;
5336 /* For add and replace, send one notification with all nexthops. For
5337 * append, send one notification with all appended nexthops.
5339 info
->skip_notify_kernel
= 1;
5342 list_for_each_entry(nh
, &rt6_nh_list
, next
) {
5343 err
= __ip6_ins_rt(nh
->fib6_info
, info
, extack
);
5344 fib6_info_release(nh
->fib6_info
);
5347 /* save reference to last route successfully inserted */
5348 rt_last
= nh
->fib6_info
;
5350 /* save reference to first route for notification */
5352 rt_notif
= nh
->fib6_info
;
5355 /* nh->fib6_info is used or freed at this point, reset to NULL*/
5356 nh
->fib6_info
= NULL
;
5359 NL_SET_ERR_MSG_MOD(extack
,
5360 "multipath route replace failed (check consistency of installed routes)");
5365 /* Because each route is added like a single route we remove
5366 * these flags after the first nexthop: if there is a collision,
5367 * we have already failed to add the first nexthop:
5368 * fib6_add_rt2node() has rejected it; when replacing, old
5369 * nexthops have been replaced by first new, the rest should
5372 if (cfg
->fc_nlinfo
.nlh
) {
5373 cfg
->fc_nlinfo
.nlh
->nlmsg_flags
&= ~(NLM_F_EXCL
|
5375 cfg
->fc_nlinfo
.nlh
->nlmsg_flags
|= NLM_F_CREATE
;
5380 /* An in-kernel notification should only be sent in case the new
5381 * multipath route is added as the first route in the node, or if
5382 * it was appended to it. We pass 'rt_notif' since it is the first
5383 * sibling and might allow us to skip some checks in the replace case.
5385 if (ip6_route_mpath_should_notify(rt_notif
)) {
5386 enum fib_event_type fib_event
;
5388 if (rt_notif
->fib6_nsiblings
!= nhn
- 1)
5389 fib_event
= FIB_EVENT_ENTRY_APPEND
;
5391 fib_event
= FIB_EVENT_ENTRY_REPLACE
;
5393 err
= call_fib6_multipath_entry_notifiers(info
->nl_net
,
5394 fib_event
, rt_notif
,
5397 /* Delete all the siblings that were just added */
5403 /* success ... tell user about new route */
5404 ip6_route_mpath_notify(rt_notif
, rt_last
, info
, nlflags
);
5408 /* send notification for routes that were added so that
5409 * the delete notifications sent by ip6_route_del are
5413 ip6_route_mpath_notify(rt_notif
, rt_last
, info
, nlflags
);
5415 /* Delete routes that were already added */
5416 list_for_each_entry(nh
, &rt6_nh_list
, next
) {
5419 ip6_route_del(&nh
->r_cfg
, extack
);
5423 list_for_each_entry_safe(nh
, nh_safe
, &rt6_nh_list
, next
) {
5425 fib6_info_release(nh
->fib6_info
);
5426 list_del(&nh
->next
);
5433 static int ip6_route_multipath_del(struct fib6_config
*cfg
,
5434 struct netlink_ext_ack
*extack
)
5436 struct fib6_config r_cfg
;
5437 struct rtnexthop
*rtnh
;
5443 remaining
= cfg
->fc_mp_len
;
5444 rtnh
= (struct rtnexthop
*)cfg
->fc_mp
;
5446 /* Parse a Multipath Entry */
5447 while (rtnh_ok(rtnh
, remaining
)) {
5448 memcpy(&r_cfg
, cfg
, sizeof(*cfg
));
5449 if (rtnh
->rtnh_ifindex
)
5450 r_cfg
.fc_ifindex
= rtnh
->rtnh_ifindex
;
5452 attrlen
= rtnh_attrlen(rtnh
);
5454 struct nlattr
*nla
, *attrs
= rtnh_attrs(rtnh
);
5456 nla
= nla_find(attrs
, attrlen
, RTA_GATEWAY
);
5458 err
= fib6_gw_from_attr(&r_cfg
.fc_gateway
, nla
,
5465 r_cfg
.fc_flags
|= RTF_GATEWAY
;
5468 err
= ip6_route_del(&r_cfg
, extack
);
5473 rtnh
= rtnh_next(rtnh
, &remaining
);
5479 static int inet6_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
5480 struct netlink_ext_ack
*extack
)
5482 struct fib6_config cfg
;
5485 err
= rtm_to_fib6_config(skb
, nlh
, &cfg
, extack
);
5490 !nexthop_find_by_id(sock_net(skb
->sk
), cfg
.fc_nh_id
)) {
5491 NL_SET_ERR_MSG(extack
, "Nexthop id does not exist");
5496 return ip6_route_multipath_del(&cfg
, extack
);
5498 cfg
.fc_delete_all_nh
= 1;
5499 return ip6_route_del(&cfg
, extack
);
5503 static int inet6_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
5504 struct netlink_ext_ack
*extack
)
5506 struct fib6_config cfg
;
5509 err
= rtm_to_fib6_config(skb
, nlh
, &cfg
, extack
);
5513 if (cfg
.fc_metric
== 0)
5514 cfg
.fc_metric
= IP6_RT_PRIO_USER
;
5517 return ip6_route_multipath_add(&cfg
, extack
);
5519 return ip6_route_add(&cfg
, GFP_KERNEL
, extack
);
5522 /* add the overhead of this fib6_nh to nexthop_len */
5523 static int rt6_nh_nlmsg_size(struct fib6_nh
*nh
, void *arg
)
5525 int *nexthop_len
= arg
;
5527 *nexthop_len
+= nla_total_size(0) /* RTA_MULTIPATH */
5528 + NLA_ALIGN(sizeof(struct rtnexthop
))
5529 + nla_total_size(16); /* RTA_GATEWAY */
5531 if (nh
->fib_nh_lws
) {
5532 /* RTA_ENCAP_TYPE */
5533 *nexthop_len
+= lwtunnel_get_encap_size(nh
->fib_nh_lws
);
5535 *nexthop_len
+= nla_total_size(2);
5541 static size_t rt6_nlmsg_size(struct fib6_info
*f6i
)
5546 nexthop_len
= nla_total_size(4); /* RTA_NH_ID */
5547 nexthop_for_each_fib6_nh(f6i
->nh
, rt6_nh_nlmsg_size
,
5550 struct fib6_nh
*nh
= f6i
->fib6_nh
;
5553 if (f6i
->fib6_nsiblings
) {
5554 nexthop_len
= nla_total_size(0) /* RTA_MULTIPATH */
5555 + NLA_ALIGN(sizeof(struct rtnexthop
))
5556 + nla_total_size(16) /* RTA_GATEWAY */
5557 + lwtunnel_get_encap_size(nh
->fib_nh_lws
);
5559 nexthop_len
*= f6i
->fib6_nsiblings
;
5561 nexthop_len
+= lwtunnel_get_encap_size(nh
->fib_nh_lws
);
5564 return NLMSG_ALIGN(sizeof(struct rtmsg
))
5565 + nla_total_size(16) /* RTA_SRC */
5566 + nla_total_size(16) /* RTA_DST */
5567 + nla_total_size(16) /* RTA_GATEWAY */
5568 + nla_total_size(16) /* RTA_PREFSRC */
5569 + nla_total_size(4) /* RTA_TABLE */
5570 + nla_total_size(4) /* RTA_IIF */
5571 + nla_total_size(4) /* RTA_OIF */
5572 + nla_total_size(4) /* RTA_PRIORITY */
5573 + RTAX_MAX
* nla_total_size(4) /* RTA_METRICS */
5574 + nla_total_size(sizeof(struct rta_cacheinfo
))
5575 + nla_total_size(TCP_CA_NAME_MAX
) /* RTAX_CC_ALGO */
5576 + nla_total_size(1) /* RTA_PREF */
5580 static int rt6_fill_node_nexthop(struct sk_buff
*skb
, struct nexthop
*nh
,
5581 unsigned char *flags
)
5583 if (nexthop_is_multipath(nh
)) {
5586 mp
= nla_nest_start_noflag(skb
, RTA_MULTIPATH
);
5588 goto nla_put_failure
;
5590 if (nexthop_mpath_fill_node(skb
, nh
, AF_INET6
))
5591 goto nla_put_failure
;
5593 nla_nest_end(skb
, mp
);
5595 struct fib6_nh
*fib6_nh
;
5597 fib6_nh
= nexthop_fib6_nh(nh
);
5598 if (fib_nexthop_info(skb
, &fib6_nh
->nh_common
, AF_INET6
,
5600 goto nla_put_failure
;
5609 static int rt6_fill_node(struct net
*net
, struct sk_buff
*skb
,
5610 struct fib6_info
*rt
, struct dst_entry
*dst
,
5611 struct in6_addr
*dest
, struct in6_addr
*src
,
5612 int iif
, int type
, u32 portid
, u32 seq
,
5615 struct rt6_info
*rt6
= (struct rt6_info
*)dst
;
5616 struct rt6key
*rt6_dst
, *rt6_src
;
5617 u32
*pmetrics
, table
, rt6_flags
;
5618 unsigned char nh_flags
= 0;
5619 struct nlmsghdr
*nlh
;
5623 nlh
= nlmsg_put(skb
, portid
, seq
, type
, sizeof(*rtm
), flags
);
5628 rt6_dst
= &rt6
->rt6i_dst
;
5629 rt6_src
= &rt6
->rt6i_src
;
5630 rt6_flags
= rt6
->rt6i_flags
;
5632 rt6_dst
= &rt
->fib6_dst
;
5633 rt6_src
= &rt
->fib6_src
;
5634 rt6_flags
= rt
->fib6_flags
;
5637 rtm
= nlmsg_data(nlh
);
5638 rtm
->rtm_family
= AF_INET6
;
5639 rtm
->rtm_dst_len
= rt6_dst
->plen
;
5640 rtm
->rtm_src_len
= rt6_src
->plen
;
5643 table
= rt
->fib6_table
->tb6_id
;
5645 table
= RT6_TABLE_UNSPEC
;
5646 rtm
->rtm_table
= table
< 256 ? table
: RT_TABLE_COMPAT
;
5647 if (nla_put_u32(skb
, RTA_TABLE
, table
))
5648 goto nla_put_failure
;
5650 rtm
->rtm_type
= rt
->fib6_type
;
5652 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
5653 rtm
->rtm_protocol
= rt
->fib6_protocol
;
5655 if (rt6_flags
& RTF_CACHE
)
5656 rtm
->rtm_flags
|= RTM_F_CLONED
;
5659 if (nla_put_in6_addr(skb
, RTA_DST
, dest
))
5660 goto nla_put_failure
;
5661 rtm
->rtm_dst_len
= 128;
5662 } else if (rtm
->rtm_dst_len
)
5663 if (nla_put_in6_addr(skb
, RTA_DST
, &rt6_dst
->addr
))
5664 goto nla_put_failure
;
5665 #ifdef CONFIG_IPV6_SUBTREES
5667 if (nla_put_in6_addr(skb
, RTA_SRC
, src
))
5668 goto nla_put_failure
;
5669 rtm
->rtm_src_len
= 128;
5670 } else if (rtm
->rtm_src_len
&&
5671 nla_put_in6_addr(skb
, RTA_SRC
, &rt6_src
->addr
))
5672 goto nla_put_failure
;
5675 #ifdef CONFIG_IPV6_MROUTE
5676 if (ipv6_addr_is_multicast(&rt6_dst
->addr
)) {
5677 int err
= ip6mr_get_route(net
, skb
, rtm
, portid
);
5682 goto nla_put_failure
;
5685 if (nla_put_u32(skb
, RTA_IIF
, iif
))
5686 goto nla_put_failure
;
5688 struct in6_addr saddr_buf
;
5689 if (ip6_route_get_saddr(net
, rt
, dest
, 0, &saddr_buf
) == 0 &&
5690 nla_put_in6_addr(skb
, RTA_PREFSRC
, &saddr_buf
))
5691 goto nla_put_failure
;
5694 if (rt
->fib6_prefsrc
.plen
) {
5695 struct in6_addr saddr_buf
;
5696 saddr_buf
= rt
->fib6_prefsrc
.addr
;
5697 if (nla_put_in6_addr(skb
, RTA_PREFSRC
, &saddr_buf
))
5698 goto nla_put_failure
;
5701 pmetrics
= dst
? dst_metrics_ptr(dst
) : rt
->fib6_metrics
->metrics
;
5702 if (rtnetlink_put_metrics(skb
, pmetrics
) < 0)
5703 goto nla_put_failure
;
5705 if (nla_put_u32(skb
, RTA_PRIORITY
, rt
->fib6_metric
))
5706 goto nla_put_failure
;
5708 /* For multipath routes, walk the siblings list and add
5709 * each as a nexthop within RTA_MULTIPATH.
5712 if (rt6_flags
& RTF_GATEWAY
&&
5713 nla_put_in6_addr(skb
, RTA_GATEWAY
, &rt6
->rt6i_gateway
))
5714 goto nla_put_failure
;
5716 if (dst
->dev
&& nla_put_u32(skb
, RTA_OIF
, dst
->dev
->ifindex
))
5717 goto nla_put_failure
;
5719 if (dst
->lwtstate
&&
5720 lwtunnel_fill_encap(skb
, dst
->lwtstate
, RTA_ENCAP
, RTA_ENCAP_TYPE
) < 0)
5721 goto nla_put_failure
;
5722 } else if (rt
->fib6_nsiblings
) {
5723 struct fib6_info
*sibling
, *next_sibling
;
5726 mp
= nla_nest_start_noflag(skb
, RTA_MULTIPATH
);
5728 goto nla_put_failure
;
5730 if (fib_add_nexthop(skb
, &rt
->fib6_nh
->nh_common
,
5731 rt
->fib6_nh
->fib_nh_weight
, AF_INET6
,
5733 goto nla_put_failure
;
5735 list_for_each_entry_safe(sibling
, next_sibling
,
5736 &rt
->fib6_siblings
, fib6_siblings
) {
5737 if (fib_add_nexthop(skb
, &sibling
->fib6_nh
->nh_common
,
5738 sibling
->fib6_nh
->fib_nh_weight
,
5740 goto nla_put_failure
;
5743 nla_nest_end(skb
, mp
);
5744 } else if (rt
->nh
) {
5745 if (nla_put_u32(skb
, RTA_NH_ID
, rt
->nh
->id
))
5746 goto nla_put_failure
;
5748 if (nexthop_is_blackhole(rt
->nh
))
5749 rtm
->rtm_type
= RTN_BLACKHOLE
;
5751 if (net
->ipv4
.sysctl_nexthop_compat_mode
&&
5752 rt6_fill_node_nexthop(skb
, rt
->nh
, &nh_flags
) < 0)
5753 goto nla_put_failure
;
5755 rtm
->rtm_flags
|= nh_flags
;
5757 if (fib_nexthop_info(skb
, &rt
->fib6_nh
->nh_common
, AF_INET6
,
5758 &nh_flags
, false) < 0)
5759 goto nla_put_failure
;
5761 rtm
->rtm_flags
|= nh_flags
;
5764 if (rt6_flags
& RTF_EXPIRES
) {
5765 expires
= dst
? dst
->expires
: rt
->expires
;
5771 rtm
->rtm_flags
|= RTM_F_OFFLOAD
;
5773 rtm
->rtm_flags
|= RTM_F_TRAP
;
5774 if (rt
->offload_failed
)
5775 rtm
->rtm_flags
|= RTM_F_OFFLOAD_FAILED
;
5778 if (rtnl_put_cacheinfo(skb
, dst
, 0, expires
, dst
? dst
->error
: 0) < 0)
5779 goto nla_put_failure
;
5781 if (nla_put_u8(skb
, RTA_PREF
, IPV6_EXTRACT_PREF(rt6_flags
)))
5782 goto nla_put_failure
;
5785 nlmsg_end(skb
, nlh
);
5789 nlmsg_cancel(skb
, nlh
);
5793 static int fib6_info_nh_uses_dev(struct fib6_nh
*nh
, void *arg
)
5795 const struct net_device
*dev
= arg
;
5797 if (nh
->fib_nh_dev
== dev
)
5803 static bool fib6_info_uses_dev(const struct fib6_info
*f6i
,
5804 const struct net_device
*dev
)
5807 struct net_device
*_dev
= (struct net_device
*)dev
;
5809 return !!nexthop_for_each_fib6_nh(f6i
->nh
,
5810 fib6_info_nh_uses_dev
,
5814 if (f6i
->fib6_nh
->fib_nh_dev
== dev
)
5817 if (f6i
->fib6_nsiblings
) {
5818 struct fib6_info
*sibling
, *next_sibling
;
5820 list_for_each_entry_safe(sibling
, next_sibling
,
5821 &f6i
->fib6_siblings
, fib6_siblings
) {
5822 if (sibling
->fib6_nh
->fib_nh_dev
== dev
)
5830 struct fib6_nh_exception_dump_walker
{
5831 struct rt6_rtnl_dump_arg
*dump
;
5832 struct fib6_info
*rt
;
5838 static int rt6_nh_dump_exceptions(struct fib6_nh
*nh
, void *arg
)
5840 struct fib6_nh_exception_dump_walker
*w
= arg
;
5841 struct rt6_rtnl_dump_arg
*dump
= w
->dump
;
5842 struct rt6_exception_bucket
*bucket
;
5843 struct rt6_exception
*rt6_ex
;
5846 bucket
= fib6_nh_get_excptn_bucket(nh
, NULL
);
5850 for (i
= 0; i
< FIB6_EXCEPTION_BUCKET_SIZE
; i
++) {
5851 hlist_for_each_entry(rt6_ex
, &bucket
->chain
, hlist
) {
5857 /* Expiration of entries doesn't bump sernum, insertion
5858 * does. Removal is triggered by insertion, so we can
5859 * rely on the fact that if entries change between two
5860 * partial dumps, this node is scanned again completely,
5861 * see rt6_insert_exception() and fib6_dump_table().
5863 * Count expired entries we go through as handled
5864 * entries that we'll skip next time, in case of partial
5865 * node dump. Otherwise, if entries expire meanwhile,
5866 * we'll skip the wrong amount.
5868 if (rt6_check_expired(rt6_ex
->rt6i
)) {
5873 err
= rt6_fill_node(dump
->net
, dump
->skb
, w
->rt
,
5874 &rt6_ex
->rt6i
->dst
, NULL
, NULL
, 0,
5876 NETLINK_CB(dump
->cb
->skb
).portid
,
5877 dump
->cb
->nlh
->nlmsg_seq
, w
->flags
);
5889 /* Return -1 if done with node, number of handled routes on partial dump */
5890 int rt6_dump_route(struct fib6_info
*rt
, void *p_arg
, unsigned int skip
)
5892 struct rt6_rtnl_dump_arg
*arg
= (struct rt6_rtnl_dump_arg
*) p_arg
;
5893 struct fib_dump_filter
*filter
= &arg
->filter
;
5894 unsigned int flags
= NLM_F_MULTI
;
5895 struct net
*net
= arg
->net
;
5898 if (rt
== net
->ipv6
.fib6_null_entry
)
5901 if ((filter
->flags
& RTM_F_PREFIX
) &&
5902 !(rt
->fib6_flags
& RTF_PREFIX_RT
)) {
5903 /* success since this is not a prefix route */
5906 if (filter
->filter_set
&&
5907 ((filter
->rt_type
&& rt
->fib6_type
!= filter
->rt_type
) ||
5908 (filter
->dev
&& !fib6_info_uses_dev(rt
, filter
->dev
)) ||
5909 (filter
->protocol
&& rt
->fib6_protocol
!= filter
->protocol
))) {
5913 if (filter
->filter_set
||
5914 !filter
->dump_routes
|| !filter
->dump_exceptions
) {
5915 flags
|= NLM_F_DUMP_FILTERED
;
5918 if (filter
->dump_routes
) {
5922 if (rt6_fill_node(net
, arg
->skb
, rt
, NULL
, NULL
, NULL
,
5924 NETLINK_CB(arg
->cb
->skb
).portid
,
5925 arg
->cb
->nlh
->nlmsg_seq
, flags
)) {
5932 if (filter
->dump_exceptions
) {
5933 struct fib6_nh_exception_dump_walker w
= { .dump
= arg
,
5942 err
= nexthop_for_each_fib6_nh(rt
->nh
,
5943 rt6_nh_dump_exceptions
,
5946 err
= rt6_nh_dump_exceptions(rt
->fib6_nh
, &w
);
5951 return count
+= w
.count
;
5957 static int inet6_rtm_valid_getroute_req(struct sk_buff
*skb
,
5958 const struct nlmsghdr
*nlh
,
5960 struct netlink_ext_ack
*extack
)
5965 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*rtm
))) {
5966 NL_SET_ERR_MSG_MOD(extack
,
5967 "Invalid header for get route request");
5971 if (!netlink_strict_get_check(skb
))
5972 return nlmsg_parse_deprecated(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
5973 rtm_ipv6_policy
, extack
);
5975 rtm
= nlmsg_data(nlh
);
5976 if ((rtm
->rtm_src_len
&& rtm
->rtm_src_len
!= 128) ||
5977 (rtm
->rtm_dst_len
&& rtm
->rtm_dst_len
!= 128) ||
5978 rtm
->rtm_table
|| rtm
->rtm_protocol
|| rtm
->rtm_scope
||
5980 NL_SET_ERR_MSG_MOD(extack
, "Invalid values in header for get route request");
5983 if (rtm
->rtm_flags
& ~RTM_F_FIB_MATCH
) {
5984 NL_SET_ERR_MSG_MOD(extack
,
5985 "Invalid flags for get route request");
5989 err
= nlmsg_parse_deprecated_strict(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
5990 rtm_ipv6_policy
, extack
);
5994 if ((tb
[RTA_SRC
] && !rtm
->rtm_src_len
) ||
5995 (tb
[RTA_DST
] && !rtm
->rtm_dst_len
)) {
5996 NL_SET_ERR_MSG_MOD(extack
, "rtm_src_len and rtm_dst_len must be 128 for IPv6");
6000 for (i
= 0; i
<= RTA_MAX
; i
++) {
6016 NL_SET_ERR_MSG_MOD(extack
, "Unsupported attribute in get route request");
6024 static int inet6_rtm_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
*nlh
,
6025 struct netlink_ext_ack
*extack
)
6027 struct net
*net
= sock_net(in_skb
->sk
);
6028 struct nlattr
*tb
[RTA_MAX
+1];
6029 int err
, iif
= 0, oif
= 0;
6030 struct fib6_info
*from
;
6031 struct dst_entry
*dst
;
6032 struct rt6_info
*rt
;
6033 struct sk_buff
*skb
;
6035 struct flowi6 fl6
= {};
6038 err
= inet6_rtm_valid_getroute_req(in_skb
, nlh
, tb
, extack
);
6043 rtm
= nlmsg_data(nlh
);
6044 fl6
.flowlabel
= ip6_make_flowinfo(rtm
->rtm_tos
, 0);
6045 fibmatch
= !!(rtm
->rtm_flags
& RTM_F_FIB_MATCH
);
6048 if (nla_len(tb
[RTA_SRC
]) < sizeof(struct in6_addr
))
6051 fl6
.saddr
= *(struct in6_addr
*)nla_data(tb
[RTA_SRC
]);
6055 if (nla_len(tb
[RTA_DST
]) < sizeof(struct in6_addr
))
6058 fl6
.daddr
= *(struct in6_addr
*)nla_data(tb
[RTA_DST
]);
6062 iif
= nla_get_u32(tb
[RTA_IIF
]);
6065 oif
= nla_get_u32(tb
[RTA_OIF
]);
6068 fl6
.flowi6_mark
= nla_get_u32(tb
[RTA_MARK
]);
6071 fl6
.flowi6_uid
= make_kuid(current_user_ns(),
6072 nla_get_u32(tb
[RTA_UID
]));
6074 fl6
.flowi6_uid
= iif
? INVALID_UID
: current_uid();
6077 fl6
.fl6_sport
= nla_get_be16(tb
[RTA_SPORT
]);
6080 fl6
.fl6_dport
= nla_get_be16(tb
[RTA_DPORT
]);
6082 if (tb
[RTA_IP_PROTO
]) {
6083 err
= rtm_getroute_parse_ip_proto(tb
[RTA_IP_PROTO
],
6084 &fl6
.flowi6_proto
, AF_INET6
,
6091 struct net_device
*dev
;
6096 dev
= dev_get_by_index_rcu(net
, iif
);
6103 fl6
.flowi6_iif
= iif
;
6105 if (!ipv6_addr_any(&fl6
.saddr
))
6106 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
6108 dst
= ip6_route_input_lookup(net
, dev
, &fl6
, NULL
, flags
);
6112 fl6
.flowi6_oif
= oif
;
6114 dst
= ip6_route_output(net
, NULL
, &fl6
);
6118 rt
= container_of(dst
, struct rt6_info
, dst
);
6119 if (rt
->dst
.error
) {
6120 err
= rt
->dst
.error
;
6125 if (rt
== net
->ipv6
.ip6_null_entry
) {
6126 err
= rt
->dst
.error
;
6131 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
6138 skb_dst_set(skb
, &rt
->dst
);
6141 from
= rcu_dereference(rt
->from
);
6144 err
= rt6_fill_node(net
, skb
, from
, NULL
, NULL
, NULL
,
6146 NETLINK_CB(in_skb
).portid
,
6149 err
= rt6_fill_node(net
, skb
, from
, dst
, &fl6
.daddr
,
6150 &fl6
.saddr
, iif
, RTM_NEWROUTE
,
6151 NETLINK_CB(in_skb
).portid
,
6163 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
6168 void inet6_rt_notify(int event
, struct fib6_info
*rt
, struct nl_info
*info
,
6169 unsigned int nlm_flags
)
6171 struct sk_buff
*skb
;
6172 struct net
*net
= info
->nl_net
;
6177 seq
= info
->nlh
? info
->nlh
->nlmsg_seq
: 0;
6179 skb
= nlmsg_new(rt6_nlmsg_size(rt
), gfp_any());
6183 err
= rt6_fill_node(net
, skb
, rt
, NULL
, NULL
, NULL
, 0,
6184 event
, info
->portid
, seq
, nlm_flags
);
6186 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
6187 WARN_ON(err
== -EMSGSIZE
);
6191 rtnl_notify(skb
, net
, info
->portid
, RTNLGRP_IPV6_ROUTE
,
6192 info
->nlh
, gfp_any());
6196 rtnl_set_sk_err(net
, RTNLGRP_IPV6_ROUTE
, err
);
6199 void fib6_rt_update(struct net
*net
, struct fib6_info
*rt
,
6200 struct nl_info
*info
)
6202 u32 seq
= info
->nlh
? info
->nlh
->nlmsg_seq
: 0;
6203 struct sk_buff
*skb
;
6206 skb
= nlmsg_new(rt6_nlmsg_size(rt
), gfp_any());
6210 err
= rt6_fill_node(net
, skb
, rt
, NULL
, NULL
, NULL
, 0,
6211 RTM_NEWROUTE
, info
->portid
, seq
, NLM_F_REPLACE
);
6213 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
6214 WARN_ON(err
== -EMSGSIZE
);
6218 rtnl_notify(skb
, net
, info
->portid
, RTNLGRP_IPV6_ROUTE
,
6219 info
->nlh
, gfp_any());
6223 rtnl_set_sk_err(net
, RTNLGRP_IPV6_ROUTE
, err
);
6226 void fib6_info_hw_flags_set(struct net
*net
, struct fib6_info
*f6i
,
6227 bool offload
, bool trap
, bool offload_failed
)
6229 struct sk_buff
*skb
;
6232 if (f6i
->offload
== offload
&& f6i
->trap
== trap
&&
6233 f6i
->offload_failed
== offload_failed
)
6236 f6i
->offload
= offload
;
6239 /* 2 means send notifications only if offload_failed was changed. */
6240 if (net
->ipv6
.sysctl
.fib_notify_on_flag_change
== 2 &&
6241 f6i
->offload_failed
== offload_failed
)
6244 f6i
->offload_failed
= offload_failed
;
6246 if (!rcu_access_pointer(f6i
->fib6_node
))
6247 /* The route was removed from the tree, do not send
6252 if (!net
->ipv6
.sysctl
.fib_notify_on_flag_change
)
6255 skb
= nlmsg_new(rt6_nlmsg_size(f6i
), GFP_KERNEL
);
6261 err
= rt6_fill_node(net
, skb
, f6i
, NULL
, NULL
, NULL
, 0, RTM_NEWROUTE
, 0,
6264 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
6265 WARN_ON(err
== -EMSGSIZE
);
6270 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV6_ROUTE
, NULL
, GFP_KERNEL
);
6274 rtnl_set_sk_err(net
, RTNLGRP_IPV6_ROUTE
, err
);
6276 EXPORT_SYMBOL(fib6_info_hw_flags_set
);
6278 static int ip6_route_dev_notify(struct notifier_block
*this,
6279 unsigned long event
, void *ptr
)
6281 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
6282 struct net
*net
= dev_net(dev
);
6284 if (!(dev
->flags
& IFF_LOOPBACK
))
6287 if (event
== NETDEV_REGISTER
) {
6288 net
->ipv6
.fib6_null_entry
->fib6_nh
->fib_nh_dev
= dev
;
6289 net
->ipv6
.ip6_null_entry
->dst
.dev
= dev
;
6290 net
->ipv6
.ip6_null_entry
->rt6i_idev
= in6_dev_get(dev
);
6291 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
6292 net
->ipv6
.ip6_prohibit_entry
->dst
.dev
= dev
;
6293 net
->ipv6
.ip6_prohibit_entry
->rt6i_idev
= in6_dev_get(dev
);
6294 net
->ipv6
.ip6_blk_hole_entry
->dst
.dev
= dev
;
6295 net
->ipv6
.ip6_blk_hole_entry
->rt6i_idev
= in6_dev_get(dev
);
6297 } else if (event
== NETDEV_UNREGISTER
&&
6298 dev
->reg_state
!= NETREG_UNREGISTERED
) {
6299 /* NETDEV_UNREGISTER could be fired for multiple times by
6300 * netdev_wait_allrefs(). Make sure we only call this once.
6302 in6_dev_put_clear(&net
->ipv6
.ip6_null_entry
->rt6i_idev
);
6303 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
6304 in6_dev_put_clear(&net
->ipv6
.ip6_prohibit_entry
->rt6i_idev
);
6305 in6_dev_put_clear(&net
->ipv6
.ip6_blk_hole_entry
->rt6i_idev
);
6316 #ifdef CONFIG_PROC_FS
6317 static int rt6_stats_seq_show(struct seq_file
*seq
, void *v
)
6319 struct net
*net
= (struct net
*)seq
->private;
6320 seq_printf(seq
, "%04x %04x %04x %04x %04x %04x %04x\n",
6321 net
->ipv6
.rt6_stats
->fib_nodes
,
6322 net
->ipv6
.rt6_stats
->fib_route_nodes
,
6323 atomic_read(&net
->ipv6
.rt6_stats
->fib_rt_alloc
),
6324 net
->ipv6
.rt6_stats
->fib_rt_entries
,
6325 net
->ipv6
.rt6_stats
->fib_rt_cache
,
6326 dst_entries_get_slow(&net
->ipv6
.ip6_dst_ops
),
6327 net
->ipv6
.rt6_stats
->fib_discarded_routes
);
6331 #endif /* CONFIG_PROC_FS */
6333 #ifdef CONFIG_SYSCTL
6335 static int ipv6_sysctl_rtcache_flush(struct ctl_table
*ctl
, int write
,
6336 void *buffer
, size_t *lenp
, loff_t
*ppos
)
6344 net
= (struct net
*)ctl
->extra1
;
6345 delay
= net
->ipv6
.sysctl
.flush_delay
;
6346 ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
6350 fib6_run_gc(delay
<= 0 ? 0 : (unsigned long)delay
, net
, delay
> 0);
6354 static struct ctl_table ipv6_route_table_template
[] = {
6356 .procname
= "flush",
6357 .data
= &init_net
.ipv6
.sysctl
.flush_delay
,
6358 .maxlen
= sizeof(int),
6360 .proc_handler
= ipv6_sysctl_rtcache_flush
6363 .procname
= "gc_thresh",
6364 .data
= &ip6_dst_ops_template
.gc_thresh
,
6365 .maxlen
= sizeof(int),
6367 .proc_handler
= proc_dointvec
,
6370 .procname
= "max_size",
6371 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_max_size
,
6372 .maxlen
= sizeof(int),
6374 .proc_handler
= proc_dointvec
,
6377 .procname
= "gc_min_interval",
6378 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_min_interval
,
6379 .maxlen
= sizeof(int),
6381 .proc_handler
= proc_dointvec_jiffies
,
6384 .procname
= "gc_timeout",
6385 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_timeout
,
6386 .maxlen
= sizeof(int),
6388 .proc_handler
= proc_dointvec_jiffies
,
6391 .procname
= "gc_interval",
6392 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_interval
,
6393 .maxlen
= sizeof(int),
6395 .proc_handler
= proc_dointvec_jiffies
,
6398 .procname
= "gc_elasticity",
6399 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_elasticity
,
6400 .maxlen
= sizeof(int),
6402 .proc_handler
= proc_dointvec
,
6405 .procname
= "mtu_expires",
6406 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_mtu_expires
,
6407 .maxlen
= sizeof(int),
6409 .proc_handler
= proc_dointvec_jiffies
,
6412 .procname
= "min_adv_mss",
6413 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_min_advmss
,
6414 .maxlen
= sizeof(int),
6416 .proc_handler
= proc_dointvec
,
6419 .procname
= "gc_min_interval_ms",
6420 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_min_interval
,
6421 .maxlen
= sizeof(int),
6423 .proc_handler
= proc_dointvec_ms_jiffies
,
6426 .procname
= "skip_notify_on_dev_down",
6427 .data
= &init_net
.ipv6
.sysctl
.skip_notify_on_dev_down
,
6428 .maxlen
= sizeof(int),
6430 .proc_handler
= proc_dointvec_minmax
,
6431 .extra1
= SYSCTL_ZERO
,
6432 .extra2
= SYSCTL_ONE
,
6437 struct ctl_table
* __net_init
ipv6_route_sysctl_init(struct net
*net
)
6439 struct ctl_table
*table
;
6441 table
= kmemdup(ipv6_route_table_template
,
6442 sizeof(ipv6_route_table_template
),
6446 table
[0].data
= &net
->ipv6
.sysctl
.flush_delay
;
6447 table
[0].extra1
= net
;
6448 table
[1].data
= &net
->ipv6
.ip6_dst_ops
.gc_thresh
;
6449 table
[2].data
= &net
->ipv6
.sysctl
.ip6_rt_max_size
;
6450 table
[3].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
;
6451 table
[4].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_timeout
;
6452 table
[5].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_interval
;
6453 table
[6].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_elasticity
;
6454 table
[7].data
= &net
->ipv6
.sysctl
.ip6_rt_mtu_expires
;
6455 table
[8].data
= &net
->ipv6
.sysctl
.ip6_rt_min_advmss
;
6456 table
[9].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
;
6457 table
[10].data
= &net
->ipv6
.sysctl
.skip_notify_on_dev_down
;
6459 /* Don't export sysctls to unprivileged users */
6460 if (net
->user_ns
!= &init_user_ns
)
6461 table
[0].procname
= NULL
;
6468 static int __net_init
ip6_route_net_init(struct net
*net
)
6472 memcpy(&net
->ipv6
.ip6_dst_ops
, &ip6_dst_ops_template
,
6473 sizeof(net
->ipv6
.ip6_dst_ops
));
6475 if (dst_entries_init(&net
->ipv6
.ip6_dst_ops
) < 0)
6476 goto out_ip6_dst_ops
;
6478 net
->ipv6
.fib6_null_entry
= fib6_info_alloc(GFP_KERNEL
, true);
6479 if (!net
->ipv6
.fib6_null_entry
)
6480 goto out_ip6_dst_entries
;
6481 memcpy(net
->ipv6
.fib6_null_entry
, &fib6_null_entry_template
,
6482 sizeof(*net
->ipv6
.fib6_null_entry
));
6484 net
->ipv6
.ip6_null_entry
= kmemdup(&ip6_null_entry_template
,
6485 sizeof(*net
->ipv6
.ip6_null_entry
),
6487 if (!net
->ipv6
.ip6_null_entry
)
6488 goto out_fib6_null_entry
;
6489 net
->ipv6
.ip6_null_entry
->dst
.ops
= &net
->ipv6
.ip6_dst_ops
;
6490 dst_init_metrics(&net
->ipv6
.ip6_null_entry
->dst
,
6491 ip6_template_metrics
, true);
6492 INIT_LIST_HEAD(&net
->ipv6
.ip6_null_entry
->rt6i_uncached
);
6494 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
6495 net
->ipv6
.fib6_has_custom_rules
= false;
6496 net
->ipv6
.ip6_prohibit_entry
= kmemdup(&ip6_prohibit_entry_template
,
6497 sizeof(*net
->ipv6
.ip6_prohibit_entry
),
6499 if (!net
->ipv6
.ip6_prohibit_entry
)
6500 goto out_ip6_null_entry
;
6501 net
->ipv6
.ip6_prohibit_entry
->dst
.ops
= &net
->ipv6
.ip6_dst_ops
;
6502 dst_init_metrics(&net
->ipv6
.ip6_prohibit_entry
->dst
,
6503 ip6_template_metrics
, true);
6504 INIT_LIST_HEAD(&net
->ipv6
.ip6_prohibit_entry
->rt6i_uncached
);
6506 net
->ipv6
.ip6_blk_hole_entry
= kmemdup(&ip6_blk_hole_entry_template
,
6507 sizeof(*net
->ipv6
.ip6_blk_hole_entry
),
6509 if (!net
->ipv6
.ip6_blk_hole_entry
)
6510 goto out_ip6_prohibit_entry
;
6511 net
->ipv6
.ip6_blk_hole_entry
->dst
.ops
= &net
->ipv6
.ip6_dst_ops
;
6512 dst_init_metrics(&net
->ipv6
.ip6_blk_hole_entry
->dst
,
6513 ip6_template_metrics
, true);
6514 INIT_LIST_HEAD(&net
->ipv6
.ip6_blk_hole_entry
->rt6i_uncached
);
6515 #ifdef CONFIG_IPV6_SUBTREES
6516 net
->ipv6
.fib6_routes_require_src
= 0;
6520 net
->ipv6
.sysctl
.flush_delay
= 0;
6521 net
->ipv6
.sysctl
.ip6_rt_max_size
= 4096;
6522 net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
= HZ
/ 2;
6523 net
->ipv6
.sysctl
.ip6_rt_gc_timeout
= 60*HZ
;
6524 net
->ipv6
.sysctl
.ip6_rt_gc_interval
= 30*HZ
;
6525 net
->ipv6
.sysctl
.ip6_rt_gc_elasticity
= 9;
6526 net
->ipv6
.sysctl
.ip6_rt_mtu_expires
= 10*60*HZ
;
6527 net
->ipv6
.sysctl
.ip6_rt_min_advmss
= IPV6_MIN_MTU
- 20 - 40;
6528 net
->ipv6
.sysctl
.skip_notify_on_dev_down
= 0;
6530 net
->ipv6
.ip6_rt_gc_expire
= 30*HZ
;
6536 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
6537 out_ip6_prohibit_entry
:
6538 kfree(net
->ipv6
.ip6_prohibit_entry
);
6540 kfree(net
->ipv6
.ip6_null_entry
);
6542 out_fib6_null_entry
:
6543 kfree(net
->ipv6
.fib6_null_entry
);
6544 out_ip6_dst_entries
:
6545 dst_entries_destroy(&net
->ipv6
.ip6_dst_ops
);
6550 static void __net_exit
ip6_route_net_exit(struct net
*net
)
6552 kfree(net
->ipv6
.fib6_null_entry
);
6553 kfree(net
->ipv6
.ip6_null_entry
);
6554 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
6555 kfree(net
->ipv6
.ip6_prohibit_entry
);
6556 kfree(net
->ipv6
.ip6_blk_hole_entry
);
6558 dst_entries_destroy(&net
->ipv6
.ip6_dst_ops
);
6561 static int __net_init
ip6_route_net_init_late(struct net
*net
)
6563 #ifdef CONFIG_PROC_FS
6564 proc_create_net("ipv6_route", 0, net
->proc_net
, &ipv6_route_seq_ops
,
6565 sizeof(struct ipv6_route_iter
));
6566 proc_create_net_single("rt6_stats", 0444, net
->proc_net
,
6567 rt6_stats_seq_show
, NULL
);
6572 static void __net_exit
ip6_route_net_exit_late(struct net
*net
)
6574 #ifdef CONFIG_PROC_FS
6575 remove_proc_entry("ipv6_route", net
->proc_net
);
6576 remove_proc_entry("rt6_stats", net
->proc_net
);
6580 static struct pernet_operations ip6_route_net_ops
= {
6581 .init
= ip6_route_net_init
,
6582 .exit
= ip6_route_net_exit
,
6585 static int __net_init
ipv6_inetpeer_init(struct net
*net
)
6587 struct inet_peer_base
*bp
= kmalloc(sizeof(*bp
), GFP_KERNEL
);
6591 inet_peer_base_init(bp
);
6592 net
->ipv6
.peers
= bp
;
6596 static void __net_exit
ipv6_inetpeer_exit(struct net
*net
)
6598 struct inet_peer_base
*bp
= net
->ipv6
.peers
;
6600 net
->ipv6
.peers
= NULL
;
6601 inetpeer_invalidate_tree(bp
);
6605 static struct pernet_operations ipv6_inetpeer_ops
= {
6606 .init
= ipv6_inetpeer_init
,
6607 .exit
= ipv6_inetpeer_exit
,
6610 static struct pernet_operations ip6_route_net_late_ops
= {
6611 .init
= ip6_route_net_init_late
,
6612 .exit
= ip6_route_net_exit_late
,
6615 static struct notifier_block ip6_route_dev_notifier
= {
6616 .notifier_call
= ip6_route_dev_notify
,
6617 .priority
= ADDRCONF_NOTIFY_PRIORITY
- 10,
6620 void __init
ip6_route_init_special_entries(void)
6622 /* Registering of the loopback is done before this portion of code,
6623 * the loopback reference in rt6_info will not be taken, do it
6624 * manually for init_net */
6625 init_net
.ipv6
.fib6_null_entry
->fib6_nh
->fib_nh_dev
= init_net
.loopback_dev
;
6626 init_net
.ipv6
.ip6_null_entry
->dst
.dev
= init_net
.loopback_dev
;
6627 init_net
.ipv6
.ip6_null_entry
->rt6i_idev
= in6_dev_get(init_net
.loopback_dev
);
6628 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
6629 init_net
.ipv6
.ip6_prohibit_entry
->dst
.dev
= init_net
.loopback_dev
;
6630 init_net
.ipv6
.ip6_prohibit_entry
->rt6i_idev
= in6_dev_get(init_net
.loopback_dev
);
6631 init_net
.ipv6
.ip6_blk_hole_entry
->dst
.dev
= init_net
.loopback_dev
;
6632 init_net
.ipv6
.ip6_blk_hole_entry
->rt6i_idev
= in6_dev_get(init_net
.loopback_dev
);
6636 #if IS_BUILTIN(CONFIG_IPV6)
6637 #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_PROC_FS)
6638 DEFINE_BPF_ITER_FUNC(ipv6_route
, struct bpf_iter_meta
*meta
, struct fib6_info
*rt
)
6640 BTF_ID_LIST(btf_fib6_info_id
)
6641 BTF_ID(struct, fib6_info
)
6643 static const struct bpf_iter_seq_info ipv6_route_seq_info
= {
6644 .seq_ops
= &ipv6_route_seq_ops
,
6645 .init_seq_private
= bpf_iter_init_seq_net
,
6646 .fini_seq_private
= bpf_iter_fini_seq_net
,
6647 .seq_priv_size
= sizeof(struct ipv6_route_iter
),
6650 static struct bpf_iter_reg ipv6_route_reg_info
= {
6651 .target
= "ipv6_route",
6652 .ctx_arg_info_size
= 1,
6654 { offsetof(struct bpf_iter__ipv6_route
, rt
),
6655 PTR_TO_BTF_ID_OR_NULL
},
6657 .seq_info
= &ipv6_route_seq_info
,
6660 static int __init
bpf_iter_register(void)
6662 ipv6_route_reg_info
.ctx_arg_info
[0].btf_id
= *btf_fib6_info_id
;
6663 return bpf_iter_reg_target(&ipv6_route_reg_info
);
6666 static void bpf_iter_unregister(void)
6668 bpf_iter_unreg_target(&ipv6_route_reg_info
);
6673 int __init
ip6_route_init(void)
6679 ip6_dst_ops_template
.kmem_cachep
=
6680 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info
), 0,
6681 SLAB_HWCACHE_ALIGN
| SLAB_ACCOUNT
, NULL
);
6682 if (!ip6_dst_ops_template
.kmem_cachep
)
6685 ret
= dst_entries_init(&ip6_dst_blackhole_ops
);
6687 goto out_kmem_cache
;
6689 ret
= register_pernet_subsys(&ipv6_inetpeer_ops
);
6691 goto out_dst_entries
;
6693 ret
= register_pernet_subsys(&ip6_route_net_ops
);
6695 goto out_register_inetpeer
;
6697 ip6_dst_blackhole_ops
.kmem_cachep
= ip6_dst_ops_template
.kmem_cachep
;
6701 goto out_register_subsys
;
6707 ret
= fib6_rules_init();
6711 ret
= register_pernet_subsys(&ip6_route_net_late_ops
);
6713 goto fib6_rules_init
;
6715 ret
= rtnl_register_module(THIS_MODULE
, PF_INET6
, RTM_NEWROUTE
,
6716 inet6_rtm_newroute
, NULL
, 0);
6718 goto out_register_late_subsys
;
6720 ret
= rtnl_register_module(THIS_MODULE
, PF_INET6
, RTM_DELROUTE
,
6721 inet6_rtm_delroute
, NULL
, 0);
6723 goto out_register_late_subsys
;
6725 ret
= rtnl_register_module(THIS_MODULE
, PF_INET6
, RTM_GETROUTE
,
6726 inet6_rtm_getroute
, NULL
,
6727 RTNL_FLAG_DOIT_UNLOCKED
);
6729 goto out_register_late_subsys
;
6731 ret
= register_netdevice_notifier(&ip6_route_dev_notifier
);
6733 goto out_register_late_subsys
;
6735 #if IS_BUILTIN(CONFIG_IPV6)
6736 #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_PROC_FS)
6737 ret
= bpf_iter_register();
6739 goto out_register_late_subsys
;
6743 for_each_possible_cpu(cpu
) {
6744 struct uncached_list
*ul
= per_cpu_ptr(&rt6_uncached_list
, cpu
);
6746 INIT_LIST_HEAD(&ul
->head
);
6747 spin_lock_init(&ul
->lock
);
6753 out_register_late_subsys
:
6754 rtnl_unregister_all(PF_INET6
);
6755 unregister_pernet_subsys(&ip6_route_net_late_ops
);
6757 fib6_rules_cleanup();
6762 out_register_subsys
:
6763 unregister_pernet_subsys(&ip6_route_net_ops
);
6764 out_register_inetpeer
:
6765 unregister_pernet_subsys(&ipv6_inetpeer_ops
);
6767 dst_entries_destroy(&ip6_dst_blackhole_ops
);
6769 kmem_cache_destroy(ip6_dst_ops_template
.kmem_cachep
);
6773 void ip6_route_cleanup(void)
6775 #if IS_BUILTIN(CONFIG_IPV6)
6776 #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_PROC_FS)
6777 bpf_iter_unregister();
6780 unregister_netdevice_notifier(&ip6_route_dev_notifier
);
6781 unregister_pernet_subsys(&ip6_route_net_late_ops
);
6782 fib6_rules_cleanup();
6785 unregister_pernet_subsys(&ipv6_inetpeer_ops
);
6786 unregister_pernet_subsys(&ip6_route_net_ops
);
6787 dst_entries_destroy(&ip6_dst_blackhole_ops
);
6788 kmem_cache_destroy(ip6_dst_ops_template
.kmem_cachep
);