Fix listing (IPv4, IPv6) and flushing (IPv6) of cached route exceptions
Subsystems (3)
v4 cover Fix listing (IPv4, IPv6) and flushing (IPv6) of cached route exceptions
For IPv6 cached routes, the commands 'ip -6 route list cache' and 'ip -6 route flush cache' don't work at all after route exceptions have been moved to a separate hash table in commit 2b760fcf5cfb ("ipv6: hook up exception table to store dst cache").
For IPv4 cached routes, the command 'ip route list cache' has also stopped working in kernel 3.5 after commit 4895c771c7f0 ("ipv4: Add FIB nexthop exceptions.") introduced storage for route exceptions as a separate entity.
Fix this by allowing userspace to clearly request cached routes with the RTM_F_CLONED flag used as a filter (in conjuction with strict checking or NLM_F_MATCH) and by retrieving and dumping cached routes if requested.
I'm submitting this for net as these changes fix rather relevant breakages. However, the scope might be a bit broad, and said breakages have been introduced 7 and 2 years ago, respectively, for IPv4 and IPv6. Let me know if I should rebase this on net-next instead.
For IPv4, cache flushing uses a completely different mechanism, so it wasn't affected. Listing of exception routes (modified routes pre-3.5) was tested against these versions of kernel and iproute2:
iproute2
kernel 4.14.0 4.15.0 4.19.0 5.0.0 5.1.0
3.5-rc4 + + + + +
4.4
4.9
4.14
4.15
4.19
5.0
5.1
fixed + + + + +
For IPv6, a separate iproute2 patch is required. Versions of iproute2 and kernel tested:
iproute2
kernel 4.14.0 4.15.0 4.19.0 5.0.0 5.1.0 5.1.0, patched
3.18 list + + + + + +
flush + + + + + +
4.4 list + + + + + +
flush + + + + + +
4.9 list + + + + + +
flush + + + + + +
4.14 list + + + + + +
flush + + + + + +
4.15 list
flush
4.19 list
flush
5.0 list
flush
5.1 list
flush
with list + + + + + +
fix flush +v4: Fix the listing issue also for IPv4, making the behaviour consistent
with IPv6. Honour NLM_F_MATCH as per RFC 3549 and allow usage of RTM_F_CLONED filter. Split patches into smaller logical changes.
v3: Drop check on RTM_F_CLONED and rework logic of return values of
rt6_dump_route()
v2: Add count of routes handled in partial dumps, and skip them, in patch 1/2. *** BLURB HERE ***
Stefano Brivio (8):
ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict
version
ipv4: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK
consistent
ipv4/fib_frontend: Allow RTM_F_CLONED flag to be used for filtering
ipv4: Dump routed caches if requested
Revert "net/ipv6: Bail early if user only wants cloned entries"
ipv6: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK
consistent
ipv6: Dump route exceptions too in rt6_dump_route()
ip6_fib: Don't discard nodes with valid routing information in
fib6_locate_1()
include/net/ip6_fib.h | 1 + include/net/ip6_route.h | 2 +- include/net/ip_fib.h | 6 +-- include/net/route.h | 3 ++ net/ipv4/fib_frontend.c | 50 ++++++++++++------- net/ipv4/fib_trie.c | 103 +++++++++++++++++++++++++++++++++++----- net/ipv4/ipmr.c | 4 +- net/ipv4/route.c | 6 +-- net/ipv6/ip6_fib.c | 37 ++++++++++----- net/ipv6/ip6mr.c | 4 +- net/ipv6/route.c | 74 ++++++++++++++++++++++++++--- net/mpls/af_mpls.c | 2 +- 12 files changed, 230 insertions(+), 62 deletions(-)
Signature · 1 line
2.20.1
PATCH v4 1/8 ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
ip_valid_fib_dump_req() does two things: performs strict checking on netlink attributes for dump requests, and sets a dump filter if netlink attributes require it.
We might want to just set a filter, without performing strict validation.
Rename it to ip_filter_fib_dump_req(), and add a 'strict' boolean argument that must be set if strict validation is requested.
This patch doesn't introduce any functional changes.
---
v4: New patch
include/net/ip_fib.h | 6 +++--- net/ipv4/fib_frontend.c | 34 ++++++++++++++++++++++------------ net/ipv4/ipmr.c | 4 ++-- net/ipv6/ip6_fib.c | 2 +- net/ipv6/ip6mr.c | 4 ++-- net/mpls/af_mpls.c | 2 +- 6 files changed, 31 insertions(+), 21 deletions(-)
include/net/ip_fib.h +3 -3
@@ -493,9 +493,9 @@ static inline void fib_proc_exit(struct net *net)u32 ip_mtu_from_fib_result (struct fib_result *res,__be32 daddr); -int ip_valid_fib_dump_req (struct net *net,const struct nlmsghdr *nlh, -struct fib_dump_filter *filter, -struct netlink_callback *cb); +int ip_filter_fib_dump_req (struct net *net,const struct nlmsghdr *nlh, +struct fib_dump_filter *filter, +struct netlink_callback *cb,bool strict);int fib_nexthop_info (struct sk_buff *skb,const struct fib_nh_common *nh,unsigned char *flags,bool skip_oif);
net/ipv4/fib_frontend.c +22 -12
@@ -859,9 +859,9 @@ static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,return err; } -int ip_valid_fib_dump_req (struct net *net,const struct nlmsghdr *nlh, -struct fib_dump_filter *filter, -struct netlink_callback *cb) +int ip_filter_fib_dump_req (struct net *net,const struct nlmsghdr *nlh, +struct fib_dump_filter *filter, +struct netlink_callback *cb,bool strict) {struct netlink_ext_ack *extack = cb->extack;struct nlattr *tb[RTA_MAX +1 ];
@@ -876,12 +876,12 @@ int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh, } rtm =nlmsg_data (nlh); -if (rtm->rtm_dst_len || rtm->rtm_src_len || rtm->rtm_tos || - rtm->rtm_scope) { +if (strict && (rtm->rtm_dst_len || rtm->rtm_src_len || rtm->rtm_tos || + rtm->rtm_scope)) {NL_SET_ERR_MSG (extack,"Invalid values in header for FIB dump request" );return -EINVAL ; } -if (rtm->rtm_flags & ~(RTM_F_CLONED |RTM_F_PREFIX )) { +if (strict && rtm->rtm_flags & ~(RTM_F_CLONED |RTM_F_PREFIX )) {NL_SET_ERR_MSG (extack,"Invalid flags for FIB dump request" );return -EINVAL ; }
@@ -892,10 +892,18 @@ int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh, filter->rt_type = rtm->rtm_type; filter->table_id = rtm->rtm_table; - err =nlmsg_parse_deprecated_strict (nlh,sizeof (*rtm), tb,RTA_MAX , - rtm_ipv4_policy, extack); -if (err <0 ) -return err; +if (strict) { + err =nlmsg_parse_deprecated_strict (nlh,sizeof (*rtm), tb, +RTA_MAX , rtm_ipv4_policy, + extack); +if (err <0 ) +return err; + }else { + err =nlmsg_parse_deprecated (nlh,sizeof (*rtm), tb,RTA_MAX , + rtm_ipv4_policy, extack); +if (err <0 ) +return err; + }for (i =0 ; i <=RTA_MAX ; ++i) {int ifindex;
@@ -914,6 +922,8 @@ int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,return -ENODEV ;break ;default : +if (!strict) +break ;NL_SET_ERR_MSG (extack,"Unsupported attribute in dump request" );return -EINVAL ; }
@@ -927,7 +937,7 @@ int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,return 0 ; } -EXPORT_SYMBOL_GPL (ip_valid_fib_dump_req); +EXPORT_SYMBOL_GPL (ip_filter_fib_dump_req);static int inet_dump_fib (struct sk_buff *skb,struct netlink_callback *cb) {
@@ -941,7 +951,7 @@ static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)int dumped =0 , err;if (cb->strict_check) { - err =ip_valid_fib_dump_req (net, nlh, &filter, cb); + err =ip_filter_fib_dump_req (net, nlh, &filter, cb, true);if (err <0 )return err; }else if (nlmsg_len (nlh) >=sizeof (struct rtmsg )) {
net/ipv4/ipmr.c +2 -2
@@ -2597,8 +2597,8 @@ static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)int err;if (cb->strict_check) { - err =ip_valid_fib_dump_req (sock_net (skb->sk), cb->nlh, - &filter, cb); + err =ip_filter_fib_dump_req (sock_net (skb->sk), cb->nlh, + &filter, cb, true);if (err <0 )return err; }
net/ipv6/ip6_fib.c +1 -1
@@ -571,7 +571,7 @@ static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)if (cb->strict_check) {int err; - err =ip_valid_fib_dump_req (net, nlh, &arg.filter, cb); + err =ip_filter_fib_dump_req (net, nlh, &arg.filter, cb, true);if (err <0 )return err; }else if (nlmsg_len (nlh) >=sizeof (struct rtmsg )) {
net/ipv6/ip6mr.c +2 -2
@@ -2487,8 +2487,8 @@ static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)int err;if (cb->strict_check) { - err =ip_valid_fib_dump_req (sock_net (skb->sk), nlh, - &filter, cb); + err =ip_filter_fib_dump_req (sock_net (skb->sk), nlh, &filter, + cb, true);if (err <0 )return err; }
net/mpls/af_mpls.c +1 -1
@@ -2078,7 +2078,7 @@ static int mpls_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,struct fib_dump_filter *filter, struct netlink_callback *cb) { - return ip_valid_fib_dump_req(net, nlh, filter, cb); + return ip_filter_fib_dump_req(net, nlh, filter, cb, true); }#else static int mpls_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,
Signature · 1 line
2.20.1
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 6 lines · Stefano Brivio
ip_valid_fib_dump_req()does two things: performs strict checking on netlink attributes for dump requests, and sets a dump filter if netlink attributes require it.We might want to just set a filter, without performing strict validation.
Quoted 9 lines
Rename it to
ip_filter_fib_dump_req(), and add a 'strict' boolean argument that must be set if strict validation is requested.This patch doesn't introduce any functional changes.
Signed-off-by Stefano Brivio <[email protected]>---
v4: New patch
Can you explain why this patch is needed? The existing function requires strict mode and is needed to enable any of the kernel side filtering beyond the RTM_F_CLONED setting in rtm_flags.
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 12 lines · On Fri, 14 Jun 2019 20:54:49 -0600 David Ahern <[email protected]> wrote:
Quoted 11 lines · Stefano Brivio
ip_valid_fib_dump_req()does two things: performs strict checking on netlink attributes for dump requests, and sets a dump filter if netlink attributes require it.We might want to just set a filter, without performing strict validation.
Rename it to
ip_filter_fib_dump_req(), and add a 'strict' boolean argument that must be set if strict validation is requested.This patch doesn't introduce any functional changes.
Quoted 8 lines
Quoted 4 lines
Signed-off-by Stefano Brivio <[email protected]>---
v4: New patchCan you explain why this patch is needed? The existing function requires strict mode and is needed to enable any of the kernel side filtering beyond the
RTM_F_CLONEDsetting inrtm_flags.
It's mostly to have proper NLM_F_MATCH support. Let's pick an iproute2 version without strict checking support (< 5.0), that sets NLM_F_MATCH though. Then we need this check:
if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm)))
and to set filter parameters not just based on flags (i.e. RTM_F_CLONED), but also on table, protocol, etc.
For example one might want to: 'ip route list cache table main', and this is then taken into account in fn_trie_dump_leaf() and rt6_dump_route().
Reusing this function avoids a nice amount of duplicated code and allows to have an almost common path with strict checking.
Signature · 1 line
Stefano
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 24 lines · Stefano Brivio
Quoted 12 lines · On Fri, 14 Jun 2019 20:54:49 -0600 David Ahern <[email protected]> wrote:
Quoted 11 lines · Stefano Brivio
ip_valid_fib_dump_req()does two things: performs strict checking on netlink attributes for dump requests, and sets a dump filter if netlink attributes require it.We might want to just set a filter, without performing strict validation.
Rename it to
ip_filter_fib_dump_req(), and add a 'strict' boolean argument that must be set if strict validation is requested.This patch doesn't introduce any functional changes.
Quoted 8 lines
Quoted 4 lines
Signed-off-by Stefano Brivio <[email protected]>---
v4: New patchCan you explain why this patch is needed? The existing function requires strict mode and is needed to enable any of the kernel side filtering beyond the
RTM_F_CLONEDsetting inrtm_flags.
Quoted 5 lines
It's mostly to have proper
NLM_F_MATCHsupport. Let's pick an iproute2 version without strict checking support (< 5.0), that setsNLM_F_MATCHthough. Then we need this check:if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm)))
but that check existed long before any of the strict checking and kernel side filtering was added.
Quoted 3 lines
and to set filter parameters not just based on flags (i.e.
RTM_F_CLONED), but also on table, protocol, etc.
and to do that you *must* have strict checking. There is no way to trust userspace without that strict flag set because iproute2 for the longest time sent the wrong header for almost all dump requests.
Quoted 7 lines
For example one might want to: 'ip route list cache table main', and this is then taken into account in
fn_trie_dump_leaf()andrt6_dump_route().Reusing this function avoids a nice amount of duplicated code and allows to have an almost common path with strict checking.
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 25 lines · On Fri, 14 Jun 2019 21:16:54 -0600 David Ahern <[email protected]> wrote:
Quoted 24 lines · Stefano Brivio
Quoted 20 lines · On Fri, 14 Jun 2019 20:54:49 -0600 David Ahern <[email protected]> wrote:
Quoted 6 lines · Stefano Brivio
ip_valid_fib_dump_req()does two things: performs strict checking on netlink attributes for dump requests, and sets a dump filter if netlink attributes require it.We might want to just set a filter, without performing strict validation.
Quoted 9 lines
Rename it to
ip_filter_fib_dump_req(), and add a 'strict' boolean argument that must be set if strict validation is requested.This patch doesn't introduce any functional changes.
Signed-off-by Stefano Brivio <[email protected]>---
v4: New patchCan you explain why this patch is needed? The existing function requires strict mode and is needed to enable any of the kernel side filtering beyond the
RTM_F_CLONEDsetting inrtm_flags.
Quoted 8 lines
Quoted 5 lines
It's mostly to have proper
NLM_F_MATCHsupport. Let's pick an iproute2 version without strict checking support (< 5.0), that setsNLM_F_MATCHthough. Then we need this check:if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm)))but that check existed long before any of the strict checking and kernel side filtering was added.
Indeed. And now I'm recycling it, even if strict checking is not requested.
Quoted 6 lines
Quoted 2 lines
and to set filter parameters not just based on flags (i.e.
RTM_F_CLONED), but also on table, protocol, etc.and to do that you *must* have strict checking. There is no way to trust userspace without that strict flag set because iproute2 for the longest time sent the wrong header for almost all dump requests.
So you're implying that:
- we shouldn't support NLM_F_MATCH
- we should keep this broken for iproute2 < 5.0.0?
I guess this might be acceptable, but please state it clearly.
By the way, if really needed, we can do strict checking even if not requested. But this might add more and more userspace breakage, I guess.
Signature · 1 line
Stefano
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 49 lines · On Sat, 15 Jun 2019 05:27:05 +0200 Stefano Brivio <[email protected]> wrote:
Quoted 25 lines · On Fri, 14 Jun 2019 21:16:54 -0600 David Ahern <[email protected]> wrote:
Quoted 24 lines · Stefano Brivio
Quoted 20 lines · On Fri, 14 Jun 2019 20:54:49 -0600 David Ahern <[email protected]> wrote:
Quoted 6 lines · Stefano Brivio
ip_valid_fib_dump_req()does two things: performs strict checking on netlink attributes for dump requests, and sets a dump filter if netlink attributes require it.We might want to just set a filter, without performing strict validation.
Quoted 9 lines
Rename it to
ip_filter_fib_dump_req(), and add a 'strict' boolean argument that must be set if strict validation is requested.This patch doesn't introduce any functional changes.
Signed-off-by Stefano Brivio <[email protected]>---
v4: New patchCan you explain why this patch is needed? The existing function requires strict mode and is needed to enable any of the kernel side filtering beyond the
RTM_F_CLONEDsetting inrtm_flags.Quoted 8 lines
Quoted 5 lines
It's mostly to have proper
NLM_F_MATCHsupport. Let's pick an iproute2 version without strict checking support (< 5.0), that setsNLM_F_MATCHthough. Then we need this check:if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm)))but that check existed long before any of the strict checking and kernel side filtering was added.
Indeed. And now I'm recycling it, even if strict checking is not requested.
Quoted 6 lines
Quoted 2 lines
and to set filter parameters not just based on flags (i.e.
RTM_F_CLONED), but also on table, protocol, etc.and to do that you *must* have strict checking. There is no way to trust userspace without that strict flag set because iproute2 for the longest time sent the wrong header for almost all dump requests.
So you're implying that:
Quoted 8 lines
- we shouldn't support
NLM_F_MATCH- we should keep this broken for iproute2 < 5.0.0?
I guess this might be acceptable, but please state it clearly.
By the way, if really needed, we can do strict checking even if not requested. But this might add more and more userspace breakage, I guess.
Maybe I have a simpler alternative, that doesn't allow filters without strict checking (your concern above) and fixes the issue for most iproute2 versions (except for 'ip -6 route cache flush' from 5.0.0 to current, unpatched version). I would also like to avoid introducing this bug:
- 'ip route list cache table main' currently returns nothing (bug)
- 'ip route list cache table main' with v1-v3 would return all cached routes (new bug)
and retain this feature from v4:
- if neither NLM_F_MATCH nor other filters are set, dump all cached and uncached routes. There's no way to get cached and uncached ones with a single request, otherwise. This would also fit RFC 3549.
We could do this:
- strict checking enabled (iproute2 >= 5.0.0):
- in inet{,6}_dump_fib(): if NLM_F_MATCH is set, set
filter->filter_set in any case
- in fn_trie_dump_leaf() and rt6_dump_route(): use filter->filter_set to decide if we want to filter depending on RTM_F_CLONED being set/unset. If other filters (rt_type, dev, protocol) are not set, they are still wildcards (existing implementation)
- no strict checking (iproute2 < 5.0.0):
- we can't filter consistently, so apply no filters at all: dump all the routes (filter->filter_set not set), cached and uncached. That means more netlink messages, but no spam as iproute2 filters them anyway, and list/flush cache commands work again.
I would drop 1/8, turn 2/8 and 6/8 into a straightforward:
if (cb->strict_check) {
err = ip_valid_fib_dump_req(net, nlh, &filter, cb); if (err < 0)
return err;
+ if (nlh->nlmsg_flags & NLM_F_MATCH)
+ filter.filter_set = 1;
} else if (nlmsg_len(nlh) >= sizeof(struct rtmsg)) {
struct rtmsg *rtm = nlmsg_data(nlh);
and other patches remain the same.
What do you think?
Signature · 1 line
Stefano
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 28 lines · Stefano Brivio
We could do this:
- strict checking enabled (iproute2 >= 5.0.0):
- in inet{,6}_dump_fib(): ifNLM_F_MATCHis set, setfilter->filter_set in any case- in
fn_trie_dump_leaf()andrt6_dump_route(): usefilter->filter_setto decide if we want to filter depending onRTM_F_CLONEDbeing set/unset. If other filters (rt_type, dev, protocol) are not set, they are still wildcards (existing implementation)- no strict checking (iproute2 < 5.0.0):
- we can't filter consistently, so apply no filters at all: dump all the routes (filter->filter_setnot set), cached and uncached. That means more netlink messages, but no spam as iproute2 filters them anyway, and list/flush cache commands work again.I would drop 1/8, turn 2/8 and 6/8 into a straightforward:
net/ipv4/fib_frontend.c +2
-0if (cb->strict_check) { err =ip_valid_fib_dump_req (net, nlh, &filter, cb);if (err <0 )return err; +if (nlh->nlmsg_flags &NLM_F_MATCH ) + filter.filter_set =1 ; }else if (nlmsg_len (nlh) >=sizeof (struct rtmsg )) {struct rtmsg *rtm =nlmsg_data (nlh);
Quoted 4 lines
and other patches remain the same.
What do you think?
With strict checking (5.0 and forward):
- RTM_F_CLONED NOT set means dump only FIB entries
- RTM_F_CLONED set means dump only exceptions
Without strict checking (old iproute2 on any kernel):
- dump all, userspace has to sort
Kernel side this can be handled with new field, dump_exceptions, in the filter that defaults to true and then is reset in the strict path if the flag is not set.
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 29 lines · On Mon, 17 Jun 2019 07:38:54 -0600 David Ahern <[email protected]> wrote:
Quoted 28 lines · Stefano Brivio
We could do this:
- strict checking enabled (iproute2 >= 5.0.0):
- in inet{,6}_dump_fib(): ifNLM_F_MATCHis set, setfilter->filter_set in any case- in
fn_trie_dump_leaf()andrt6_dump_route(): usefilter->filter_setto decide if we want to filter depending onRTM_F_CLONEDbeing set/unset. If other filters (rt_type, dev, protocol) are not set, they are still wildcards (existing implementation)- no strict checking (iproute2 < 5.0.0):
- we can't filter consistently, so apply no filters at all: dump all the routes (filter->filter_setnot set), cached and uncached. That means more netlink messages, but no spam as iproute2 filters them anyway, and list/flush cache commands work again.I would drop 1/8, turn 2/8 and 6/8 into a straightforward:
(quoted diff) +2
-0if (cb->strict_check) { err = ip_valid_fib_dump_req(net, nlh, &filter, cb); if (err < 0) return err; + if (nlh->nlmsg_flags & NLM_F_MATCH) + filter.filter_set = 1; } else if (nlmsg_len(nlh) >= sizeof(struct rtmsg)) { struct rtmsg *rtm = nlmsg_data(nlh);
Quoted 8 lines
Quoted 4 lines
and other patches remain the same.
What do you think?
With strict checking (5.0 and forward):
-RTM_F_CLONEDNOT set means dump only FIB entries
-RTM_F_CLONEDset means dump only exceptions
Okay. Should we really ignore the RFC and NLM_F_MATCH though? If we add field(s) to the filter, it comes almost for free, something like:
if (nlh->nlmsg_flags & NLM_F_MATCH) filter->dump_exceptions = rtm->rtm_flags & RTM_F_CLONED;
instead of:
filter->dump_exceptions = rtm->rtm_flags & RTM_F_CLONED;
Quoted 6 lines
Without strict checking (old iproute2 on any kernel):
- dump all, userspace has to sortKernel side this can be handled with new field,
dump_exceptions, in the filter that defaults to true and then is reset in the strict path if the flag is not set.
I guess we need to add two fields, we'll need a 'dump_routes' too.
Otherwise, the dump functions can't distinguish between the three cases ('no strict checking', 'strict checking and RTM_F_CLONED', 'strict checking and no RTM_F_CLONED'). How would you do this with a single additional field?
Signature · 1 line
Stefano
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 8 lines · Stefano Brivio
Quoted 4 lines
With strict checking (5.0 and forward):
-RTM_F_CLONEDNOT set means dump only FIB entries
-RTM_F_CLONEDset means dump only exceptionsOkay. Should we really ignore the RFC and
NLM_F_MATCHthough? If we add field(s) to the filter, it comes almost for free, something like:
Quoted 6 lines
if (nlh->nlmsg_flags & NLM_F_MATCH) filter->dump_exceptions = rtm->rtm_flags & RTM_F_CLONED;instead of:
filter->dump_exceptions = rtm->rtm_flags & RTM_F_CLONED;
This is where you keep losing me. iproute2 has always set NLM_F_MATCH on dump requests, so that flag can not be used as a discriminator here.
Quoted 8 lines
Quoted 7 lines
Without strict checking (old iproute2 on any kernel):
- dump all, userspace has to sortKernel side this can be handled with new field,
dump_exceptions, in the filter that defaults to true and then is reset in the strict path if the flag is not set.
Quoted 7 lines
I guess we need to add two fields, we'll need a '
dump_routes' too.Otherwise, the dump functions can't distinguish between the three cases ('no strict checking', 'strict checking and
RTM_F_CLONED', 'strict checking and noRTM_F_CLONED'). How would you do this with a single additional field?
sure, separate fields are needed for the pre-strict mode use case. So, I take it we are converging on this:
1. non-strict mode, dump both (FIB entries and exceptions). Userspace has to filter. This is the legacy behavior you are trying to restore.
2. strict mode:
a. dump only FIB entries if RTM_F_CLONED is not set b. dump only exception entries if RTM_F_CLONED is set
Agreed?
Martin, others, ok with this?
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
Quoted 12 lines · On Mon, 17 Jun 2019 11:06:51 -0600 David Ahern <[email protected]> wrote:
Quoted 11 lines · Stefano Brivio
Quoted 4 lines
With strict checking (5.0 and forward):
-RTM_F_CLONEDNOT set means dump only FIB entries
-RTM_F_CLONEDset means dump only exceptionsOkay. Should we really ignore the RFC and
NLM_F_MATCHthough? If we add field(s) to the filter, it comes almost for free, something like:if (nlh->nlmsg_flags & NLM_F_MATCH) filter->dump_exceptions = rtm->rtm_flags & RTM_F_CLONED;
Quoted 6 lines
Quoted 3 lines
instead of:
filter->dump_exceptions = rtm->rtm_flags & RTM_F_CLONED;This is where you keep losing me. iproute2 has always set
NLM_F_MATCHon dump requests, so that flag can not be used as a discriminator here.
iproute2 yes, but some other users (I'm not aware of any so I have no examples) might *very* vaguely follow the RFC and expect consistent results. That was my only point here. Most likely just a theoretical one.
Quoted 10 lines
Quoted 10 lines
Quoted 7 lines
Without strict checking (old iproute2 on any kernel):
- dump all, userspace has to sortKernel side this can be handled with new field,
dump_exceptions, in the filter that defaults to true and then is reset in the strict path if the flag is not set.I guess we need to add two fields, we'll need a '
dump_routes' too.
Quoted 7 lines
Quoted 5 lines
Otherwise, the dump functions can't distinguish between the three cases ('no strict checking', 'strict checking and
RTM_F_CLONED', 'strict checking and noRTM_F_CLONED'). How would you do this with a single additional field?sure, separate fields are needed for the pre-strict mode use case.
Well, they are needed, in general. They both start as true, non-strict mode doesn't clear them, strict mode clears one. That's how I would do it.
Quoted 10 lines
So, I take it we are converging on this:
1. non-strict mode, dump both (FIB entries and exceptions). Userspace has to filter. This is the legacy behavior you are trying to restore.
2. strict mode:
a. dump only FIB entries ifRTM_F_CLONEDis not set b. dump only exception entries ifRTM_F_CLONEDis setAgreed?
Agreed in general, maybe let me know what you think about the NLM_F_MATCH point above though.
Signature · 1 line
Stefano
Re: [PATCH net v4 1/8] ipv4/fib_frontend: Rename ip_valid_fib_dump_req, provide non-strict version
In reply to Stefano BrivioQuoted 25 lines · Stefano Brivio
Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
Can you explain why this patch is needed? The existing function requires strict mode and is needed to enable any of the kernel side filtering beyond the
RTM_F_CLONEDsetting inrtm_flags.Quoted 8 lines
Quoted 5 lines
It's mostly to have proper
NLM_F_MATCHsupport. Let's pick an iproute2 version without strict checking support (< 5.0), that setsNLM_F_MATCHthough. Then we need this check:if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm)))but that check existed long before any of the strict checking and kernel side filtering was added.
Indeed. And now I'm recycling it, even if strict checking is not requested.
Quoted 6 lines
Quoted 2 lines
and to set filter parameters not just based on flags (i.e.
RTM_F_CLONED), but also on table, protocol, etc.and to do that you *must* have strict checking. There is no way to trust userspace without that strict flag set because iproute2 for the longest time sent the wrong header for almost all dump requests.
So you're implying that:
Quoted 9 lines
- we shouldn't support
NLM_F_MATCH- we should keep this broken for iproute2 < 5.0.0?
I guess this might be acceptable, but please state it clearly.
By the way, if really needed, we can do strict checking even if not requested. But this might add more and more userspace breakage, I guess.
Prior to 5.0 and strict checking, iproute2 was sending ifinfomsg as the header struct - which is wrong for routes. ifi_flags just happens to have the same offset as rtm_flags so the check for RTM_F_CLONED is ok, but nothing else sent in the get request (e.g., potentially appended attributes) can be trusted, so the !strict path you are adding with nlmsg_parse_deprecated is wrong. The kernel side filter argument can be used and treating RTM_F_CLONED as a filter is ok, but not the new parsing code.
PATCH v4 2/8 ipv4: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK consistent
In reply to Stefano BrivioSocket option NETLINK_GET_STRICT_CHK, quoting from commit 89d35528d17d ("netlink: Add new socket option to enable strict checking on dumps"), is used to "request strict checking of headers and attributes on dump requests".
If some attributes are set (including flags), setting this option causes dump functions to filter results according to these attributes, via the filter_set flag. However, if strict checking is requested, this should imply that we also filter results based on flags that are *not* set.
This is currently not the case, at least for IPv4 FIB dumps: if the RTM_F_CLONED flag is not set, and strict checking is required, we should not return routes with the RTM_F_CLONED flag set.
Set the filter_set flag whenever strict checking is requested, limiting the scope to IPv4 FIB dumps for the moment being, as other users of the flag might not present this inconsistency.
Note that this partially duplicates the semantics of NLM_F_MATCH as described by RFC 3549, par. 3.1.1. Instead of setting a filter based on the size of the netlink message, properly support NLM_F_MATCH, by setting a filter via ip_filter_fib_dump_req() and setting the filter_set flag.
---
v4: New patch
net/ipv4/fib_frontend.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
net/ipv4/fib_frontend.c +8 -4
@@ -954,10 +954,14 @@ static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb) err =ip_filter_fib_dump_req (net, nlh, &filter, cb, true);if (err <0 )return err; - }else if (nlmsg_len (nlh) >=sizeof (struct rtmsg )) { -struct rtmsg *rtm =nlmsg_data (nlh); - - filter.flags = rtm->rtm_flags & (RTM_F_PREFIX |RTM_F_CLONED ); + filter.filter_set =1 ; + }else if (nlh->nlmsg_flags &NLM_F_MATCH ) { + err =ip_filter_fib_dump_req (net, nlh, &filter, cb, false); +if (err == -ENODEV ) +return skb->len; +if (err) +return err; + filter.filter_set =1 ; }/* fib entries are never clones and ipv4 does not use prefix flag */
Signature · 1 line
2.20.1
Re: [PATCH net v4 2/8] ipv4: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK consistent
Quoted 9 lines · Stefano Brivio
Socket option
NETLINK_GET_STRICT_CHK, quoting from commit89d35528d17d("netlink: Add new socket option to enable strict checking on dumps"), is used to "request strict checking of headers and attributes on dump requests".If some attributes are set (including flags), setting this option causes dump functions to filter results according to these attributes, via the
filter_setflag. However, if strict checking is requested, this should imply that we also filter results based on flags that are *not* set.
I don't agree with that comment. If a request does not specify a bit or specify an attribute on the request, it is a wildcard in the sense of nothing to be considered when matching records to be returned.
Quoted 4 lines
This is currently not the case, at least for IPv4 FIB dumps: if the
RTM_F_CLONEDflag is not set, and strict checking is required, we should not return routes with theRTM_F_CLONEDflag set.
IPv4 currently ignores the CLONED flag and just returns - regardless of whether strict checking is enabled. This is the original short cut added many years ago.
Quoted 11 lines
Set the
filter_setflag whenever strict checking is requested, limiting the scope to IPv4 FIB dumps for the moment being, as other users of the flag might not present this inconsistency.Note that this partially duplicates the semantics of
NLM_F_MATCHas described by RFC 3549, par. 3.1.1. Instead of setting a filter based on the size of the netlink message, properly supportNLM_F_MATCH, by setting a filter viaip_filter_fib_dump_req()and setting thefilter_setflag.
your commit description is very confusing given the end goal. can you explain again?
Re: [PATCH net v4 2/8] ipv4: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK consistent
Quoted 6 lines · On Fri, 14 Jun 2019 21:13:38 -0600 David Ahern <[email protected]> wrote:
Quoted 5 lines · Stefano Brivio
Socket option
NETLINK_GET_STRICT_CHK, quoting from commit89d35528d17d("netlink: Add new socket option to enable strict checking on dumps"), is used to "request strict checking of headers and attributes on dump requests".
Quoted 8 lines
Quoted 4 lines
If some attributes are set (including flags), setting this option causes dump functions to filter results according to these attributes, via the
filter_setflag. However, if strict checking is requested, this should imply that we also filter results based on flags that are *not* set.I don't agree with that comment. If a request does not specify a bit or specify an attribute on the request, it is a wildcard in the sense of nothing to be considered when matching records to be returned.
This is what I had in v1. Then:
Quoted 3 lines · On Thu, 6 Jun 2019 16:47:00 -0600 David Ahern <[email protected]> wrote:
That's the use case I was targeting:
1. fib dumps -RTM_F_CLONEDnot set
2. exception dump -RTM_F_CLONEDset
Quoted 2 lines · On Mon, 10 Jun 2019 15:38:06 -0600 David Ahern <[email protected]> wrote:
By that I mean without the CLONED flag, no exceptions are returned (default FIB dump). With the CLONED flag only exceptions are returned.
and this looks to me like a sensible way (if strict checking is requested, or if NLM_F_MATCH is passed) to filter the results.
Quoted 7 lines
Quoted 3 lines
This is currently not the case, at least for IPv4 FIB dumps: if the
RTM_F_CLONEDflag is not set, and strict checking is required, we should not return routes with theRTM_F_CLONEDflag set.IPv4 currently ignores the CLONED flag and just returns - regardless of whether strict checking is enabled. This is the original short cut added many years ago.
Sure, and I'm removing that, because there's no way to fetch cached routes otherwise.
Quoted 11 lines
Quoted 10 lines
Set the
filter_setflag whenever strict checking is requested, limiting the scope to IPv4 FIB dumps for the moment being, as other users of the flag might not present this inconsistency.Note that this partially duplicates the semantics of
NLM_F_MATCHas described by RFC 3549, par. 3.1.1. Instead of setting a filter based on the size of the netlink message, properly supportNLM_F_MATCH, by setting a filter viaip_filter_fib_dump_req()and setting thefilter_setflag.
Quoted 2 lines
your commit description is very confusing given the end goal. can you explain again?
1. we need a way to filter on cached routes
2. RTM_F_CLONED, by itself, doesn't specify a filter
3. how do we turn that into a filter? NLM_F_MATCH, says RFC 3549
4. but if strict checking is requested, you also turn some attributes and flags into filters -- so let's make that apply to RTM_F_CLONED too, I don't see any reason why that should be special
Signature · 1 line
Stefano
Re: [PATCH net v4 2/8] ipv4: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK consistent
Quoted 11 lines · Stefano Brivio
1. we need a way to filter on cached routes
2.
RTM_F_CLONED, by itself, doesn't specify a filter3. how do we turn that into a filter?
NLM_F_MATCH, says RFC 35494. but if strict checking is requested, you also turn some attributes and flags into filters -- so let's make that apply to
RTM_F_CLONEDtoo, I don't see any reason why that should be special
I guess I am arguing (and Martin seems to agree with end goal) that RTM_F_CLONED is special. There are really 2 "databases" to be dumped
here: FIB entries and exceptions. Which one to dump is controlled by RTM_F_CLONED.
PATCH v4 3/8 ipv4/fib_frontend: Allow RTM_F_CLONED flag to be used for filtering
In reply to Stefano BrivioThis functionally reverts the check introduced by commit e8ba330ac0c5 ("rtnetlink: Update fib dumps for strict data checking") as modified by commit e4e92fb160d7 ("net/ipv4: Bail early if user only wants prefix entries").
As we are preparing to fix listing of IPv4 cached routes, we need to give userspace a way to request for cached routes only.
---
v4: New patch
net/ipv4/fib_frontend.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
net/ipv4/fib_frontend.c +2 -2
@@ -964,8 +964,8 @@ static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb) filter.filter_set =1 ; } -/* fib entries are never clones and ipv4 does not use prefix flag */ -if (filter.flags & (RTM_F_PREFIX |RTM_F_CLONED )) +/* ipv4 does not use prefix flag */ +if (filter.flags &RTM_F_PREFIX )return skb->len;if (filter.table_id) {
Signature · 1 line
2.20.1
PATCH v4 4/8 ipv4: Dump routed caches if requested
In reply to Stefano BrivioSince commit 4895c771c7f0 ("ipv4: Add FIB nexthop exceptions."), cached exception routes are stored as a separate entity, so they are not dumped on a FIB dump, even if the RTM_F_CLONED flag is passed.
This implies that the command 'ip route list cache' doesn't return any result anymore.
If the RTM_F_CLONED is passed as filter, together with strict checking or the NLM_F_MATCH flag described by RFC 3549, retrieve nexthop exception routes and dump them.
With this, we need to add an argument to the netlink callback in order to track how many entries were already dumped for the last leaf included in a partial netlink dump.
Note that this is only as accurate as the existing tracking mechanism for
leaves: if a partial dump is restarted after exceptions are removed or expired, we might skip some non-dumped entries. To improve this, we could attach a 'sernum' attribute (similar to the one used for IPv6) to nexthop entities, and bump this counter whenever exceptions change.
Listing of exception routes (modified routes pre-3.5) was tested against these versions of kernel and iproute2:
iproute2
kernel 4.14.0 4.15.0 4.19.0 5.0.0 5.1.0
3.5-rc4 + + + + +
4.4
4.9
4.14
4.15
4.19
5.0
5.1
fixed + + + + +
---
v4: New patch
include/net/route.h | 3 ++ net/ipv4/fib_trie.c | 103 ++++++++++++++++++++++++++++++++++++++------ net/ipv4/route.c | 6 +-- 3 files changed, 97 insertions(+), 15 deletions(-)
include/net/route.h +3 -0
@@ -221,6 +221,9 @@ void ip_rt_get_source(u8 *src, struct sk_buff *skb, struct rtable *rt);struct rtable *rt_dst_alloc (struct net_device *dev,unsigned int flags,u16 type,bool nopolicy,bool noxfrm,bool will_cache); +int rt_fill_info (struct net *net,__be32 dst,__be32 src,struct rtable *rt, +u32 table_id,struct flowi4 *fl4,struct sk_buff *skb, +u32 portid,u32 seq);struct in_ifaddr ;void fib_add_ifaddr (struct in_ifaddr *);
net/ipv4/fib_trie.c +91 -12
140 lines not on this page · raw message
net/ipv4/route.c +3 -3
@@ -2663,9 +2663,9 @@ struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,EXPORT_SYMBOL_GPL (ip_route_output_flow);/* called with rcu_read_lock held */ -static int rt_fill_info (struct net *net,__be32 dst,__be32 src, -struct rtable *rt,u32 table_id,struct flowi4 *fl4, -struct sk_buff *skb,u32 portid,u32 seq) +int rt_fill_info (struct net *net,__be32 dst,__be32 src,struct rtable *rt, +u32 table_id,struct flowi4 *fl4,struct sk_buff *skb, +u32 portid,u32 seq) {struct rtmsg *r;struct nlmsghdr *nlh;
Signature · 1 line
2.20.1
PATCH v4 5/8 Revert "net/ipv6: Bail early if user only wants cloned entries"
In reply to Stefano BrivioThis reverts commit 08e814c9e8eb5a982cbd1e8f6bd255d97c51026f: as we are preparing to fix listing and dumping of IPv6 cached routes, we need to allow RTM_F_CLONED as a flag to match routes against while dumping them.
---
v4: New patch, split from 6/8
net/ipv6/ip6_fib.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
net/ipv6/ip6_fib.c +2 -5
@@ -577,13 +577,10 @@ static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb) }else if (nlmsg_len (nlh) >=sizeof (struct rtmsg )) {struct rtmsg *rtm =nlmsg_data (nlh); - arg.filter.flags = rtm->rtm_flags & (RTM_F_PREFIX |RTM_F_CLONED ); +if (rtm->rtm_flags &RTM_F_PREFIX ) + arg.filter.flags =RTM_F_PREFIX ; } -/* fib entries are never clones */ -if (arg.filter.flags &RTM_F_CLONED ) - goto out; - w = (void *)cb->args[2 ];if (!w) {/* New dump:
Signature · 1 line
2.20.1
PATCH v4 6/8 ipv6: Honour NLM_F_MATCH, make semantics of NETLINK_GET_STRICT_CHK consistent
In reply to Stefano BrivioSocket option NETLINK_GET_STRICT_CHK, quoting from commit 89d35528d17d ("netlink: Add new socket option to enable strict checking on dumps"), is used to "request strict checking of headers and attributes on dump requests".
If some attributes are set (including flags), setting this option causes dump functions to filter results according to these attributes, via the filter_set flag. However, if strict checking is requested, this should imply that we also filter results based on flags that are *not* set.
This is currently not the case, at least for IPv6 FIB dumps: if the RTM_F_CLONED flag is not set, and strict checking is required, we should not return routes with the RTM_F_CLONED flag set.
Set the filter_set flag whenever strict checking is requested, limiting the scope to IPv6 FIB dumps for the moment being, as other users of the flag might not present this inconsistency.
Note that this partially duplicates the semantics of NLM_F_MATCH as described by RFC 3549, par. 3.1.1. Instead of setting a filter based on the size of the netlink message, properly support NLM_F_MATCH, by setting a filter via ip_filter_fib_dump_req() and setting the filter_set flag.
---
v4: New patch, split from 6/8
net/ipv6/ip6_fib.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)
net/ipv6/ip6_fib.c +9 -6
@@ -570,15 +570,18 @@ static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)if (cb->strict_check) {int err; - err =ip_filter_fib_dump_req (net, nlh, &arg.filter, cb, true);if (err <0 )return err; - }else if (nlmsg_len (nlh) >=sizeof (struct rtmsg )) { -struct rtmsg *rtm =nlmsg_data (nlh); - -if (rtm->rtm_flags &RTM_F_PREFIX ) - arg.filter.flags =RTM_F_PREFIX ; + arg.filter.filter_set =1 ; + }else if (nlh->nlmsg_flags &NLM_F_MATCH ) { + res =ip_filter_fib_dump_req (net, nlh, &arg.filter, cb, false); +if (res) { +if (res == -ENODEV ) + res =0 ; + goto out; + } + arg.filter.filter_set =1 ; } w = (void *)cb->args[2 ];
Signature · 1 line
2.20.1
PATCH v4 7/8 ipv6: Dump route exceptions too in rt6_dump_route()
In reply to Stefano BrivioSince commit 2b760fcf5cfb ("ipv6: hook up exception table to store dst cache"), route exceptions reside in a separate hash table, and won't be found by walking the FIB, so they won't be dumped to userspace on a RTM_GETROUTE message.
This causes 'ip -6 route list cache' and 'ip -6 route flush cache' to have no function anymore:
# ip -6 route get fc00:3::1 fc00:3::1 via fc00:1::2 dev veth_A-R1 src fc00:1::1 metric 1024 expires 539sec mtu 1400 pref medium # ip -6 route get fc00:4::1 fc00:4::1 via fc00:2::2 dev veth_A-R2 src fc00:2::1 metric 1024 expires 536sec mtu 1500 pref medium # ip -6 route list cache # ip -6 route flush cache # ip -6 route get fc00:3::1 fc00:3::1 via fc00:1::2 dev veth_A-R1 src fc00:1::1 metric 1024 expires 520sec mtu 1400 pref medium # ip -6 route get fc00:4::1 fc00:4::1 via fc00:2::2 dev veth_A-R2 src fc00:2::1 metric 1024 expires 519sec mtu 1500 pref medium
because iproute2 lists cached routes using RTM_GETROUTE, and flushes them by listing all the routes, and deleting them with RTM_DELROUTE one by one.
If cached routes are requested using the RTM_F_CLONED flag (together with strict checking or the NLM_F_MATCH flag), look up exceptions in the hash table associated with the current fib6_info in rt6_dump_route(), and, if present and not expired, add them to the dump.
We might be unable to dump all the entries for a given node in a single message, so keep track of how many entries were handled for the current node in fib6_walker, and skip that amount in case we start from the same partially dumped node.
Note that, with the current version of iproute2, this only fixes the 'ip -6 route list cache': on a flush command, iproute2 doesn't pass RTM_F_CLONED and, due to this inconsistency, 'ip -6 route flush cache' is still unable to fetch the routes to be flushed. This will be addressed in a patch for iproute2.
To flush cached routes, a procfs entry could be introduced instead: that's how it works for IPv4. We already have a rt6_flush_exception() function ready to be wired to it. However, this would not solve the issue for listing.
Versions of iproute2 and kernel tested:
iproute2
kernel 4.14.0 4.15.0 4.19.0 5.0.0 5.1.0 5.1.0, patched
3.18 list + + + + + +
flush + + + + + +
4.4 list + + + + + +
flush + + + + + +
4.9 list + + + + + +
flush + + + + + +
4.14 list + + + + + +
flush + + + + + +
4.15 list
flush
4.19 list
flush
5.0 list
flush
5.1 list
flush
with list + + + + + +
fix flush +v4:
- split NLM_F_MATCH and strict check handling in separate patches
- filter routes using RTM_F_CLONED: if it's not set, only return non-cached routes, and if it's set, only return cached routes:
change requested by David Ahern and Martin Lau. This implies that iproute2 needs a separate patch to be able to flush IPv6 cached routes. This is not ideal because we can't fix the breakage caused by 2b760fcf5cfb entirely in kernel. However, two years have passed since then, and this makes it more tolerable
v3:
- more descriptive comment about expired exceptions in rt6_dump_route()
- swap return values of rt6_dump_route() (suggested by Martin Lau)
- don't zero skip_in_node in case we don't dump anything in a given pass (also suggested by Martin Lau)
- remove check on RTM_F_CLONED altogether: in the current UAPI semantic, it's just a flag to indicate the route was cloned, not to filter on routes
v2: Add tracking of number of entries to be skipped in current node after
a partial dump. As we restart from the same node, if not all the exceptions for a given node fit in a single message, the dump will not terminate, as suggested by Martin Lau. This is a concrete possibility, setting up a big number of exceptions for the same route actually causes the issue, suggested by David Ahern.
---
This will cause a non-trivial conflict with commit cc5c073a693f ("ipv6: Move exception bucket to fib6_nh") on net-next. I can submit an equivalent patch against net-next, if it helps.
include/net/ip6_fib.h | 1 + include/net/ip6_route.h | 2 +- net/ipv6/ip6_fib.c | 14 ++++++-- net/ipv6/route.c | 74 +++++++++++++++++++++++++++++++++++++---- 4 files changed, 81 insertions(+), 10 deletions(-)
include/net/ip6_fib.h +1 -0
@@ -312,6 +312,7 @@ struct fib6_walker {enum fib6_walk_state state;unsigned int skip;unsigned int count; +unsigned int skip_in_node;int (*func)(struct fib6_walker *);void *args; };
include/net/ip6_route.h +1 -1
@@ -178,7 +178,7 @@ struct rt6_rtnl_dump_arg {struct fib_dump_filter filter; }; -int rt6_dump_route (struct fib6_info *f6i,void *p_arg); +int rt6_dump_route (struct fib6_info *f6i,void *p_arg,unsigned int skip);void rt6_mtu_change (struct net_device *dev,unsigned int mtu);void rt6_remove_prefsrc (struct inet6_ifaddr *ifp);void rt6_clean_tohost (struct net *net,struct in6_addr *gateway);
net/ipv6/ip6_fib.c +12 -2
@@ -469,12 +469,19 @@ static int fib6_dump_node(struct fib6_walker *w)struct fib6_info *rt;for_each_fib6_walker_rt (w) { - res =rt6_dump_route (rt, w->args); -if (res <0 ) { + res =rt6_dump_route (rt, w->args, w->skip_in_node); +if (res >=0 ) {/* Frame is full, suspend walking */ w->leaf = rt; + +/* We'll restart from this node, so if some routes were +* already dumped, skip them next time. +*/ + w->skip_in_node += res; +return 1 ; } + w->skip_in_node =0 ;/* Multipath routes are dumped in one route with the * RTA_MULTIPATH attribute. Jump 'rt' to point to the
@@ -526,6 +533,7 @@ static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb,if (cb->args[4 ] ==0 ) { w->count =0 ; w->skip =0 ; + w->skip_in_node =0 ;spin_lock_bh (&table->tb6_lock); res =fib6_walk (net, w);
@@ -541,6 +549,7 @@ static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb, w->state =FWS_INIT ; w->node = w->root; w->skip = w->count; + w->skip_in_node =0 ; }else w->skip =0 ;
@@ -2041,6 +2050,7 @@ static void fib6_clean_tree(struct net *net, struct fib6_node *root, c.w.func = fib6_clean_node; c.w.count =0 ; c.w.skip =0 ; + c.w.skip_in_node =0 ; c.func = func; c.sernum = sernum; c.arg = arg;
net/ipv6/route.c +67 -7
100 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v4 8/8 ip6_fib: Don't discard nodes with valid routing information in fib6_locate_1()
In reply to Stefano BrivioWhen we perform an inexact match on FIB nodes via fib6_locate_1(), longer prefixes will be preferred to shorter ones. However, it might happen that a node, with higher fn_bit value than some other, has no valid routing information.
In this case, we'll pick that node, but it will be discarded by the check on RTN_RTINFO in fib6_locate(), and we might miss nodes with valid routing information but with lower fn_bit value.
This is apparent when a routing exception is created for a default route:
# ip -6 route list fc00:1::/64 dev veth_A-R1 proto kernel metric 256 pref medium fc00:2::/64 dev veth_A-R2 proto kernel metric 256 pref medium fc00:4::1 via fc00:2::2 dev veth_A-R2 metric 1024 pref medium fe80::/64 dev veth_A-R1 proto kernel metric 256 pref medium fe80::/64 dev veth_A-R2 proto kernel metric 256 pref medium default via fc00:1::2 dev veth_A-R1 metric 1024 pref medium # ip -6 route list cache fc00:4::1 via fc00:2::2 dev veth_A-R2 metric 1024 expires 593sec mtu 1500 pref medium fc00:3::1 via fc00:1::2 dev veth_A-R1 metric 1024 expires 593sec mtu 1500 pref medium # ip -6 route flush cache # node for default route is discarded Failed to send flush request: No such process # ip -6 route list cache fc00:3::1 via fc00:1::2 dev veth_A-R1 metric 1024 expires 586sec mtu 1500 pref medium
Check right away if the node has a RTN_RTINFO flag, before replacing the 'prev' pointer, that indicates the longest matching prefix found so far.
---
v4: No changes
v3: No changes
v2: No changes
net/ipv6/ip6_fib.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
net/ipv6/ip6_fib.c +2 -1
@@ -1545,7 +1545,8 @@ static struct fib6_node *fib6_locate_1(struct fib6_node *root,if (plen == fn->fn_bit)return fn; - prev = fn; +if (fn->fn_flags &RTN_RTINFO ) + prev = fn; next:/*
Signature · 1 line
2.20.1