[RFC PATCH net-next 03/13] net: introduce a mutex for the netns interface lists

Vladimir Oltean
2020-12-07T00:01:33Z

Currently, any writer that wants to alter the lists of network
interfaces (either the plain list net->dev_base_head, or the hash tables
net->dev_index_head and net->dev_name_head) can keep other writers at
bay using the RTNL mutex.

However, the RTNL mutex has become a very contended resource over the
years, so there is a movement to do finer grained locking.

This patch adds one more way for writers to the network interface lists
to serialize themselves. We assume that all writers to the network
interface lists are easily identifiable because the write side of
dev_base_lock also needs to be held (note that some instances of that
were deliberately skipped, since they only dealt with protecting the
operational state of the netdev).

Holding the RTNL mutex is now optional for new code that alters the
lists, since all relevant writers were made to also hold the new lock.

Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
---
include/net/net_namespace.h | 5 +++++
net/core/dev.c | 44 +++++++++++++++++++++++++------------
2 files changed, 35 insertions(+), 14 deletions(-)

diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 29567875f428..90826982843d 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -105,6 +105,11 @@ struct net {
struct hlist_head *dev_index_head;
struct raw_notifier_head netdev_chain;

+ /* Serializes writers to @dev_base_head, @dev_name_head
+ * and @dev_index_head
+ */
+ struct mutex netdev_lists_lock;
+
/* Note that @hash_mix can be read millions times per second,
* it is critical that it is on a read_mostly cache line.
*/
diff --git a/net/core/dev.c b/net/core/dev.c
index 701a326682e8..18904acb7797 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -175,13 +175,16 @@ static struct napi_struct *napi_by_id(unsigned int napi_id);
*
* Pure readers should hold rcu_read_lock() which should protect them against
* concurrent changes to the interface lists made by the writers. Pure writers
- * must serialize by holding the RTNL mutex while they loop through the list
- * and make changes to it.
+ * must serialize by holding the @net->netdev_lists_lock mutex while they loop
+ * through the list and make changes to it.
+ *
+ * It is possible to hold the RTNL mutex for serializing the writers too, but
+ * this should be avoided in new code due to lock contention.
*
* It is also possible to hold the global rwlock_t @dev_base_lock for
* protection (holding its read side as an alternative to rcu_read_lock, and
- * its write side as an alternative to the RTNL mutex), however this should not
- * be done in new code, since it is deprecated and pending removal.
+ * its write side as an alternative to @net->netdev_lists_lock), however this
+ * should not be done in new code, since it is deprecated and pending removal.
*
* One other role of @dev_base_lock is to protect against changes in the
* operational state of a network interface.
@@ -360,12 +363,14 @@ static void list_netdevice(struct net_device *dev)

ASSERT_RTNL();

+ mutex_lock(&net->netdev_lists_lock);
write_lock_bh(&dev_base_lock);
list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
netdev_name_node_add(net, dev->name_node);
hlist_add_head_rcu(&dev->index_hlist,
dev_index_hash(net, dev->ifindex));
write_unlock_bh(&dev_base_lock);
+ mutex_unlock(&net->netdev_lists_lock);

dev_base_seq_inc(net);
}
@@ -375,16 +380,20 @@ static void list_netdevice(struct net_device *dev)
*/
static void unlist_netdevice(struct net_device *dev)
{
+ struct net *net = dev_net(dev);
+
ASSERT_RTNL();

/* Unlink dev from the device chain */
+ mutex_lock(&net->netdev_lists_lock);
write_lock_bh(&dev_base_lock);
list_del_rcu(&dev->dev_list);
netdev_name_node_del(dev->name_node);
hlist_del_rcu(&dev->index_hlist);
write_unlock_bh(&dev_base_lock);
+ mutex_unlock(&net->netdev_lists_lock);

- dev_base_seq_inc(dev_net(dev));
+ dev_base_seq_inc(net);
}

/*
@@ -850,11 +859,11 @@ EXPORT_SYMBOL_GPL(dev_fill_metadata_dst);
* @net: the applicable net namespace
* @name: name to find
*
- * Find an interface by name. Must be called under RTNL semaphore
- * or @dev_base_lock. If the name is found a pointer to the device
- * is returned. If the name is not found then %NULL is returned. The
- * reference counters are not incremented so the caller must be
- * careful with locks.
+ * Find an interface by name. Must be called under RTNL semaphore,
+ * @net->netdev_lists_lock or @dev_base_lock. If the name is found,
+ * a pointer to the device is returned. If the name is not found then
+ * %NULL is returned. The reference counters are not incremented so the
+ * caller must be careful with locks.
*/

struct net_device *__dev_get_by_name(struct net *net, const char *name)
@@ -920,8 +929,8 @@ EXPORT_SYMBOL(dev_get_by_name);
* Search for an interface by index. Returns %NULL if the device
* is not found or a pointer to the device. The device has not
* had its reference counter increased so the caller must be careful
- * about locking. The caller must hold either the RTNL semaphore
- * or @dev_base_lock.
+ * about locking. The caller must hold either the RTNL semaphore,
+ * @net->netdev_lists_lock or @dev_base_lock.
*/

struct net_device *__dev_get_by_index(struct net *net, int ifindex)
@@ -1330,15 +1339,19 @@ int dev_change_name(struct net_device *dev, const char *newname)

netdev_adjacent_rename_links(dev, oldname);

+ mutex_lock(&net->netdev_lists_lock);
write_lock_bh(&dev_base_lock);
netdev_name_node_del(dev->name_node);
write_unlock_bh(&dev_base_lock);
+ mutex_unlock(&net->netdev_lists_lock);

synchronize_rcu();

+ mutex_lock(&net->netdev_lists_lock);
write_lock_bh(&dev_base_lock);
netdev_name_node_add(net, dev->name_node);
write_unlock_bh(&dev_base_lock);
+ mutex_unlock(&net->netdev_lists_lock);

ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
ret = notifier_to_errno(ret);
@@ -9379,8 +9392,9 @@ int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
* @net: the applicable net namespace
*
* Returns a suitable unique value for a new device interface
- * number. The caller must hold the rtnl semaphore or the
- * dev_base_lock to be sure it remains unique.
+ * number.
+ * The caller must hold the rtnl semaphore, @net->netdev_lists_lock or the
+ * @dev_base_lock to be sure it remains unique.
*/
static int dev_new_index(struct net *net)
{
@@ -10958,6 +10972,8 @@ static int __net_init netdev_init(struct net *net)
if (net->dev_index_head == NULL)
goto err_idx;

+ mutex_init(&net->netdev_lists_lock);
+
RAW_INIT_NOTIFIER_HEAD(&net->netdev_chain);

return 0;
--
2.25.1