Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-21 19:41:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

rtnetlink: Protect link_ops by mutex.

Browse Source 
rtnl_link_unregister() holds RTNL and calls synchronize_srcu(),
but rtnl_newlink() will acquire SRCU frist and then RTNL.

Then, we need to unlink ops and call synchronize_srcu() outside
of RTNL to avoid the deadlock.

   rtnl_link_unregister()       rtnl_newlink()
   ----                         ----
   lock(rtnl_mutex);
                                lock(&ops->srcu);
                                lock(rtnl_mutex);
   sync(&ops->srcu);

Let's move as such and add a mutex to protect link_ops.

Now, link_ops is protected by its dedicated mutex and
rtnl_link_register() no longer needs to hold RTNL.

While at it, we move the initialisation of ops->dellink and
ops->srcu out of the mutex scope.

Signed-off-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://patch.msgid.link/20241108004823.29419-3-kuniyu@amazon.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Kuniyuki Iwashima 2024-11-07 16:48:15 -08:00 committed by Jakub Kicinski
parent d5ec8d91f8
commit 6b57ff21a3
2 changed files with 22 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/net/rtnetlink.h
View File

@ -71,7 +71,7 @@ static inline int rtnl_msg_family(const struct nlmsghdr *nlh)
/**
* struct rtnl_link_ops - rtnetlink link operations
*
* @list: Used internally, protected by RTNL and SRCU
* @list: Used internally, protected by link_ops_mutex and SRCU
* @srcu: Used internally
* @kind: Identifier
* @netns_refund: Physical device, move to init_net on netns exit

35
net/core/rtnetlink.c
View File

@ -466,6 +466,7 @@ void __rtnl_unregister_many(const struct rtnl_msg_handler *handlers, int n)
}
EXPORT_SYMBOL_GPL(__rtnl_unregister_many);
static DEFINE_MUTEX(link_ops_mutex);
static LIST_HEAD(link_ops);
static struct rtnl_link_ops *rtnl_link_ops_get(const char *kind, int *srcu_index)
@ -508,14 +509,6 @@ int __rtnl_link_register(struct rtnl_link_ops *ops)
struct rtnl_link_ops *tmp;
int err;
/* When RTNL is removed, add lock for link_ops. */
ASSERT_RTNL();
list_for_each_entry(tmp, &link_ops, list) {
if (!strcmp(ops->kind, tmp->kind))
return -EEXIST;
}
/* The check for alloc/setup is here because if ops
* does not have that filled up, it is not possible
* to use the ops for creating device. So do not
@ -528,9 +521,20 @@ int __rtnl_link_register(struct rtnl_link_ops *ops)
if (err)
return err;
list_add_tail_rcu(&ops->list, &link_ops);
mutex_lock(&link_ops_mutex);
return 0;
list_for_each_entry(tmp, &link_ops, list) {
if (!strcmp(ops->kind, tmp->kind)) {
err = -EEXIST;
goto unlock;
}
}
list_add_tail_rcu(&ops->list, &link_ops);
unlock:
mutex_unlock(&link_ops_mutex);
return err;
}
EXPORT_SYMBOL_GPL(__rtnl_link_register);
@ -598,14 +602,17 @@ void rtnl_link_unregister(struct rtnl_link_ops *ops)
{
struct net *net;
mutex_lock(&link_ops_mutex);
list_del_rcu(&ops->list);
mutex_unlock(&link_ops_mutex);
synchronize_srcu(&ops->srcu);
cleanup_srcu_struct(&ops->srcu);
/* Close the race with setup_net() and cleanup_net() */
down_write(&pernet_ops_rwsem);
rtnl_lock_unregistering_all();
list_del_rcu(&ops->list);
synchronize_srcu(&ops->srcu);
cleanup_srcu_struct(&ops->srcu);
for_each_net(net)
__rtnl_kill_links(net, ops);