Skip to content

Commit

Permalink
Merge branch 'net-core-rcuify-rtnl-af_ops'
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
David S. Miller committed Oct 16, 2017
2 parents d85969f + 5fa85a0 commit 4588048
Show file tree
Hide file tree
Showing 2 changed files with 89 additions and 47 deletions.
132 changes: 87 additions & 45 deletions net/core/rtnetlink.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -453,7 +453,7 @@ static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
{
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)
return ops;
}
Expand All @@ -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)
{
rtnl_lock();
list_add_tail(&ops->list, &rtnl_af_ops);
list_add_tail_rcu(&ops->list, &rtnl_af_ops);
rtnl_unlock();
}
EXPORT_SYMBOL_GPL(rtnl_af_register);
Expand All @@ -482,8 +482,10 @@ EXPORT_SYMBOL_GPL(rtnl_af_register);
void rtnl_af_unregister(struct rtnl_af_ops *ops)
{
rtnl_lock();
list_del(&ops->list);
list_del_rcu(&ops->list);
rtnl_unlock();

synchronize_rcu();
}
EXPORT_SYMBOL_GPL(rtnl_af_unregister);

Expand All @@ -496,13 +498,15 @@ static size_t rtnl_link_get_af_size(const struct net_device *dev,
/* IFLA_AF_SPEC */
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) {
/* AF_* + nested data */
size += nla_total_size(sizeof(struct nlattr)) +
af_ops->get_link_af_size(dev, ext_filter_mask);
}
}
rcu_read_unlock();

return size;
}
Expand Down Expand Up @@ -1382,15 +1386,54 @@ static int rtnl_fill_link_netnsid(struct sk_buff *skb,
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,
int type, u32 pid, u32 seq, u32 change,
unsigned int flags, u32 ext_filter_mask,
u32 event, int *new_nsid)
{
struct ifinfomsg *ifm;
struct nlmsghdr *nlh;
struct nlattr *af_spec;
struct rtnl_af_ops *af_ops;

ASSERT_RTNL();
nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
Expand Down Expand Up @@ -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)
goto nla_put_failure;

if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
goto nla_put_failure;

list_for_each_entry(af_ops, &rtnl_af_ops, list) {
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);
rcu_read_lock();
if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
goto nla_put_failure_rcu;
rcu_read_unlock();

nlmsg_end(skb, nlh);
return 0;

nla_put_failure_rcu:
rcu_read_unlock();
nla_put_failure:
nlmsg_cancel(skb, nlh);
return -EMSGSIZE;
Expand Down Expand Up @@ -1771,17 +1791,27 @@ static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
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;
}

if (!af_ops->set_link_af)
if (!af_ops->set_link_af) {
rcu_read_unlock();
return -EOPNOTSUPP;
}

if (af_ops->validate_link_af) {
err = af_ops->validate_link_af(dev, af);
if (err < 0)
if (err < 0) {
rcu_read_unlock();
return err;
}
}

rcu_read_unlock();
}
}

Expand Down Expand Up @@ -2239,13 +2269,18 @@ static int do_setlink(const struct sk_buff *skb,
nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
const struct rtnl_af_ops *af_ops;

rcu_read_lock();

if (!(af_ops = rtnl_af_lookup(nla_type(af))))
BUG();

err = af_ops->set_link_af(dev, af);
if (err < 0)
if (err < 0) {
rcu_read_unlock();
goto errout;
}

rcu_read_unlock();
status |= DO_SETLINK_NOTIFY;
}
}
Expand Down Expand Up @@ -3992,25 +4027,30 @@ static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
if (!attr)
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) {
struct nlattr *af;
int err;

af = nla_nest_start(skb, af_ops->family);
if (!af)
if (!af) {
rcu_read_unlock();
goto nla_put_failure;

}
err = af_ops->fill_stats_af(skb, dev);

if (err == -ENODATA)
if (err == -ENODATA) {
nla_nest_cancel(skb, af);
else if (err < 0)
} else if (err < 0) {
rcu_read_unlock();
goto nla_put_failure;
}

nla_nest_end(skb, af);
}
}
rcu_read_unlock();

nla_nest_end(skb, attr);

Expand Down Expand Up @@ -4079,7 +4119,8 @@ static size_t if_nlmsg_stats_size(const struct net_device *dev,
/* for IFLA_STATS_AF_SPEC */
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) {
size += nla_total_size(
af_ops->get_stats_af_size(dev));
Expand All @@ -4088,6 +4129,7 @@ static size_t if_nlmsg_stats_size(const struct net_device *dev,
size += nla_total_size(0);
}
}
rcu_read_unlock();
}

return size;
Expand Down
4 changes: 2 additions & 2 deletions net/ipv4/devinet.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1757,7 +1757,7 @@ static int inet_validate_link_af(const struct net_device *dev,
struct nlattr *a, *tb[IFLA_INET_MAX+1];
int err, rem;

if (dev && !__in_dev_get_rtnl(dev))
if (dev && !__in_dev_get_rcu(dev))
return -EAFNOSUPPORT;

err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL);
Expand All @@ -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)
{
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];
int rem;

Expand Down

0 comments on commit 4588048

Please sign in to comment.