iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'net-core-rcuify-rtnl-af_ops'

Browse Source 
Florian Westphal says:

====================
net: core: rcuify rtnl af_ops

None of the rtnl af_ops callbacks sleep, so they can be called while
holding rcu read lock.

Switch handling of af_ops to rcu.

This would allow to later call af_ops functions without holding
the rtnl mutex anymore.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2017-10-16 21:26:40 +01:00
commit 45880485a3
2 changed files with 89 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
net/core/rtnetlink.c
View File

@ -453,7 +453,7 @@ static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
{ {
const struct rtnl_af_ops *ops; const struct rtnl_af_ops *ops;
list_for_each_entry(ops, &rtnl_af_ops, list) { list_for_each_entry_rcu(ops, &rtnl_af_ops, list) {
if (ops->family == family) if (ops->family == family)
return ops; return ops;
} }
@ -470,7 +470,7 @@ static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
void rtnl_af_register(struct rtnl_af_ops *ops) void rtnl_af_register(struct rtnl_af_ops *ops)
{ {
rtnl_lock(); rtnl_lock();
list_add_tail(&ops->list, &rtnl_af_ops); list_add_tail_rcu(&ops->list, &rtnl_af_ops);
rtnl_unlock(); rtnl_unlock();
} }
EXPORT_SYMBOL_GPL(rtnl_af_register); EXPORT_SYMBOL_GPL(rtnl_af_register);
@ -482,8 +482,10 @@ EXPORT_SYMBOL_GPL(rtnl_af_register);
void rtnl_af_unregister(struct rtnl_af_ops *ops) void rtnl_af_unregister(struct rtnl_af_ops *ops)
{ {
rtnl_lock(); rtnl_lock();
list_del(&ops->list); list_del_rcu(&ops->list);
rtnl_unlock(); rtnl_unlock();
synchronize_rcu();
} }
EXPORT_SYMBOL_GPL(rtnl_af_unregister); EXPORT_SYMBOL_GPL(rtnl_af_unregister);
@ -496,13 +498,15 @@ static size_t rtnl_link_get_af_size(const struct net_device *dev,
/* IFLA_AF_SPEC */ /* IFLA_AF_SPEC */
size = nla_total_size(sizeof(struct nlattr)); size = nla_total_size(sizeof(struct nlattr));
list_for_each_entry(af_ops, &rtnl_af_ops, list) { rcu_read_lock();
list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
if (af_ops->get_link_af_size) { if (af_ops->get_link_af_size) {
/* AF_* + nested data */ /* AF_* + nested data */
size += nla_total_size(sizeof(struct nlattr)) + size += nla_total_size(sizeof(struct nlattr)) +
af_ops->get_link_af_size(dev, ext_filter_mask); af_ops->get_link_af_size(dev, ext_filter_mask);
} }
} }
rcu_read_unlock();
return size; return size;
} }
@ -1382,6 +1386,47 @@ static int rtnl_fill_link_netnsid(struct sk_buff *skb,
return 0; return 0;
} }
static int rtnl_fill_link_af(struct sk_buff *skb,
const struct net_device *dev,
u32 ext_filter_mask)
{
const struct rtnl_af_ops *af_ops;
struct nlattr *af_spec;
af_spec = nla_nest_start(skb, IFLA_AF_SPEC);
if (!af_spec)
return -EMSGSIZE;
list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
struct nlattr *af;
int err;
if (!af_ops->fill_link_af)
continue;
af = nla_nest_start(skb, af_ops->family);
if (!af)
return -EMSGSIZE;
err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
/*
* Caller may return ENODATA to indicate that there
* was no data to be dumped. This is not an error, it
* means we should trim the attribute header and
* continue.
*/
if (err == -ENODATA)
nla_nest_cancel(skb, af);
else if (err < 0)
return -EMSGSIZE;
nla_nest_end(skb, af);
}
nla_nest_end(skb, af_spec);
return 0;
}
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
int type, u32 pid, u32 seq, u32 change, int type, u32 pid, u32 seq, u32 change,
unsigned int flags, u32 ext_filter_mask, unsigned int flags, u32 ext_filter_mask,
@ -1389,8 +1434,6 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
{ {
struct ifinfomsg *ifm; struct ifinfomsg *ifm;
struct nlmsghdr *nlh; struct nlmsghdr *nlh;
struct nlattr *af_spec;
struct rtnl_af_ops *af_ops;
ASSERT_RTNL(); ASSERT_RTNL();
nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags); nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
@ -1477,39 +1520,16 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0) nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
goto nla_put_failure; goto nla_put_failure;
if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC))) rcu_read_lock();
goto nla_put_failure; if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
goto nla_put_failure_rcu;
list_for_each_entry(af_ops, &rtnl_af_ops, list) { rcu_read_unlock();
if (af_ops->fill_link_af) {
struct nlattr *af;
int err;
if (!(af = nla_nest_start(skb, af_ops->family)))
goto nla_put_failure;
err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
/*
* Caller may return ENODATA to indicate that there
* was no data to be dumped. This is not an error, it
* means we should trim the attribute header and
* continue.
*/
if (err == -ENODATA)
nla_nest_cancel(skb, af);
else if (err < 0)
goto nla_put_failure;
nla_nest_end(skb, af);
}
}
nla_nest_end(skb, af_spec);
nlmsg_end(skb, nlh); nlmsg_end(skb, nlh);
return 0; return 0;
nla_put_failure_rcu:
rcu_read_unlock();
nla_put_failure: nla_put_failure:
nlmsg_cancel(skb, nlh); nlmsg_cancel(skb, nlh);
return -EMSGSIZE; return -EMSGSIZE;
@ -1771,18 +1791,28 @@ static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
const struct rtnl_af_ops *af_ops; const struct rtnl_af_ops *af_ops;
if (!(af_ops = rtnl_af_lookup(nla_type(af)))) rcu_read_lock();
af_ops = rtnl_af_lookup(nla_type(af));
if (!af_ops) {
rcu_read_unlock();
return -EAFNOSUPPORT; return -EAFNOSUPPORT;
}
if (!af_ops->set_link_af) if (!af_ops->set_link_af) {
rcu_read_unlock();
return -EOPNOTSUPP; return -EOPNOTSUPP;
}
if (af_ops->validate_link_af) { if (af_ops->validate_link_af) {
err = af_ops->validate_link_af(dev, af); err = af_ops->validate_link_af(dev, af);
if (err < 0) if (err < 0) {
rcu_read_unlock();
return err; return err;
} }
} }
rcu_read_unlock();
}
} }
return 0; return 0;
@ -2239,13 +2269,18 @@ static int do_setlink(const struct sk_buff *skb,
nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
const struct rtnl_af_ops *af_ops; const struct rtnl_af_ops *af_ops;
rcu_read_lock();
if (!(af_ops = rtnl_af_lookup(nla_type(af)))) if (!(af_ops = rtnl_af_lookup(nla_type(af))))
BUG(); BUG();
err = af_ops->set_link_af(dev, af); err = af_ops->set_link_af(dev, af);
if (err < 0) if (err < 0) {
rcu_read_unlock();
goto errout; goto errout;
}
rcu_read_unlock();
status |= DO_SETLINK_NOTIFY; status |= DO_SETLINK_NOTIFY;
} }
} }
@ -3992,25 +4027,30 @@ static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
if (!attr) if (!attr)
goto nla_put_failure; goto nla_put_failure;
list_for_each_entry(af_ops, &rtnl_af_ops, list) { rcu_read_lock();
list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
if (af_ops->fill_stats_af) { if (af_ops->fill_stats_af) {
struct nlattr *af; struct nlattr *af;
int err; int err;
af = nla_nest_start(skb, af_ops->family); af = nla_nest_start(skb, af_ops->family);
if (!af) if (!af) {
rcu_read_unlock();
goto nla_put_failure; goto nla_put_failure;
}
err = af_ops->fill_stats_af(skb, dev); err = af_ops->fill_stats_af(skb, dev);
if (err == -ENODATA) if (err == -ENODATA) {
nla_nest_cancel(skb, af); nla_nest_cancel(skb, af);
else if (err < 0) } else if (err < 0) {
rcu_read_unlock();
goto nla_put_failure; goto nla_put_failure;
}
nla_nest_end(skb, af); nla_nest_end(skb, af);
} }
} }
rcu_read_unlock();
nla_nest_end(skb, attr); nla_nest_end(skb, attr);
@ -4079,7 +4119,8 @@ static size_t if_nlmsg_stats_size(const struct net_device *dev,
/* for IFLA_STATS_AF_SPEC */ /* for IFLA_STATS_AF_SPEC */
size += nla_total_size(0); size += nla_total_size(0);
list_for_each_entry(af_ops, &rtnl_af_ops, list) { rcu_read_lock();
list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
if (af_ops->get_stats_af_size) { if (af_ops->get_stats_af_size) {
size += nla_total_size( size += nla_total_size(
af_ops->get_stats_af_size(dev)); af_ops->get_stats_af_size(dev));
@ -4088,6 +4129,7 @@ static size_t if_nlmsg_stats_size(const struct net_device *dev,
size += nla_total_size(0); size += nla_total_size(0);
} }
} }
rcu_read_unlock();
} }
return size; return size;

4
net/ipv4/devinet.c
View File

@ -1757,7 +1757,7 @@ static int inet_validate_link_af(const struct net_device *dev,
struct nlattr *a, *tb[IFLA_INET_MAX+1]; struct nlattr *a, *tb[IFLA_INET_MAX+1];
int err, rem; int err, rem;
if (dev && !__in_dev_get_rtnl(dev)) if (dev && !__in_dev_get_rcu(dev))
return -EAFNOSUPPORT; return -EAFNOSUPPORT;
err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL); err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL);
@ -1781,7 +1781,7 @@ static int inet_validate_link_af(const struct net_device *dev,
static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla) static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
{ {
struct in_device *in_dev = __in_dev_get_rtnl(dev); struct in_device *in_dev = __in_dev_get_rcu(dev);
struct nlattr *a, *tb[IFLA_INET_MAX+1]; struct nlattr *a, *tb[IFLA_INET_MAX+1];
int rem; int rem;