rtnetlink: Protect link_ops by mutex.

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>

diff --git a/include/net/rtnetlink.h b/include/net/rtnetlink.h
index 3ebfcc6e56fd7a0dde63afcb6b260e433c04f7a3..7559020f760c5a2e3e01d0a58c8d481e1fad7ad5 100644 (file)
--- a/include/net/rtnetlink.h
+++ b/include/net/rtnetlink.h
@@ -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

diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index f0246ecec7fa7e14b02623ae13f93126d7784452..21154ef0048f0dcc81c1b8e76f4ef8e664985a0a 100644 (file)
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -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;
 
+       mutex_lock(&link_ops_mutex);
+
+       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 0;
+       return err;
 }
 EXPORT_SYMBOL_GPL(__rtnl_link_register);
 
@@ -598,14 +602,17 @@ void rtnl_link_unregister(struct rtnl_link_ops *ops)
 {
        struct net *net;
 
-       /* Close the race with setup_net() and cleanup_net() */
-       down_write(&pernet_ops_rwsem);
-       rtnl_lock_unregistering_all();
-
+       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();
+
        for_each_net(net)
                __rtnl_kill_links(net, ops);