1 // SPDX-License-Identifier: GPL-2.0
2 /* Generic nexthop implementation
4 * Copyright (c) 2017-19 Cumulus Networks
5 * Copyright (c) 2017-19 David Ahern <dsa@cumulusnetworks.com>
8 #include <linux/nexthop.h>
9 #include <linux/rtnetlink.h>
10 #include <linux/slab.h>
12 #include <net/ipv6_stubs.h>
13 #include <net/lwtunnel.h>
14 #include <net/ndisc.h>
15 #include <net/nexthop.h>
16 #include <net/route.h>
19 static void remove_nexthop(struct net
*net
, struct nexthop
*nh
,
20 struct nl_info
*nlinfo
);
22 #define NH_DEV_HASHBITS 8
23 #define NH_DEV_HASHSIZE (1U << NH_DEV_HASHBITS)
25 static const struct nla_policy rtm_nh_policy
[NHA_MAX
+ 1] = {
26 [NHA_ID
] = { .type
= NLA_U32
},
27 [NHA_GROUP
] = { .type
= NLA_BINARY
},
28 [NHA_GROUP_TYPE
] = { .type
= NLA_U16
},
29 [NHA_BLACKHOLE
] = { .type
= NLA_FLAG
},
30 [NHA_OIF
] = { .type
= NLA_U32
},
31 [NHA_GATEWAY
] = { .type
= NLA_BINARY
},
32 [NHA_ENCAP_TYPE
] = { .type
= NLA_U16
},
33 [NHA_ENCAP
] = { .type
= NLA_NESTED
},
34 [NHA_GROUPS
] = { .type
= NLA_FLAG
},
35 [NHA_MASTER
] = { .type
= NLA_U32
},
36 [NHA_FDB
] = { .type
= NLA_FLAG
},
39 static int call_nexthop_notifiers(struct net
*net
,
40 enum nexthop_event_type event_type
,
45 err
= blocking_notifier_call_chain(&net
->nexthop
.notifier_chain
,
47 return notifier_to_errno(err
);
50 static unsigned int nh_dev_hashfn(unsigned int val
)
52 unsigned int mask
= NH_DEV_HASHSIZE
- 1;
55 (val
>> NH_DEV_HASHBITS
) ^
56 (val
>> (NH_DEV_HASHBITS
* 2))) & mask
;
59 static void nexthop_devhash_add(struct net
*net
, struct nh_info
*nhi
)
61 struct net_device
*dev
= nhi
->fib_nhc
.nhc_dev
;
62 struct hlist_head
*head
;
67 hash
= nh_dev_hashfn(dev
->ifindex
);
68 head
= &net
->nexthop
.devhash
[hash
];
69 hlist_add_head(&nhi
->dev_hash
, head
);
72 static void nexthop_free_mpath(struct nexthop
*nh
)
77 nhg
= rcu_dereference_raw(nh
->nh_grp
);
78 for (i
= 0; i
< nhg
->num_nh
; ++i
) {
79 struct nh_grp_entry
*nhge
= &nhg
->nh_entries
[i
];
81 WARN_ON(!list_empty(&nhge
->nh_list
));
82 nexthop_put(nhge
->nh
);
85 WARN_ON(nhg
->spare
== nhg
);
91 static void nexthop_free_single(struct nexthop
*nh
)
95 nhi
= rcu_dereference_raw(nh
->nh_info
);
96 switch (nhi
->family
) {
98 fib_nh_release(nh
->net
, &nhi
->fib_nh
);
101 ipv6_stub
->fib6_nh_release(&nhi
->fib6_nh
);
107 void nexthop_free_rcu(struct rcu_head
*head
)
109 struct nexthop
*nh
= container_of(head
, struct nexthop
, rcu
);
112 nexthop_free_mpath(nh
);
114 nexthop_free_single(nh
);
118 EXPORT_SYMBOL_GPL(nexthop_free_rcu
);
120 static struct nexthop
*nexthop_alloc(void)
124 nh
= kzalloc(sizeof(struct nexthop
), GFP_KERNEL
);
126 INIT_LIST_HEAD(&nh
->fi_list
);
127 INIT_LIST_HEAD(&nh
->f6i_list
);
128 INIT_LIST_HEAD(&nh
->grp_list
);
129 INIT_LIST_HEAD(&nh
->fdb_list
);
134 static struct nh_group
*nexthop_grp_alloc(u16 num_nh
)
136 struct nh_group
*nhg
;
138 nhg
= kzalloc(struct_size(nhg
, nh_entries
, num_nh
), GFP_KERNEL
);
140 nhg
->num_nh
= num_nh
;
145 static void nh_base_seq_inc(struct net
*net
)
147 while (++net
->nexthop
.seq
== 0)
151 /* no reference taken; rcu lock or rtnl must be held */
152 struct nexthop
*nexthop_find_by_id(struct net
*net
, u32 id
)
154 struct rb_node
**pp
, *parent
= NULL
, *next
;
156 pp
= &net
->nexthop
.rb_root
.rb_node
;
160 next
= rcu_dereference_raw(*pp
);
165 nh
= rb_entry(parent
, struct nexthop
, rb_node
);
168 else if (id
> nh
->id
)
169 pp
= &next
->rb_right
;
175 EXPORT_SYMBOL_GPL(nexthop_find_by_id
);
177 /* used for auto id allocation; called with rtnl held */
178 static u32
nh_find_unused_id(struct net
*net
)
180 u32 id_start
= net
->nexthop
.last_id_allocated
;
183 net
->nexthop
.last_id_allocated
++;
184 if (net
->nexthop
.last_id_allocated
== id_start
)
187 if (!nexthop_find_by_id(net
, net
->nexthop
.last_id_allocated
))
188 return net
->nexthop
.last_id_allocated
;
193 static int nla_put_nh_group(struct sk_buff
*skb
, struct nh_group
*nhg
)
195 struct nexthop_grp
*p
;
196 size_t len
= nhg
->num_nh
* sizeof(*p
);
202 group_type
= NEXTHOP_GRP_TYPE_MPATH
;
204 if (nla_put_u16(skb
, NHA_GROUP_TYPE
, group_type
))
205 goto nla_put_failure
;
207 nla
= nla_reserve(skb
, NHA_GROUP
, len
);
209 goto nla_put_failure
;
212 for (i
= 0; i
< nhg
->num_nh
; ++i
) {
213 p
->id
= nhg
->nh_entries
[i
].nh
->id
;
214 p
->weight
= nhg
->nh_entries
[i
].weight
- 1;
224 static int nh_fill_node(struct sk_buff
*skb
, struct nexthop
*nh
,
225 int event
, u32 portid
, u32 seq
, unsigned int nlflags
)
227 struct fib6_nh
*fib6_nh
;
228 struct fib_nh
*fib_nh
;
229 struct nlmsghdr
*nlh
;
233 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*nhm
), nlflags
);
237 nhm
= nlmsg_data(nlh
);
238 nhm
->nh_family
= AF_UNSPEC
;
239 nhm
->nh_flags
= nh
->nh_flags
;
240 nhm
->nh_protocol
= nh
->protocol
;
244 if (nla_put_u32(skb
, NHA_ID
, nh
->id
))
245 goto nla_put_failure
;
248 struct nh_group
*nhg
= rtnl_dereference(nh
->nh_grp
);
250 if (nhg
->fdb_nh
&& nla_put_flag(skb
, NHA_FDB
))
251 goto nla_put_failure
;
252 if (nla_put_nh_group(skb
, nhg
))
253 goto nla_put_failure
;
257 nhi
= rtnl_dereference(nh
->nh_info
);
258 nhm
->nh_family
= nhi
->family
;
259 if (nhi
->reject_nh
) {
260 if (nla_put_flag(skb
, NHA_BLACKHOLE
))
261 goto nla_put_failure
;
263 } else if (nhi
->fdb_nh
) {
264 if (nla_put_flag(skb
, NHA_FDB
))
265 goto nla_put_failure
;
267 const struct net_device
*dev
;
269 dev
= nhi
->fib_nhc
.nhc_dev
;
270 if (dev
&& nla_put_u32(skb
, NHA_OIF
, dev
->ifindex
))
271 goto nla_put_failure
;
274 nhm
->nh_scope
= nhi
->fib_nhc
.nhc_scope
;
275 switch (nhi
->family
) {
277 fib_nh
= &nhi
->fib_nh
;
278 if (fib_nh
->fib_nh_gw_family
&&
279 nla_put_be32(skb
, NHA_GATEWAY
, fib_nh
->fib_nh_gw4
))
280 goto nla_put_failure
;
284 fib6_nh
= &nhi
->fib6_nh
;
285 if (fib6_nh
->fib_nh_gw_family
&&
286 nla_put_in6_addr(skb
, NHA_GATEWAY
, &fib6_nh
->fib_nh_gw6
))
287 goto nla_put_failure
;
291 if (nhi
->fib_nhc
.nhc_lwtstate
&&
292 lwtunnel_fill_encap(skb
, nhi
->fib_nhc
.nhc_lwtstate
,
293 NHA_ENCAP
, NHA_ENCAP_TYPE
) < 0)
294 goto nla_put_failure
;
301 nlmsg_cancel(skb
, nlh
);
305 static size_t nh_nlmsg_size_grp(struct nexthop
*nh
)
307 struct nh_group
*nhg
= rtnl_dereference(nh
->nh_grp
);
308 size_t sz
= sizeof(struct nexthop_grp
) * nhg
->num_nh
;
310 return nla_total_size(sz
) +
311 nla_total_size(2); /* NHA_GROUP_TYPE */
314 static size_t nh_nlmsg_size_single(struct nexthop
*nh
)
316 struct nh_info
*nhi
= rtnl_dereference(nh
->nh_info
);
319 /* covers NHA_BLACKHOLE since NHA_OIF and BLACKHOLE
320 * are mutually exclusive
322 sz
= nla_total_size(4); /* NHA_OIF */
324 switch (nhi
->family
) {
326 if (nhi
->fib_nh
.fib_nh_gw_family
)
327 sz
+= nla_total_size(4); /* NHA_GATEWAY */
332 if (nhi
->fib6_nh
.fib_nh_gw_family
)
333 sz
+= nla_total_size(sizeof(const struct in6_addr
));
337 if (nhi
->fib_nhc
.nhc_lwtstate
) {
338 sz
+= lwtunnel_get_encap_size(nhi
->fib_nhc
.nhc_lwtstate
);
339 sz
+= nla_total_size(2); /* NHA_ENCAP_TYPE */
345 static size_t nh_nlmsg_size(struct nexthop
*nh
)
347 size_t sz
= NLMSG_ALIGN(sizeof(struct nhmsg
));
349 sz
+= nla_total_size(4); /* NHA_ID */
352 sz
+= nh_nlmsg_size_grp(nh
);
354 sz
+= nh_nlmsg_size_single(nh
);
359 static void nexthop_notify(int event
, struct nexthop
*nh
, struct nl_info
*info
)
361 unsigned int nlflags
= info
->nlh
? info
->nlh
->nlmsg_flags
: 0;
362 u32 seq
= info
->nlh
? info
->nlh
->nlmsg_seq
: 0;
366 skb
= nlmsg_new(nh_nlmsg_size(nh
), gfp_any());
370 err
= nh_fill_node(skb
, nh
, event
, info
->portid
, seq
, nlflags
);
372 /* -EMSGSIZE implies BUG in nh_nlmsg_size() */
373 WARN_ON(err
== -EMSGSIZE
);
378 rtnl_notify(skb
, info
->nl_net
, info
->portid
, RTNLGRP_NEXTHOP
,
379 info
->nlh
, gfp_any());
383 rtnl_set_sk_err(info
->nl_net
, RTNLGRP_NEXTHOP
, err
);
386 static bool valid_group_nh(struct nexthop
*nh
, unsigned int npaths
,
387 bool *is_fdb
, struct netlink_ext_ack
*extack
)
390 struct nh_group
*nhg
= rtnl_dereference(nh
->nh_grp
);
392 /* nested multipath (group within a group) is not
396 NL_SET_ERR_MSG(extack
,
397 "Multipath group can not be a nexthop within a group");
400 *is_fdb
= nhg
->fdb_nh
;
402 struct nh_info
*nhi
= rtnl_dereference(nh
->nh_info
);
404 if (nhi
->reject_nh
&& npaths
> 1) {
405 NL_SET_ERR_MSG(extack
,
406 "Blackhole nexthop can not be used in a group with more than 1 path");
409 *is_fdb
= nhi
->fdb_nh
;
415 static int nh_check_attr_fdb_group(struct nexthop
*nh
, u8
*nh_family
,
416 struct netlink_ext_ack
*extack
)
420 nhi
= rtnl_dereference(nh
->nh_info
);
423 NL_SET_ERR_MSG(extack
, "FDB nexthop group can only have fdb nexthops");
427 if (*nh_family
== AF_UNSPEC
) {
428 *nh_family
= nhi
->family
;
429 } else if (*nh_family
!= nhi
->family
) {
430 NL_SET_ERR_MSG(extack
, "FDB nexthop group cannot have mixed family nexthops");
437 static int nh_check_attr_group(struct net
*net
, struct nlattr
*tb
[],
438 struct netlink_ext_ack
*extack
)
440 unsigned int len
= nla_len(tb
[NHA_GROUP
]);
441 u8 nh_family
= AF_UNSPEC
;
442 struct nexthop_grp
*nhg
;
446 if (!len
|| len
& (sizeof(struct nexthop_grp
) - 1)) {
447 NL_SET_ERR_MSG(extack
,
448 "Invalid length for nexthop group attribute");
452 /* convert len to number of nexthop ids */
455 nhg
= nla_data(tb
[NHA_GROUP
]);
456 for (i
= 0; i
< len
; ++i
) {
457 if (nhg
[i
].resvd1
|| nhg
[i
].resvd2
) {
458 NL_SET_ERR_MSG(extack
, "Reserved fields in nexthop_grp must be 0");
461 if (nhg
[i
].weight
> 254) {
462 NL_SET_ERR_MSG(extack
, "Invalid value for weight");
465 for (j
= i
+ 1; j
< len
; ++j
) {
466 if (nhg
[i
].id
== nhg
[j
].id
) {
467 NL_SET_ERR_MSG(extack
, "Nexthop id can not be used twice in a group");
475 nhg
= nla_data(tb
[NHA_GROUP
]);
476 for (i
= 0; i
< len
; ++i
) {
480 nh
= nexthop_find_by_id(net
, nhg
[i
].id
);
482 NL_SET_ERR_MSG(extack
, "Invalid nexthop id");
485 if (!valid_group_nh(nh
, len
, &is_fdb_nh
, extack
))
488 if (nhg_fdb
&& nh_check_attr_fdb_group(nh
, &nh_family
, extack
))
491 if (!nhg_fdb
&& is_fdb_nh
) {
492 NL_SET_ERR_MSG(extack
, "Non FDB nexthop group cannot have fdb nexthops");
496 for (i
= NHA_GROUP_TYPE
+ 1; i
< __NHA_MAX
; ++i
) {
501 NL_SET_ERR_MSG(extack
,
502 "No other attributes can be set in nexthop groups");
509 static bool ipv6_good_nh(const struct fib6_nh
*nh
)
511 int state
= NUD_REACHABLE
;
516 n
= __ipv6_neigh_lookup_noref_stub(nh
->fib_nh_dev
, &nh
->fib_nh_gw6
);
518 state
= n
->nud_state
;
520 rcu_read_unlock_bh();
522 return !!(state
& NUD_VALID
);
525 static bool ipv4_good_nh(const struct fib_nh
*nh
)
527 int state
= NUD_REACHABLE
;
532 n
= __ipv4_neigh_lookup_noref(nh
->fib_nh_dev
,
533 (__force u32
)nh
->fib_nh_gw4
);
535 state
= n
->nud_state
;
537 rcu_read_unlock_bh();
539 return !!(state
& NUD_VALID
);
542 struct nexthop
*nexthop_select_path(struct nexthop
*nh
, int hash
)
544 struct nexthop
*rc
= NULL
;
545 struct nh_group
*nhg
;
551 nhg
= rcu_dereference(nh
->nh_grp
);
552 for (i
= 0; i
< nhg
->num_nh
; ++i
) {
553 struct nh_grp_entry
*nhge
= &nhg
->nh_entries
[i
];
556 if (hash
> atomic_read(&nhge
->upper_bound
))
559 nhi
= rcu_dereference(nhge
->nh
->nh_info
);
563 /* nexthops always check if it is good and does
564 * not rely on a sysctl for this behavior
566 switch (nhi
->family
) {
568 if (ipv4_good_nh(&nhi
->fib_nh
))
572 if (ipv6_good_nh(&nhi
->fib6_nh
))
583 EXPORT_SYMBOL_GPL(nexthop_select_path
);
585 int nexthop_for_each_fib6_nh(struct nexthop
*nh
,
586 int (*cb
)(struct fib6_nh
*nh
, void *arg
),
593 struct nh_group
*nhg
;
596 nhg
= rcu_dereference_rtnl(nh
->nh_grp
);
597 for (i
= 0; i
< nhg
->num_nh
; i
++) {
598 struct nh_grp_entry
*nhge
= &nhg
->nh_entries
[i
];
600 nhi
= rcu_dereference_rtnl(nhge
->nh
->nh_info
);
601 err
= cb(&nhi
->fib6_nh
, arg
);
606 nhi
= rcu_dereference_rtnl(nh
->nh_info
);
607 err
= cb(&nhi
->fib6_nh
, arg
);
614 EXPORT_SYMBOL_GPL(nexthop_for_each_fib6_nh
);
616 static int check_src_addr(const struct in6_addr
*saddr
,
617 struct netlink_ext_ack
*extack
)
619 if (!ipv6_addr_any(saddr
)) {
620 NL_SET_ERR_MSG(extack
, "IPv6 routes using source address can not use nexthop objects");
626 int fib6_check_nexthop(struct nexthop
*nh
, struct fib6_config
*cfg
,
627 struct netlink_ext_ack
*extack
)
632 /* fib6_src is unique to a fib6_info and limits the ability to cache
633 * routes in fib6_nh within a nexthop that is potentially shared
634 * across multiple fib entries. If the config wants to use source
635 * routing it can not use nexthop objects. mlxsw also does not allow
636 * fib6_src on routes.
638 if (cfg
&& check_src_addr(&cfg
->fc_src
, extack
) < 0)
642 struct nh_group
*nhg
;
644 nhg
= rtnl_dereference(nh
->nh_grp
);
647 is_fdb_nh
= nhg
->fdb_nh
;
649 nhi
= rtnl_dereference(nh
->nh_info
);
650 if (nhi
->family
== AF_INET
)
652 is_fdb_nh
= nhi
->fdb_nh
;
656 NL_SET_ERR_MSG(extack
, "Route cannot point to a fdb nexthop");
662 NL_SET_ERR_MSG(extack
, "IPv6 routes can not use an IPv4 nexthop");
665 EXPORT_SYMBOL_GPL(fib6_check_nexthop
);
667 /* if existing nexthop has ipv6 routes linked to it, need
668 * to verify this new spec works with ipv6
670 static int fib6_check_nh_list(struct nexthop
*old
, struct nexthop
*new,
671 struct netlink_ext_ack
*extack
)
673 struct fib6_info
*f6i
;
675 if (list_empty(&old
->f6i_list
))
678 list_for_each_entry(f6i
, &old
->f6i_list
, nh_list
) {
679 if (check_src_addr(&f6i
->fib6_src
.addr
, extack
) < 0)
683 return fib6_check_nexthop(new, NULL
, extack
);
686 static int nexthop_check_scope(struct nh_info
*nhi
, u8 scope
,
687 struct netlink_ext_ack
*extack
)
689 if (scope
== RT_SCOPE_HOST
&& nhi
->fib_nhc
.nhc_gw_family
) {
690 NL_SET_ERR_MSG(extack
,
691 "Route with host scope can not have a gateway");
695 if (nhi
->fib_nhc
.nhc_flags
& RTNH_F_ONLINK
&& scope
>= RT_SCOPE_LINK
) {
696 NL_SET_ERR_MSG(extack
, "Scope mismatch with nexthop");
703 /* Invoked by fib add code to verify nexthop by id is ok with
704 * config for prefix; parts of fib_check_nh not done when nexthop
707 int fib_check_nexthop(struct nexthop
*nh
, u8 scope
,
708 struct netlink_ext_ack
*extack
)
714 struct nh_group
*nhg
;
716 nhg
= rtnl_dereference(nh
->nh_grp
);
718 NL_SET_ERR_MSG(extack
, "Route cannot point to a fdb nexthop");
723 if (scope
== RT_SCOPE_HOST
) {
724 NL_SET_ERR_MSG(extack
, "Route with host scope can not have multiple nexthops");
729 /* all nexthops in a group have the same scope */
730 nhi
= rtnl_dereference(nhg
->nh_entries
[0].nh
->nh_info
);
731 err
= nexthop_check_scope(nhi
, scope
, extack
);
733 nhi
= rtnl_dereference(nh
->nh_info
);
735 NL_SET_ERR_MSG(extack
, "Route cannot point to a fdb nexthop");
739 err
= nexthop_check_scope(nhi
, scope
, extack
);
746 static int fib_check_nh_list(struct nexthop
*old
, struct nexthop
*new,
747 struct netlink_ext_ack
*extack
)
751 list_for_each_entry(fi
, &old
->fi_list
, nh_list
) {
754 err
= fib_check_nexthop(new, fi
->fib_scope
, extack
);
761 static void nh_group_rebalance(struct nh_group
*nhg
)
767 for (i
= 0; i
< nhg
->num_nh
; ++i
)
768 total
+= nhg
->nh_entries
[i
].weight
;
770 for (i
= 0; i
< nhg
->num_nh
; ++i
) {
771 struct nh_grp_entry
*nhge
= &nhg
->nh_entries
[i
];
775 upper_bound
= DIV_ROUND_CLOSEST_ULL((u64
)w
<< 31, total
) - 1;
776 atomic_set(&nhge
->upper_bound
, upper_bound
);
780 static void remove_nh_grp_entry(struct net
*net
, struct nh_grp_entry
*nhge
,
781 struct nl_info
*nlinfo
)
783 struct nh_grp_entry
*nhges
, *new_nhges
;
784 struct nexthop
*nhp
= nhge
->nh_parent
;
785 struct nexthop
*nh
= nhge
->nh
;
786 struct nh_group
*nhg
, *newg
;
791 nhg
= rtnl_dereference(nhp
->nh_grp
);
794 /* last entry, keep it visible and remove the parent */
795 if (nhg
->num_nh
== 1) {
796 remove_nexthop(net
, nhp
, nlinfo
);
800 newg
->has_v4
= false;
801 newg
->mpath
= nhg
->mpath
;
802 newg
->fdb_nh
= nhg
->fdb_nh
;
803 newg
->num_nh
= nhg
->num_nh
;
805 /* copy old entries to new except the one getting removed */
806 nhges
= nhg
->nh_entries
;
807 new_nhges
= newg
->nh_entries
;
808 for (i
= 0, j
= 0; i
< nhg
->num_nh
; ++i
) {
811 /* current nexthop getting removed */
812 if (nhg
->nh_entries
[i
].nh
== nh
) {
817 nhi
= rtnl_dereference(nhges
[i
].nh
->nh_info
);
818 if (nhi
->family
== AF_INET
)
821 list_del(&nhges
[i
].nh_list
);
822 new_nhges
[j
].nh_parent
= nhges
[i
].nh_parent
;
823 new_nhges
[j
].nh
= nhges
[i
].nh
;
824 new_nhges
[j
].weight
= nhges
[i
].weight
;
825 list_add(&new_nhges
[j
].nh_list
, &new_nhges
[j
].nh
->grp_list
);
829 nh_group_rebalance(newg
);
830 rcu_assign_pointer(nhp
->nh_grp
, newg
);
832 list_del(&nhge
->nh_list
);
833 nexthop_put(nhge
->nh
);
836 nexthop_notify(RTM_NEWNEXTHOP
, nhp
, nlinfo
);
839 static void remove_nexthop_from_groups(struct net
*net
, struct nexthop
*nh
,
840 struct nl_info
*nlinfo
)
842 struct nh_grp_entry
*nhge
, *tmp
;
844 list_for_each_entry_safe(nhge
, tmp
, &nh
->grp_list
, nh_list
)
845 remove_nh_grp_entry(net
, nhge
, nlinfo
);
847 /* make sure all see the newly published array before releasing rtnl */
851 static void remove_nexthop_group(struct nexthop
*nh
, struct nl_info
*nlinfo
)
853 struct nh_group
*nhg
= rcu_dereference_rtnl(nh
->nh_grp
);
854 int i
, num_nh
= nhg
->num_nh
;
856 for (i
= 0; i
< num_nh
; ++i
) {
857 struct nh_grp_entry
*nhge
= &nhg
->nh_entries
[i
];
859 if (WARN_ON(!nhge
->nh
))
862 list_del_init(&nhge
->nh_list
);
866 /* not called for nexthop replace */
867 static void __remove_nexthop_fib(struct net
*net
, struct nexthop
*nh
)
869 struct fib6_info
*f6i
, *tmp
;
870 bool do_flush
= false;
873 list_for_each_entry(fi
, &nh
->fi_list
, nh_list
) {
874 fi
->fib_flags
|= RTNH_F_DEAD
;
880 /* ip6_del_rt removes the entry from this list hence the _safe */
881 list_for_each_entry_safe(f6i
, tmp
, &nh
->f6i_list
, nh_list
) {
882 /* __ip6_del_rt does a release, so do a hold here */
884 ipv6_stub
->ip6_del_rt(net
, f6i
,
885 !net
->ipv4
.sysctl_nexthop_compat_mode
);
889 static void __remove_nexthop(struct net
*net
, struct nexthop
*nh
,
890 struct nl_info
*nlinfo
)
892 __remove_nexthop_fib(net
, nh
);
895 remove_nexthop_group(nh
, nlinfo
);
899 nhi
= rtnl_dereference(nh
->nh_info
);
900 if (nhi
->fib_nhc
.nhc_dev
)
901 hlist_del(&nhi
->dev_hash
);
903 remove_nexthop_from_groups(net
, nh
, nlinfo
);
907 static void remove_nexthop(struct net
*net
, struct nexthop
*nh
,
908 struct nl_info
*nlinfo
)
910 call_nexthop_notifiers(net
, NEXTHOP_EVENT_DEL
, nh
);
912 /* remove from the tree */
913 rb_erase(&nh
->rb_node
, &net
->nexthop
.rb_root
);
916 nexthop_notify(RTM_DELNEXTHOP
, nh
, nlinfo
);
918 __remove_nexthop(net
, nh
, nlinfo
);
919 nh_base_seq_inc(net
);
924 /* if any FIB entries reference this nexthop, any dst entries
925 * need to be regenerated
927 static void nh_rt_cache_flush(struct net
*net
, struct nexthop
*nh
)
929 struct fib6_info
*f6i
;
931 if (!list_empty(&nh
->fi_list
))
934 list_for_each_entry(f6i
, &nh
->f6i_list
, nh_list
)
935 ipv6_stub
->fib6_update_sernum(net
, f6i
);
938 static int replace_nexthop_grp(struct net
*net
, struct nexthop
*old
,
940 struct netlink_ext_ack
*extack
)
942 struct nh_group
*oldg
, *newg
;
945 if (!new->is_group
) {
946 NL_SET_ERR_MSG(extack
, "Can not replace a nexthop group with a nexthop.");
950 oldg
= rtnl_dereference(old
->nh_grp
);
951 newg
= rtnl_dereference(new->nh_grp
);
953 /* update parents - used by nexthop code for cleanup */
954 for (i
= 0; i
< newg
->num_nh
; i
++)
955 newg
->nh_entries
[i
].nh_parent
= old
;
957 rcu_assign_pointer(old
->nh_grp
, newg
);
959 for (i
= 0; i
< oldg
->num_nh
; i
++)
960 oldg
->nh_entries
[i
].nh_parent
= new;
962 rcu_assign_pointer(new->nh_grp
, oldg
);
967 static void nh_group_v4_update(struct nh_group
*nhg
)
969 struct nh_grp_entry
*nhges
;
973 nhges
= nhg
->nh_entries
;
974 for (i
= 0; i
< nhg
->num_nh
; i
++) {
977 nhi
= rtnl_dereference(nhges
[i
].nh
->nh_info
);
978 if (nhi
->family
== AF_INET
)
981 nhg
->has_v4
= has_v4
;
984 static int replace_nexthop_single(struct net
*net
, struct nexthop
*old
,
986 struct netlink_ext_ack
*extack
)
988 struct nh_info
*oldi
, *newi
;
991 NL_SET_ERR_MSG(extack
, "Can not replace a nexthop with a nexthop group.");
995 oldi
= rtnl_dereference(old
->nh_info
);
996 newi
= rtnl_dereference(new->nh_info
);
998 newi
->nh_parent
= old
;
999 oldi
->nh_parent
= new;
1001 old
->protocol
= new->protocol
;
1002 old
->nh_flags
= new->nh_flags
;
1004 rcu_assign_pointer(old
->nh_info
, newi
);
1005 rcu_assign_pointer(new->nh_info
, oldi
);
1007 /* When replacing an IPv4 nexthop with an IPv6 nexthop, potentially
1008 * update IPv4 indication in all the groups using the nexthop.
1010 if (oldi
->family
== AF_INET
&& newi
->family
== AF_INET6
) {
1011 struct nh_grp_entry
*nhge
;
1013 list_for_each_entry(nhge
, &old
->grp_list
, nh_list
) {
1014 struct nexthop
*nhp
= nhge
->nh_parent
;
1015 struct nh_group
*nhg
;
1017 nhg
= rtnl_dereference(nhp
->nh_grp
);
1018 nh_group_v4_update(nhg
);
1025 static void __nexthop_replace_notify(struct net
*net
, struct nexthop
*nh
,
1026 struct nl_info
*info
)
1028 struct fib6_info
*f6i
;
1030 if (!list_empty(&nh
->fi_list
)) {
1031 struct fib_info
*fi
;
1033 /* expectation is a few fib_info per nexthop and then
1034 * a lot of routes per fib_info. So mark the fib_info
1035 * and then walk the fib tables once
1037 list_for_each_entry(fi
, &nh
->fi_list
, nh_list
)
1038 fi
->nh_updated
= true;
1040 fib_info_notify_update(net
, info
);
1042 list_for_each_entry(fi
, &nh
->fi_list
, nh_list
)
1043 fi
->nh_updated
= false;
1046 list_for_each_entry(f6i
, &nh
->f6i_list
, nh_list
)
1047 ipv6_stub
->fib6_rt_update(net
, f6i
, info
);
1050 /* send RTM_NEWROUTE with REPLACE flag set for all FIB entries
1051 * linked to this nexthop and for all groups that the nexthop
1054 static void nexthop_replace_notify(struct net
*net
, struct nexthop
*nh
,
1055 struct nl_info
*info
)
1057 struct nh_grp_entry
*nhge
;
1059 __nexthop_replace_notify(net
, nh
, info
);
1061 list_for_each_entry(nhge
, &nh
->grp_list
, nh_list
)
1062 __nexthop_replace_notify(net
, nhge
->nh_parent
, info
);
1065 static int replace_nexthop(struct net
*net
, struct nexthop
*old
,
1066 struct nexthop
*new, struct netlink_ext_ack
*extack
)
1068 bool new_is_reject
= false;
1069 struct nh_grp_entry
*nhge
;
1072 /* check that existing FIB entries are ok with the
1073 * new nexthop definition
1075 err
= fib_check_nh_list(old
, new, extack
);
1079 err
= fib6_check_nh_list(old
, new, extack
);
1083 if (!new->is_group
) {
1084 struct nh_info
*nhi
= rtnl_dereference(new->nh_info
);
1086 new_is_reject
= nhi
->reject_nh
;
1089 list_for_each_entry(nhge
, &old
->grp_list
, nh_list
) {
1090 /* if new nexthop is a blackhole, any groups using this
1091 * nexthop cannot have more than 1 path
1093 if (new_is_reject
&&
1094 nexthop_num_path(nhge
->nh_parent
) > 1) {
1095 NL_SET_ERR_MSG(extack
, "Blackhole nexthop can not be a member of a group with more than one path");
1099 err
= fib_check_nh_list(nhge
->nh_parent
, new, extack
);
1103 err
= fib6_check_nh_list(nhge
->nh_parent
, new, extack
);
1109 err
= replace_nexthop_grp(net
, old
, new, extack
);
1111 err
= replace_nexthop_single(net
, old
, new, extack
);
1114 nh_rt_cache_flush(net
, old
);
1116 __remove_nexthop(net
, new, NULL
);
1123 /* called with rtnl_lock held */
1124 static int insert_nexthop(struct net
*net
, struct nexthop
*new_nh
,
1125 struct nh_config
*cfg
, struct netlink_ext_ack
*extack
)
1127 struct rb_node
**pp
, *parent
= NULL
, *next
;
1128 struct rb_root
*root
= &net
->nexthop
.rb_root
;
1129 bool replace
= !!(cfg
->nlflags
& NLM_F_REPLACE
);
1130 bool create
= !!(cfg
->nlflags
& NLM_F_CREATE
);
1131 u32 new_id
= new_nh
->id
;
1132 int replace_notify
= 0;
1135 pp
= &root
->rb_node
;
1145 nh
= rb_entry(parent
, struct nexthop
, rb_node
);
1146 if (new_id
< nh
->id
) {
1147 pp
= &next
->rb_left
;
1148 } else if (new_id
> nh
->id
) {
1149 pp
= &next
->rb_right
;
1150 } else if (replace
) {
1151 rc
= replace_nexthop(net
, nh
, new_nh
, extack
);
1153 new_nh
= nh
; /* send notification with old nh */
1158 /* id already exists and not a replace */
1163 if (replace
&& !create
) {
1164 NL_SET_ERR_MSG(extack
, "Replace specified without create and no entry exists");
1169 rb_link_node_rcu(&new_nh
->rb_node
, parent
, pp
);
1170 rb_insert_color(&new_nh
->rb_node
, root
);
1174 nh_base_seq_inc(net
);
1175 nexthop_notify(RTM_NEWNEXTHOP
, new_nh
, &cfg
->nlinfo
);
1176 if (replace_notify
&& net
->ipv4
.sysctl_nexthop_compat_mode
)
1177 nexthop_replace_notify(net
, new_nh
, &cfg
->nlinfo
);
1184 /* remove all nexthops tied to a device being deleted */
1185 static void nexthop_flush_dev(struct net_device
*dev
)
1187 unsigned int hash
= nh_dev_hashfn(dev
->ifindex
);
1188 struct net
*net
= dev_net(dev
);
1189 struct hlist_head
*head
= &net
->nexthop
.devhash
[hash
];
1190 struct hlist_node
*n
;
1191 struct nh_info
*nhi
;
1193 hlist_for_each_entry_safe(nhi
, n
, head
, dev_hash
) {
1194 if (nhi
->fib_nhc
.nhc_dev
!= dev
)
1197 remove_nexthop(net
, nhi
->nh_parent
, NULL
);
1201 /* rtnl; called when net namespace is deleted */
1202 static void flush_all_nexthops(struct net
*net
)
1204 struct rb_root
*root
= &net
->nexthop
.rb_root
;
1205 struct rb_node
*node
;
1208 while ((node
= rb_first(root
))) {
1209 nh
= rb_entry(node
, struct nexthop
, rb_node
);
1210 remove_nexthop(net
, nh
, NULL
);
1215 static struct nexthop
*nexthop_create_group(struct net
*net
,
1216 struct nh_config
*cfg
)
1218 struct nlattr
*grps_attr
= cfg
->nh_grp
;
1219 struct nexthop_grp
*entry
= nla_data(grps_attr
);
1220 u16 num_nh
= nla_len(grps_attr
) / sizeof(*entry
);
1221 struct nh_group
*nhg
;
1225 if (WARN_ON(!num_nh
))
1226 return ERR_PTR(-EINVAL
);
1228 nh
= nexthop_alloc();
1230 return ERR_PTR(-ENOMEM
);
1234 nhg
= nexthop_grp_alloc(num_nh
);
1237 return ERR_PTR(-ENOMEM
);
1240 /* spare group used for removals */
1241 nhg
->spare
= nexthop_grp_alloc(num_nh
);
1245 return ERR_PTR(-ENOMEM
);
1247 nhg
->spare
->spare
= nhg
;
1249 for (i
= 0; i
< nhg
->num_nh
; ++i
) {
1250 struct nexthop
*nhe
;
1251 struct nh_info
*nhi
;
1253 nhe
= nexthop_find_by_id(net
, entry
[i
].id
);
1254 if (!nexthop_get(nhe
))
1257 nhi
= rtnl_dereference(nhe
->nh_info
);
1258 if (nhi
->family
== AF_INET
)
1261 nhg
->nh_entries
[i
].nh
= nhe
;
1262 nhg
->nh_entries
[i
].weight
= entry
[i
].weight
+ 1;
1263 list_add(&nhg
->nh_entries
[i
].nh_list
, &nhe
->grp_list
);
1264 nhg
->nh_entries
[i
].nh_parent
= nh
;
1267 if (cfg
->nh_grp_type
== NEXTHOP_GRP_TYPE_MPATH
) {
1269 nh_group_rebalance(nhg
);
1275 rcu_assign_pointer(nh
->nh_grp
, nhg
);
1281 nexthop_put(nhg
->nh_entries
[i
].nh
);
1287 return ERR_PTR(-ENOENT
);
1290 static int nh_create_ipv4(struct net
*net
, struct nexthop
*nh
,
1291 struct nh_info
*nhi
, struct nh_config
*cfg
,
1292 struct netlink_ext_ack
*extack
)
1294 struct fib_nh
*fib_nh
= &nhi
->fib_nh
;
1295 struct fib_config fib_cfg
= {
1296 .fc_oif
= cfg
->nh_ifindex
,
1297 .fc_gw4
= cfg
->gw
.ipv4
,
1298 .fc_gw_family
= cfg
->gw
.ipv4
? AF_INET
: 0,
1299 .fc_flags
= cfg
->nh_flags
,
1300 .fc_encap
= cfg
->nh_encap
,
1301 .fc_encap_type
= cfg
->nh_encap_type
,
1303 u32 tb_id
= (cfg
->dev
? l3mdev_fib_table(cfg
->dev
) : RT_TABLE_MAIN
);
1306 err
= fib_nh_init(net
, fib_nh
, &fib_cfg
, 1, extack
);
1308 fib_nh_release(net
, fib_nh
);
1315 /* sets nh_dev if successful */
1316 err
= fib_check_nh(net
, fib_nh
, tb_id
, 0, extack
);
1318 nh
->nh_flags
= fib_nh
->fib_nh_flags
;
1319 fib_info_update_nhc_saddr(net
, &fib_nh
->nh_common
,
1320 fib_nh
->fib_nh_scope
);
1322 fib_nh_release(net
, fib_nh
);
1328 static int nh_create_ipv6(struct net
*net
, struct nexthop
*nh
,
1329 struct nh_info
*nhi
, struct nh_config
*cfg
,
1330 struct netlink_ext_ack
*extack
)
1332 struct fib6_nh
*fib6_nh
= &nhi
->fib6_nh
;
1333 struct fib6_config fib6_cfg
= {
1334 .fc_table
= l3mdev_fib_table(cfg
->dev
),
1335 .fc_ifindex
= cfg
->nh_ifindex
,
1336 .fc_gateway
= cfg
->gw
.ipv6
,
1337 .fc_flags
= cfg
->nh_flags
,
1338 .fc_encap
= cfg
->nh_encap
,
1339 .fc_encap_type
= cfg
->nh_encap_type
,
1340 .fc_is_fdb
= cfg
->nh_fdb
,
1344 if (!ipv6_addr_any(&cfg
->gw
.ipv6
))
1345 fib6_cfg
.fc_flags
|= RTF_GATEWAY
;
1347 /* sets nh_dev if successful */
1348 err
= ipv6_stub
->fib6_nh_init(net
, fib6_nh
, &fib6_cfg
, GFP_KERNEL
,
1351 ipv6_stub
->fib6_nh_release(fib6_nh
);
1353 nh
->nh_flags
= fib6_nh
->fib_nh_flags
;
1358 static struct nexthop
*nexthop_create(struct net
*net
, struct nh_config
*cfg
,
1359 struct netlink_ext_ack
*extack
)
1361 struct nh_info
*nhi
;
1365 nh
= nexthop_alloc();
1367 return ERR_PTR(-ENOMEM
);
1369 nhi
= kzalloc(sizeof(*nhi
), GFP_KERNEL
);
1372 return ERR_PTR(-ENOMEM
);
1375 nh
->nh_flags
= cfg
->nh_flags
;
1378 nhi
->nh_parent
= nh
;
1379 nhi
->family
= cfg
->nh_family
;
1380 nhi
->fib_nhc
.nhc_scope
= RT_SCOPE_LINK
;
1385 if (cfg
->nh_blackhole
) {
1387 cfg
->nh_ifindex
= net
->loopback_dev
->ifindex
;
1390 switch (cfg
->nh_family
) {
1392 err
= nh_create_ipv4(net
, nh
, nhi
, cfg
, extack
);
1395 err
= nh_create_ipv6(net
, nh
, nhi
, cfg
, extack
);
1402 return ERR_PTR(err
);
1405 /* add the entry to the device based hash */
1407 nexthop_devhash_add(net
, nhi
);
1409 rcu_assign_pointer(nh
->nh_info
, nhi
);
1414 /* called with rtnl lock held */
1415 static struct nexthop
*nexthop_add(struct net
*net
, struct nh_config
*cfg
,
1416 struct netlink_ext_ack
*extack
)
1421 if (cfg
->nlflags
& NLM_F_REPLACE
&& !cfg
->nh_id
) {
1422 NL_SET_ERR_MSG(extack
, "Replace requires nexthop id");
1423 return ERR_PTR(-EINVAL
);
1427 cfg
->nh_id
= nh_find_unused_id(net
);
1429 NL_SET_ERR_MSG(extack
, "No unused id");
1430 return ERR_PTR(-EINVAL
);
1435 nh
= nexthop_create_group(net
, cfg
);
1437 nh
= nexthop_create(net
, cfg
, extack
);
1442 refcount_set(&nh
->refcnt
, 1);
1443 nh
->id
= cfg
->nh_id
;
1444 nh
->protocol
= cfg
->nh_protocol
;
1447 err
= insert_nexthop(net
, nh
, cfg
, extack
);
1449 __remove_nexthop(net
, nh
, NULL
);
1457 static int rtm_to_nh_config(struct net
*net
, struct sk_buff
*skb
,
1458 struct nlmsghdr
*nlh
, struct nh_config
*cfg
,
1459 struct netlink_ext_ack
*extack
)
1461 struct nhmsg
*nhm
= nlmsg_data(nlh
);
1462 struct nlattr
*tb
[NHA_MAX
+ 1];
1465 err
= nlmsg_parse(nlh
, sizeof(*nhm
), tb
, NHA_MAX
, rtm_nh_policy
,
1471 if (nhm
->resvd
|| nhm
->nh_scope
) {
1472 NL_SET_ERR_MSG(extack
, "Invalid values in ancillary header");
1475 if (nhm
->nh_flags
& ~NEXTHOP_VALID_USER_FLAGS
) {
1476 NL_SET_ERR_MSG(extack
, "Invalid nexthop flags in ancillary header");
1480 switch (nhm
->nh_family
) {
1489 NL_SET_ERR_MSG(extack
, "Invalid address family");
1493 if (tb
[NHA_GROUPS
] || tb
[NHA_MASTER
]) {
1494 NL_SET_ERR_MSG(extack
, "Invalid attributes in request");
1498 memset(cfg
, 0, sizeof(*cfg
));
1499 cfg
->nlflags
= nlh
->nlmsg_flags
;
1500 cfg
->nlinfo
.portid
= NETLINK_CB(skb
).portid
;
1501 cfg
->nlinfo
.nlh
= nlh
;
1502 cfg
->nlinfo
.nl_net
= net
;
1504 cfg
->nh_family
= nhm
->nh_family
;
1505 cfg
->nh_protocol
= nhm
->nh_protocol
;
1506 cfg
->nh_flags
= nhm
->nh_flags
;
1509 cfg
->nh_id
= nla_get_u32(tb
[NHA_ID
]);
1512 if (tb
[NHA_OIF
] || tb
[NHA_BLACKHOLE
] ||
1513 tb
[NHA_ENCAP
] || tb
[NHA_ENCAP_TYPE
]) {
1514 NL_SET_ERR_MSG(extack
, "Fdb attribute can not be used with encap, oif or blackhole");
1517 if (nhm
->nh_flags
) {
1518 NL_SET_ERR_MSG(extack
, "Unsupported nexthop flags in ancillary header");
1521 cfg
->nh_fdb
= nla_get_flag(tb
[NHA_FDB
]);
1524 if (tb
[NHA_GROUP
]) {
1525 if (nhm
->nh_family
!= AF_UNSPEC
) {
1526 NL_SET_ERR_MSG(extack
, "Invalid family for group");
1529 cfg
->nh_grp
= tb
[NHA_GROUP
];
1531 cfg
->nh_grp_type
= NEXTHOP_GRP_TYPE_MPATH
;
1532 if (tb
[NHA_GROUP_TYPE
])
1533 cfg
->nh_grp_type
= nla_get_u16(tb
[NHA_GROUP_TYPE
]);
1535 if (cfg
->nh_grp_type
> NEXTHOP_GRP_TYPE_MAX
) {
1536 NL_SET_ERR_MSG(extack
, "Invalid group type");
1539 err
= nh_check_attr_group(net
, tb
, extack
);
1541 /* no other attributes should be set */
1545 if (tb
[NHA_BLACKHOLE
]) {
1546 if (tb
[NHA_GATEWAY
] || tb
[NHA_OIF
] ||
1547 tb
[NHA_ENCAP
] || tb
[NHA_ENCAP_TYPE
] || tb
[NHA_FDB
]) {
1548 NL_SET_ERR_MSG(extack
, "Blackhole attribute can not be used with gateway, oif, encap or fdb");
1552 cfg
->nh_blackhole
= 1;
1557 if (!cfg
->nh_fdb
&& !tb
[NHA_OIF
]) {
1558 NL_SET_ERR_MSG(extack
, "Device attribute required for non-blackhole and non-fdb nexthops");
1562 if (!cfg
->nh_fdb
&& tb
[NHA_OIF
]) {
1563 cfg
->nh_ifindex
= nla_get_u32(tb
[NHA_OIF
]);
1564 if (cfg
->nh_ifindex
)
1565 cfg
->dev
= __dev_get_by_index(net
, cfg
->nh_ifindex
);
1568 NL_SET_ERR_MSG(extack
, "Invalid device index");
1570 } else if (!(cfg
->dev
->flags
& IFF_UP
)) {
1571 NL_SET_ERR_MSG(extack
, "Nexthop device is not up");
1574 } else if (!netif_carrier_ok(cfg
->dev
)) {
1575 NL_SET_ERR_MSG(extack
, "Carrier for nexthop device is down");
1582 if (tb
[NHA_GATEWAY
]) {
1583 struct nlattr
*gwa
= tb
[NHA_GATEWAY
];
1585 switch (cfg
->nh_family
) {
1587 if (nla_len(gwa
) != sizeof(u32
)) {
1588 NL_SET_ERR_MSG(extack
, "Invalid gateway");
1591 cfg
->gw
.ipv4
= nla_get_be32(gwa
);
1594 if (nla_len(gwa
) != sizeof(struct in6_addr
)) {
1595 NL_SET_ERR_MSG(extack
, "Invalid gateway");
1598 cfg
->gw
.ipv6
= nla_get_in6_addr(gwa
);
1601 NL_SET_ERR_MSG(extack
,
1602 "Unknown address family for gateway");
1606 /* device only nexthop (no gateway) */
1607 if (cfg
->nh_flags
& RTNH_F_ONLINK
) {
1608 NL_SET_ERR_MSG(extack
,
1609 "ONLINK flag can not be set for nexthop without a gateway");
1614 if (tb
[NHA_ENCAP
]) {
1615 cfg
->nh_encap
= tb
[NHA_ENCAP
];
1617 if (!tb
[NHA_ENCAP_TYPE
]) {
1618 NL_SET_ERR_MSG(extack
, "LWT encapsulation type is missing");
1622 cfg
->nh_encap_type
= nla_get_u16(tb
[NHA_ENCAP_TYPE
]);
1623 err
= lwtunnel_valid_encap_type(cfg
->nh_encap_type
, extack
);
1627 } else if (tb
[NHA_ENCAP_TYPE
]) {
1628 NL_SET_ERR_MSG(extack
, "LWT encapsulation attribute is missing");
1639 static int rtm_new_nexthop(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1640 struct netlink_ext_ack
*extack
)
1642 struct net
*net
= sock_net(skb
->sk
);
1643 struct nh_config cfg
;
1647 err
= rtm_to_nh_config(net
, skb
, nlh
, &cfg
, extack
);
1649 nh
= nexthop_add(net
, &cfg
, extack
);
1657 static int nh_valid_get_del_req(struct nlmsghdr
*nlh
, u32
*id
,
1658 struct netlink_ext_ack
*extack
)
1660 struct nhmsg
*nhm
= nlmsg_data(nlh
);
1661 struct nlattr
*tb
[NHA_MAX
+ 1];
1664 err
= nlmsg_parse(nlh
, sizeof(*nhm
), tb
, NHA_MAX
, rtm_nh_policy
,
1670 for (i
= 0; i
< __NHA_MAX
; ++i
) {
1678 NL_SET_ERR_MSG_ATTR(extack
, tb
[i
],
1679 "Unexpected attribute in request");
1683 if (nhm
->nh_protocol
|| nhm
->resvd
|| nhm
->nh_scope
|| nhm
->nh_flags
) {
1684 NL_SET_ERR_MSG(extack
, "Invalid values in header");
1689 NL_SET_ERR_MSG(extack
, "Nexthop id is missing");
1693 *id
= nla_get_u32(tb
[NHA_ID
]);
1695 NL_SET_ERR_MSG(extack
, "Invalid nexthop id");
1703 static int rtm_del_nexthop(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1704 struct netlink_ext_ack
*extack
)
1706 struct net
*net
= sock_net(skb
->sk
);
1707 struct nl_info nlinfo
= {
1710 .portid
= NETLINK_CB(skb
).portid
,
1716 err
= nh_valid_get_del_req(nlh
, &id
, extack
);
1720 nh
= nexthop_find_by_id(net
, id
);
1724 remove_nexthop(net
, nh
, &nlinfo
);
1730 static int rtm_get_nexthop(struct sk_buff
*in_skb
, struct nlmsghdr
*nlh
,
1731 struct netlink_ext_ack
*extack
)
1733 struct net
*net
= sock_net(in_skb
->sk
);
1734 struct sk_buff
*skb
= NULL
;
1739 err
= nh_valid_get_del_req(nlh
, &id
, extack
);
1744 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
1749 nh
= nexthop_find_by_id(net
, id
);
1753 err
= nh_fill_node(skb
, nh
, RTM_NEWNEXTHOP
, NETLINK_CB(in_skb
).portid
,
1756 WARN_ON(err
== -EMSGSIZE
);
1760 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1768 static bool nh_dump_filtered(struct nexthop
*nh
, int dev_idx
, int master_idx
,
1769 bool group_filter
, u8 family
)
1771 const struct net_device
*dev
;
1772 const struct nh_info
*nhi
;
1774 if (group_filter
&& !nh
->is_group
)
1777 if (!dev_idx
&& !master_idx
&& !family
)
1783 nhi
= rtnl_dereference(nh
->nh_info
);
1784 if (family
&& nhi
->family
!= family
)
1787 dev
= nhi
->fib_nhc
.nhc_dev
;
1788 if (dev_idx
&& (!dev
|| dev
->ifindex
!= dev_idx
))
1792 struct net_device
*master
;
1797 master
= netdev_master_upper_dev_get((struct net_device
*)dev
);
1798 if (!master
|| master
->ifindex
!= master_idx
)
1805 static int nh_valid_dump_req(const struct nlmsghdr
*nlh
, int *dev_idx
,
1806 int *master_idx
, bool *group_filter
,
1807 bool *fdb_filter
, struct netlink_callback
*cb
)
1809 struct netlink_ext_ack
*extack
= cb
->extack
;
1810 struct nlattr
*tb
[NHA_MAX
+ 1];
1815 err
= nlmsg_parse(nlh
, sizeof(*nhm
), tb
, NHA_MAX
, rtm_nh_policy
,
1820 for (i
= 0; i
<= NHA_MAX
; ++i
) {
1826 idx
= nla_get_u32(tb
[i
]);
1827 if (idx
> INT_MAX
) {
1828 NL_SET_ERR_MSG(extack
, "Invalid device index");
1834 idx
= nla_get_u32(tb
[i
]);
1835 if (idx
> INT_MAX
) {
1836 NL_SET_ERR_MSG(extack
, "Invalid master device index");
1842 *group_filter
= true;
1848 NL_SET_ERR_MSG(extack
, "Unsupported attribute in dump request");
1853 nhm
= nlmsg_data(nlh
);
1854 if (nhm
->nh_protocol
|| nhm
->resvd
|| nhm
->nh_scope
|| nhm
->nh_flags
) {
1855 NL_SET_ERR_MSG(extack
, "Invalid values in header for nexthop dump request");
1863 static int rtm_dump_nexthop(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1865 bool group_filter
= false, fdb_filter
= false;
1866 struct nhmsg
*nhm
= nlmsg_data(cb
->nlh
);
1867 int dev_filter_idx
= 0, master_idx
= 0;
1868 struct net
*net
= sock_net(skb
->sk
);
1869 struct rb_root
*root
= &net
->nexthop
.rb_root
;
1870 struct rb_node
*node
;
1874 err
= nh_valid_dump_req(cb
->nlh
, &dev_filter_idx
, &master_idx
,
1875 &group_filter
, &fdb_filter
, cb
);
1879 s_idx
= cb
->args
[0];
1880 for (node
= rb_first(root
); node
; node
= rb_next(node
)) {
1886 nh
= rb_entry(node
, struct nexthop
, rb_node
);
1887 if (nh_dump_filtered(nh
, dev_filter_idx
, master_idx
,
1888 group_filter
, nhm
->nh_family
))
1891 err
= nh_fill_node(skb
, nh
, RTM_NEWNEXTHOP
,
1892 NETLINK_CB(cb
->skb
).portid
,
1893 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
);
1895 if (likely(skb
->len
))
1908 cb
->seq
= net
->nexthop
.seq
;
1909 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1914 static void nexthop_sync_mtu(struct net_device
*dev
, u32 orig_mtu
)
1916 unsigned int hash
= nh_dev_hashfn(dev
->ifindex
);
1917 struct net
*net
= dev_net(dev
);
1918 struct hlist_head
*head
= &net
->nexthop
.devhash
[hash
];
1919 struct hlist_node
*n
;
1920 struct nh_info
*nhi
;
1922 hlist_for_each_entry_safe(nhi
, n
, head
, dev_hash
) {
1923 if (nhi
->fib_nhc
.nhc_dev
== dev
) {
1924 if (nhi
->family
== AF_INET
)
1925 fib_nhc_update_mtu(&nhi
->fib_nhc
, dev
->mtu
,
1932 static int nh_netdev_event(struct notifier_block
*this,
1933 unsigned long event
, void *ptr
)
1935 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1936 struct netdev_notifier_info_ext
*info_ext
;
1940 case NETDEV_UNREGISTER
:
1941 nexthop_flush_dev(dev
);
1944 if (!(dev_get_flags(dev
) & (IFF_RUNNING
| IFF_LOWER_UP
)))
1945 nexthop_flush_dev(dev
);
1947 case NETDEV_CHANGEMTU
:
1949 nexthop_sync_mtu(dev
, info_ext
->ext
.mtu
);
1950 rt_cache_flush(dev_net(dev
));
1956 static struct notifier_block nh_netdev_notifier
= {
1957 .notifier_call
= nh_netdev_event
,
1960 int register_nexthop_notifier(struct net
*net
, struct notifier_block
*nb
)
1962 return blocking_notifier_chain_register(&net
->nexthop
.notifier_chain
,
1965 EXPORT_SYMBOL(register_nexthop_notifier
);
1967 int unregister_nexthop_notifier(struct net
*net
, struct notifier_block
*nb
)
1969 return blocking_notifier_chain_unregister(&net
->nexthop
.notifier_chain
,
1972 EXPORT_SYMBOL(unregister_nexthop_notifier
);
1974 static void __net_exit
nexthop_net_exit(struct net
*net
)
1977 flush_all_nexthops(net
);
1979 kfree(net
->nexthop
.devhash
);
1982 static int __net_init
nexthop_net_init(struct net
*net
)
1984 size_t sz
= sizeof(struct hlist_head
) * NH_DEV_HASHSIZE
;
1986 net
->nexthop
.rb_root
= RB_ROOT
;
1987 net
->nexthop
.devhash
= kzalloc(sz
, GFP_KERNEL
);
1988 if (!net
->nexthop
.devhash
)
1990 BLOCKING_INIT_NOTIFIER_HEAD(&net
->nexthop
.notifier_chain
);
1995 static struct pernet_operations nexthop_net_ops
= {
1996 .init
= nexthop_net_init
,
1997 .exit
= nexthop_net_exit
,
2000 static int __init
nexthop_init(void)
2002 register_pernet_subsys(&nexthop_net_ops
);
2004 register_netdevice_notifier(&nh_netdev_notifier
);
2006 rtnl_register(PF_UNSPEC
, RTM_NEWNEXTHOP
, rtm_new_nexthop
, NULL
, 0);
2007 rtnl_register(PF_UNSPEC
, RTM_DELNEXTHOP
, rtm_del_nexthop
, NULL
, 0);
2008 rtnl_register(PF_UNSPEC
, RTM_GETNEXTHOP
, rtm_get_nexthop
,
2009 rtm_dump_nexthop
, 0);
2011 rtnl_register(PF_INET
, RTM_NEWNEXTHOP
, rtm_new_nexthop
, NULL
, 0);
2012 rtnl_register(PF_INET
, RTM_GETNEXTHOP
, NULL
, rtm_dump_nexthop
, 0);
2014 rtnl_register(PF_INET6
, RTM_NEWNEXTHOP
, rtm_new_nexthop
, NULL
, 0);
2015 rtnl_register(PF_INET6
, RTM_GETNEXTHOP
, NULL
, rtm_dump_nexthop
, 0);
2019 subsys_initcall(nexthop_init
);