github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 17:47:41 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

Merge branch 'rtnetlink-rtnl-avoidance-in-rtnl_getlink-and-rtnl_dump_ifinfo'

Browse Source 
Eric Dumazet says:

====================
rtnetlink: RTNL avoidance in rtnl_getlink() and rtnl_dump_ifinfo()

Many shell scripts invoke iproute2 commands specifying a device by
its name.

This series improves their performance avoiding RTNL acquisition
for their (repeated) name->index conversion.
====================

Link: https://patch.msgid.link/20260525083542.1565964-1-edumazet@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski 2026-05-26 19:20:20 -07:00
commit aa064a614e
2 changed files with 96 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
net/core/dev.c
View File

@ -11730,6 +11730,8 @@ void netdev_run_todo(void)
WARN_ON(rcu_access_pointer(dev->ip_ptr));
WARN_ON(rcu_access_pointer(dev->ip6_ptr));
netdev_name_node_alt_flush(dev);
netdev_name_node_free(dev->name_node);
netdev_do_free_pcpu_stats(dev);
if (dev->priv_destructor)
dev->priv_destructor(dev);
@ -12443,8 +12445,6 @@ void unregister_netdevice_many_notify(struct list_head *head,
dev_uc_flush(dev);
dev_mc_flush(dev);
netdev_name_node_alt_flush(dev);
netdev_name_node_free(dev->name_node);
netdev_rss_contexts_free(dev);

132
net/core/rtnetlink.c
View File

@ -1970,7 +1970,10 @@ static int rtnl_fill_prop_list(struct sk_buff *skb,
if (ret <= 0)
goto nest_cancel;
nla_nest_end(skb, prop_list);
ret = -EMSGSIZE;
if (nla_nest_end_safe(skb, prop_list) < 0)
goto nest_cancel;
return 0;
nest_cancel:
@ -2065,7 +2068,6 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb,
struct nlmsghdr *nlh;
struct Qdisc *qdisc;
ASSERT_RTNL();
nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
if (nlh == NULL)
return -EMSGSIZE;
@ -2088,6 +2090,7 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb,
if (ext_filter_mask & RTEXT_FILTER_NAME_ONLY)
goto end;
ASSERT_RTNL();
if (tgt_netnsid >= 0 &&
nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
goto nla_put_failure;
@ -2368,22 +2371,24 @@ static struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla,
static bool link_master_filtered(struct net_device *dev, int master_idx)
{
struct net_device *master;
bool res = false;
if (!master_idx)
return false;
master = netdev_master_upper_dev_get(dev);
rcu_read_lock();
master = netdev_master_upper_dev_get_rcu(dev);
/* 0 is already used to denote IFLA_MASTER wasn't passed, therefore need
* another invalid value for ifindex to denote "no master".
*/
if (master_idx == -1)
return !!master;
res = !!master;
else if (!master || master->ifindex != master_idx)
res = true;
rcu_read_unlock();
if (!master || master->ifindex != master_idx)
return true;
return false;
return res;
}
static bool link_kind_filtered(const struct net_device *dev,
@ -2494,6 +2499,7 @@ static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
int ops_srcu_index;
int master_idx = 0;
int netnsid = -1;
bool need_rtnl;
int err, i;
err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
@ -2543,6 +2549,12 @@ static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
walk_entries:
err = 0;
need_rtnl = !(ext_filter_mask & RTEXT_FILTER_NAME_ONLY);
if (need_rtnl)
rtnl_lock();
else
rcu_read_lock();
for_each_netdev_dump(tgt_net, dev, ctx->ifindex) {
if (link_dump_filtered(dev, master_idx, kind_ops))
continue;
@ -2554,11 +2566,13 @@ static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
if (err < 0)
break;
}
cb->seq = tgt_net->dev_base_seq;
cb->seq = READ_ONCE(tgt_net->dev_base_seq);
nl_dump_check_consistent(cb, nlmsg_hdr(skb));
if (need_rtnl)
rtnl_unlock();
else
rcu_read_unlock();
out:
if (kind_ops)
@ -3465,6 +3479,21 @@ static struct net_device *rtnl_dev_get(struct net *net,
return __dev_get_by_name(net, ifname);
}
static struct net_device *rtnl_dev_get_rcu(struct net *net,
struct nlattr *tb[])
{
char ifname[ALTIFNAMSIZ];
if (tb[IFLA_IFNAME])
nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
else if (tb[IFLA_ALT_IFNAME])
nla_strscpy(ifname, tb[IFLA_ALT_IFNAME], ALTIFNAMSIZ);
else
return NULL;
return dev_get_by_name_rcu(net, ifname);
}
static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
struct netlink_ext_ack *extack)
{
@ -4184,14 +4213,16 @@ static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
struct netlink_ext_ack *extack)
{
struct net *net = sock_net(skb->sk);
struct net *tgt_net = net;
struct ifinfomsg *ifm;
struct nlattr *tb[IFLA_MAX+1];
struct nlattr *tb[IFLA_MAX + 1];
netdevice_tracker dev_tracker;
struct net_device *dev = NULL;
struct net *tgt_net = net;
u32 ext_filter_mask = 0;
struct ifinfomsg *ifm;
struct sk_buff *nskb;
int netnsid = -1;
bool need_rtnl;
int err;
u32 ext_filter_mask = 0;
err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
if (err < 0)
@ -4211,43 +4242,65 @@ static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
if (tb[IFLA_EXT_MASK])
ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
err = -EINVAL;
ifm = nlmsg_data(nlh);
if (ifm->ifi_index > 0)
dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
dev = rtnl_dev_get(tgt_net, tb);
else
rcu_read_lock();
if (ifm->ifi_index > 0) {
dev = dev_get_by_index_rcu(tgt_net, ifm->ifi_index);
} else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) {
dev = rtnl_dev_get_rcu(tgt_net, tb);
} else {
rcu_read_unlock();
err = -EINVAL;
goto out;
}
netdev_hold(dev, &dev_tracker, GFP_ATOMIC);
rcu_read_unlock();
err = -ENODEV;
if (dev == NULL)
goto out;
need_rtnl = !(ext_filter_mask & RTEXT_FILTER_NAME_ONLY);
retry:
if (need_rtnl) {
rtnl_lock();
/* Synchronize the carrier state so we don't report a state
* that we're not actually going to honour immediately; if
* the driver just did a carrier off->on transition, we can
* only TX if link watch work has run, but without this we'd
* already report carrier on, even if it doesn't work yet.
*/
linkwatch_sync_dev(dev);
}
err = -ENOBUFS;
nskb = nlmsg_new_large(if_nlmsg_size(dev, ext_filter_mask));
if (nskb == NULL)
goto out;
if (nskb)
err = rtnl_fill_ifinfo(nskb, dev, net,
RTM_NEWLINK, NETLINK_CB(skb).portid,
nlh->nlmsg_seq, 0, 0, ext_filter_mask,
0, NULL, 0, netnsid, GFP_KERNEL);
/* Synchronize the carrier state so we don't report a state
* that we're not actually going to honour immediately; if
* the driver just did a carrier off->on transition, we can
* only TX if link watch work has run, but without this we'd
* already report carrier on, even if it doesn't work yet.
*/
linkwatch_sync_dev(dev);
if (need_rtnl)
rtnl_unlock();
err = rtnl_fill_ifinfo(nskb, dev, net,
RTM_NEWLINK, NETLINK_CB(skb).portid,
nlh->nlmsg_seq, 0, 0, ext_filter_mask,
0, NULL, 0, netnsid, GFP_KERNEL);
if (err < 0) {
/* -EMSGSIZE implies BUG in if_nlmsg_size */
WARN_ON(err == -EMSGSIZE);
kfree_skb(nskb);
} else
if (err == -EMSGSIZE) {
if (!need_rtnl) {
/* Some altnames were added, retry with RTNL. */
need_rtnl = true;
goto retry;
}
/* -EMSGSIZE implies BUG in if_nlmsg_size */
WARN_ON_ONCE(1);
}
} else {
err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
}
out:
netdev_put(dev, &dev_tracker);
if (netnsid >= 0)
put_net(tgt_net);
@ -7114,7 +7167,10 @@ static const struct rtnl_msg_handler rtnetlink_rtnl_msg_handlers[] __initconst =
{.msgtype = RTM_DELLINK, .doit = rtnl_dellink,
.flags = RTNL_FLAG_DOIT_PERNET_WIP},
{.msgtype = RTM_GETLINK, .doit = rtnl_getlink,
.dumpit = rtnl_dump_ifinfo, .flags = RTNL_FLAG_DUMP_SPLIT_NLM_DONE},
.dumpit = rtnl_dump_ifinfo,
.flags = RTNL_FLAG_DUMP_SPLIT_NLM_DONE |
RTNL_FLAG_DOIT_UNLOCKED |
RTNL_FLAG_DUMP_UNLOCKED},
{.msgtype = RTM_SETLINK, .doit = rtnl_setlink,
.flags = RTNL_FLAG_DOIT_PERNET_WIP},
{.msgtype = RTM_GETADDR, .dumpit = rtnl_dump_all},