nfs_common: move localio_lock to new lock member of nfs_uuid_t

Remove cl_localio_lock from 'struct nfs_client' in favor of adding a
lock to the nfs_uuid_t struct (which is embedded in each nfs_client).

Push nfs_local_{enable,disable} implementation down to nfs_common.
Those methods now call nfs_localio_{enable,disable}_client.

This allows implementing nfs_localio_invalidate_clients in terms of
nfs_localio_disable_client.

Signed-off-by: Mike Snitzer <snitzer@kernel.org>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Anna Schumaker <anna.schumaker@oracle.com>

diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 550ca934c9cfca57446661afbab381733a25a92d..e83e1ce0461305ca2cb95ed708c33cf82f439066 100644 (file)
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -186,7 +186,6 @@ struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
        seqlock_init(&clp->cl_boot_lock);
        ktime_get_real_ts64(&clp->cl_nfssvc_boot);
        nfs_uuid_init(&clp->cl_uuid);
-       spin_lock_init(&clp->cl_localio_lock);
 #endif /* CONFIG_NFS_LOCALIO */
 
        clp->cl_principal = "*";

diff --git a/fs/nfs/localio.c b/fs/nfs/localio.c
index 94af5d89bb99651fcf89feb4732279aac9c38242..7191135b47a429efd30f4496347efd3d52aed7b6 100644 (file)
--- a/fs/nfs/localio.c
+++ b/fs/nfs/localio.c
@@ -126,10 +126,8 @@ const struct rpc_program nfslocalio_program = {
  */
 static void nfs_local_enable(struct nfs_client *clp)
 {
-       spin_lock(&clp->cl_localio_lock);
-       set_bit(NFS_CS_LOCAL_IO, &clp->cl_flags);
        trace_nfs_local_enable(clp);
-       spin_unlock(&clp->cl_localio_lock);
+       nfs_localio_enable_client(clp);
 }
 
 /*
@@ -137,12 +135,8 @@ static void nfs_local_enable(struct nfs_client *clp)
  */
 void nfs_local_disable(struct nfs_client *clp)
 {
-       spin_lock(&clp->cl_localio_lock);
-       if (test_and_clear_bit(NFS_CS_LOCAL_IO, &clp->cl_flags)) {
-               trace_nfs_local_disable(clp);
-               nfs_localio_disable_client(&clp->cl_uuid);
-       }
-       spin_unlock(&clp->cl_localio_lock);
+       trace_nfs_local_disable(clp);
+       nfs_localio_disable_client(clp);
 }
 
 /*
@@ -184,7 +178,7 @@ static bool nfs_server_uuid_is_local(struct nfs_client *clp)
        rpc_shutdown_client(rpcclient_localio);
 
        /* Server is only local if it initialized required struct members */
-       if (status || !clp->cl_uuid.net || !clp->cl_uuid.dom)
+       if (status || !rcu_access_pointer(clp->cl_uuid.net) || !clp->cl_uuid.dom)
                return false;
 
        return true;

diff --git a/fs/nfs_common/nfslocalio.c b/fs/nfs_common/nfslocalio.c
index 904439e4bb85991d9b602740529ff6a7efa5b7e7..abc132166742e7551a85ea70a5b90b5a025c4b23 100644 (file)
--- a/fs/nfs_common/nfslocalio.c
+++ b/fs/nfs_common/nfslocalio.c
@@ -7,6 +7,9 @@
 #include <linux/module.h>
 #include <linux/list.h>
 #include <linux/nfslocalio.h>
+#include <linux/nfs3.h>
+#include <linux/nfs4.h>
+#include <linux/nfs_fs_sb.h>
 #include <net/netns/generic.h>
 
 MODULE_LICENSE("GPL");
@@ -25,6 +28,7 @@ void nfs_uuid_init(nfs_uuid_t *nfs_uuid)
        nfs_uuid->net = NULL;
        nfs_uuid->dom = NULL;
        INIT_LIST_HEAD(&nfs_uuid->list);
+       spin_lock_init(&nfs_uuid->lock);
 }
 EXPORT_SYMBOL_GPL(nfs_uuid_init);
 
@@ -94,12 +98,23 @@ void nfs_uuid_is_local(const uuid_t *uuid, struct list_head *list,
 }
 EXPORT_SYMBOL_GPL(nfs_uuid_is_local);
 
+void nfs_localio_enable_client(struct nfs_client *clp)
+{
+       nfs_uuid_t *nfs_uuid = &clp->cl_uuid;
+
+       spin_lock(&nfs_uuid->lock);
+       set_bit(NFS_CS_LOCAL_IO, &clp->cl_flags);
+       spin_unlock(&nfs_uuid->lock);
+}
+EXPORT_SYMBOL_GPL(nfs_localio_enable_client);
+
 static void nfs_uuid_put_locked(nfs_uuid_t *nfs_uuid)
 {
-       if (nfs_uuid->net) {
-               module_put(nfsd_mod);
-               nfs_uuid->net = NULL;
-       }
+       if (!nfs_uuid->net)
+               return;
+       module_put(nfsd_mod);
+       RCU_INIT_POINTER(nfs_uuid->net, NULL);
+
        if (nfs_uuid->dom) {
                auth_domain_put(nfs_uuid->dom);
                nfs_uuid->dom = NULL;
@@ -107,27 +122,35 @@ static void nfs_uuid_put_locked(nfs_uuid_t *nfs_uuid)
        list_del_init(&nfs_uuid->list);
 }
 
-void nfs_localio_invalidate_clients(struct list_head *list)
+void nfs_localio_disable_client(struct nfs_client *clp)
 {
-       nfs_uuid_t *nfs_uuid, *tmp;
-
-       spin_lock(&nfs_uuid_lock);
-       list_for_each_entry_safe(nfs_uuid, tmp, list, list)
-               nfs_uuid_put_locked(nfs_uuid);
-       spin_unlock(&nfs_uuid_lock);
-}
-EXPORT_SYMBOL_GPL(nfs_localio_invalidate_clients);
+       nfs_uuid_t *nfs_uuid = &clp->cl_uuid;
 
-void nfs_localio_disable_client(nfs_uuid_t *nfs_uuid)
-{
-       if (nfs_uuid->net) {
+       spin_lock(&nfs_uuid->lock);
+       if (test_and_clear_bit(NFS_CS_LOCAL_IO, &clp->cl_flags)) {
                spin_lock(&nfs_uuid_lock);
                nfs_uuid_put_locked(nfs_uuid);
                spin_unlock(&nfs_uuid_lock);
        }
+       spin_unlock(&nfs_uuid->lock);
 }
 EXPORT_SYMBOL_GPL(nfs_localio_disable_client);
 
+void nfs_localio_invalidate_clients(struct list_head *cl_uuid_list)
+{
+       nfs_uuid_t *nfs_uuid, *tmp;
+
+       spin_lock(&nfs_uuid_lock);
+       list_for_each_entry_safe(nfs_uuid, tmp, cl_uuid_list, list) {
+               struct nfs_client *clp =
+                       container_of(nfs_uuid, struct nfs_client, cl_uuid);
+
+               nfs_localio_disable_client(clp);
+       }
+       spin_unlock(&nfs_uuid_lock);
+}
+EXPORT_SYMBOL_GPL(nfs_localio_invalidate_clients);
+
 struct nfsd_file *nfs_open_local_fh(nfs_uuid_t *uuid,
                   struct rpc_clnt *rpc_clnt, const struct cred *cred,
                   const struct nfs_fh *nfs_fh, const fmode_t fmode)

diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index b804346a974195927de579e67369cfd5e6054c78..239d86ef166c0bd6ba412e13f142410a5ecdacc6 100644 (file)
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -132,7 +132,6 @@ struct nfs_client {
        struct timespec64       cl_nfssvc_boot;
        seqlock_t               cl_boot_lock;
        nfs_uuid_t              cl_uuid;
-       spinlock_t              cl_localio_lock;
 #endif /* CONFIG_NFS_LOCALIO */
 };
 

diff --git a/include/linux/nfslocalio.h b/include/linux/nfslocalio.h
index a05d1043f2b07e671e492842f6207e0f410e71a2..4d5583873f41877089e63d37caa01c1d7c772523 100644 (file)
--- a/include/linux/nfslocalio.h
+++ b/include/linux/nfslocalio.h
@@ -6,6 +6,7 @@
 #ifndef __LINUX_NFSLOCALIO_H
 #define __LINUX_NFSLOCALIO_H
 
+
 /* nfsd_file structure is purposely kept opaque to NFS client */
 struct nfsd_file;
 
@@ -19,6 +20,8 @@ struct nfsd_file;
 #include <linux/nfs.h>
 #include <net/net_namespace.h>
 
+struct nfs_client;
+
 /*
  * Useful to allow a client to negotiate if localio
  * possible with its server.
@@ -27,6 +30,8 @@ struct nfsd_file;
  */
 typedef struct {
        uuid_t uuid;
+       /* sadly this struct is just over a cacheline, avoid bouncing */
+       spinlock_t ____cacheline_aligned lock;
        struct list_head list;
        struct net __rcu *net; /* nfsd's network namespace */
        struct auth_domain *dom; /* auth_domain for localio */
@@ -38,7 +43,8 @@ void nfs_uuid_end(nfs_uuid_t *);
 void nfs_uuid_is_local(const uuid_t *, struct list_head *,
                       struct net *, struct auth_domain *, struct module *);
 
-void nfs_localio_disable_client(nfs_uuid_t *nfs_uuid);
+void nfs_localio_enable_client(struct nfs_client *clp);
+void nfs_localio_disable_client(struct nfs_client *clp);
 void nfs_localio_invalidate_clients(struct list_head *list);
 
 /* localio needs to map filehandle -> struct nfsd_file */