From patchwork Tue Jan 5 18:58:52 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vladimir Oltean X-Patchwork-Id: 12000153 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8A822C07D5B for ; Tue, 5 Jan 2021 19:02:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7178022D58 for ; Tue, 5 Jan 2021 19:02:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730876AbhAETCk (ORCPT ); Tue, 5 Jan 2021 14:02:40 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43268 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730718AbhAETCG (ORCPT ); Tue, 5 Jan 2021 14:02:06 -0500 Received: from mail-ed1-x533.google.com (mail-ed1-x533.google.com [IPv6:2a00:1450:4864:20::533]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5853AC06179F; Tue, 5 Jan 2021 11:00:49 -0800 (PST) Received: by mail-ed1-x533.google.com with SMTP id y24so1833525edt.10; Tue, 05 Jan 2021 11:00:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RJ8dUowMPq3ju2B2o3YV26hFEb1pomATUmoxAPlTqus=; b=GO7hev4U0YJdcgEsK88J9bkR8g3/S6oOiXXivS8BAO4XXMadjuyWthyEQaJfLTQU8H 1DtCrBIJpgmhfZHYYpCpCbObm1o8+Q3w0br77uRKGySHd+NErjtbo8nUJ9uTBaikj/xm ha+1zPYpGxf7Q24YsQkP6ajnLAhmnT33sqAZMipWWhHzaxoZ4NrGUpqHBX/6Mfda7CA9 v2zWxCC3JjJjZFOhV570Qiuul7gfegHhSSn1kYhfygu72yKpW9xu3WnYUJmU8oBXb8QL 5E43oPwO2ZORacZGW+gxBLzBPjyGXgjmmI9/8/JlN+Aw3OF8hOCq/UXbkw60orAEk1ry Sf8A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=RJ8dUowMPq3ju2B2o3YV26hFEb1pomATUmoxAPlTqus=; b=YKE9GK9EjToIeEGDOTzt4I/pApo21DCBxB53EB1P72VU2pfrdwfjJXtMlNpQzs8dnZ GeR94gxfiNY23sZfIvRa4itgE92+hMkQD88+r8AdmUwNU00FHbG0V/ugEsa9f0OjSEjL ctQgr/7To3yd1T1cvPf3HigNg4+1OgqEz6rGUMyAAnQOuIkPn6WTJJMF32tTk0j2fpjk +p3fYOi+Ylc0vZDNmBeaXGUmJuOKYvjjzz7awyezxHCf+ZPKTPisOVHpcF3chyJstHHT SgEvhabvryCe3ffdGyKiPL7+tY1/8/H4i8wU6k/sgxJajxVqSFL70gHb0CtIUkrVaxqE tk+Q== X-Gm-Message-State: AOAM532qG3WXudTEjpmYXYIw7C9qYP9aSoubNp3Egar9z7Jfkwy/JLYT eOpRCSHeJwPqd2CA6OjEGVM= X-Google-Smtp-Source: ABdhPJzWjpEMpRNRloZq9Mto5vPvzjgXXIC9uZYEM/t0Vlmggp+gh9m7BU6tGVHsrf+F/rfiXtSgog== X-Received: by 2002:a05:6402:1692:: with SMTP id a18mr1145030edv.321.1609873248090; Tue, 05 Jan 2021 11:00:48 -0800 (PST) Received: from localhost.localdomain (5-12-227-87.residential.rdsnet.ro. [5.12.227.87]) by smtp.gmail.com with ESMTPSA id z13sm205084edq.48.2021.01.05.11.00.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Jan 2021 11:00:47 -0800 (PST) From: Vladimir Oltean To: "David S . Miller" , Jakub Kicinski Cc: netdev@vger.kernel.org, Andrew Lunn , Florian Fainelli , Paul Gortmaker , Pablo Neira Ayuso , Jiri Benc , Cong Wang , Jamal Hadi Salim , Stephen Hemminger , Eric Dumazet , George McCollister , Oleksij Rempel , Jay Vosburgh , Veaceslav Falico , Andy Gospodarek , Arnd Bergmann , Alexei Starovoitov , Andrii Nakryiko , Daniel Borkmann , Taehee Yoo , Jiri Pirko , =?utf-8?b?QmrDtnJuIFTDtnBlbA==?= , Paolo Abeni , Christian Brauner , Florian Westphal , linux-s390@vger.kernel.org, intel-wired-lan@lists.osuosl.org, linux-parisc@vger.kernel.org, linux-scsi@vger.kernel.org, linux-usb@vger.kernel.org, dev@openvswitch.org Subject: [RFC PATCH v2 net-next 02/12] net: introduce a mutex for the netns interface lists Date: Tue, 5 Jan 2021 20:58:52 +0200 Message-Id: <20210105185902.3922928-3-olteanv@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210105185902.3922928-1-olteanv@gmail.com> References: <20210105185902.3922928-1-olteanv@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-usb@vger.kernel.org From: Vladimir Oltean 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 --- include/linux/netdevice.h | 10 +++++++++ include/net/net_namespace.h | 6 +++++ net/core/dev.c | 44 +++++++++++++++++++++++++------------ 3 files changed, 46 insertions(+), 14 deletions(-) diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index 7bf167993c05..199b3be2cce4 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -4393,6 +4393,16 @@ static inline void netif_addr_unlock_bh(struct net_device *dev) spin_unlock_bh(&dev->addr_list_lock); } +static inline void netif_lists_lock(struct net *net) +{ + mutex_lock(&net->netif_lists_lock); +} + +static inline void netif_lists_unlock(struct net *net) +{ + mutex_unlock(&net->netif_lists_lock); +} + /* * dev_addrs walker. Should be used only for read access. Call with * rcu_read_lock held. diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h index 29567875f428..cac64c3c7ce0 100644 --- a/include/net/net_namespace.h +++ b/include/net/net_namespace.h @@ -183,6 +183,12 @@ struct net { struct sock *crypto_nlsk; #endif struct sock *diag_nlsk; + + /* Serializes writers to @dev_base_head, @dev_name_head and + * @dev_index_head. It does _not_ protect the netif adjacency lists + * (struct net_device::adj_list). + */ + struct mutex netif_lists_lock; } __randomize_layout; #include diff --git a/net/core/dev.c b/net/core/dev.c index 2aa613d22318..1bd41cc91f71 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->netif_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->netif_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(); + netif_lists_lock(net); 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); + netif_lists_unlock(net); 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 */ + netif_lists_lock(net); 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); + netif_lists_unlock(net); - 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->netif_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->netif_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); + netif_lists_lock(net); write_lock_bh(&dev_base_lock); netdev_name_node_del(dev->name_node); write_unlock_bh(&dev_base_lock); + netif_lists_unlock(net); synchronize_rcu(); + netif_lists_lock(net); write_lock_bh(&dev_base_lock); netdev_name_node_add(net, dev->name_node); write_unlock_bh(&dev_base_lock); + netif_lists_unlock(net); ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev); ret = notifier_to_errno(ret); @@ -9397,8 +9410,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->netif_lists_lock or the + * @dev_base_lock to be sure it remains unique. */ static int dev_new_index(struct net *net) { @@ -10981,6 +10995,8 @@ static int __net_init netdev_init(struct net *net) if (net->dev_index_head == NULL) goto err_idx; + mutex_init(&net->netif_lists_lock); + RAW_INIT_NOTIFIER_HEAD(&net->netdev_chain); return 0;