]> Git Repo - J-linux.git/blob - fs/nfs_common/nfslocalio.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / fs / nfs_common / nfslocalio.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2024 Mike Snitzer <[email protected]>
4  * Copyright (C) 2024 NeilBrown <[email protected]>
5  */
6
7 #include <linux/module.h>
8 #include <linux/list.h>
9 #include <linux/nfslocalio.h>
10 #include <net/netns/generic.h>
11
12 MODULE_LICENSE("GPL");
13 MODULE_DESCRIPTION("NFS localio protocol bypass support");
14
15 static DEFINE_SPINLOCK(nfs_uuid_lock);
16
17 /*
18  * Global list of nfs_uuid_t instances
19  * that is protected by nfs_uuid_lock.
20  */
21 static LIST_HEAD(nfs_uuids);
22
23 void nfs_uuid_init(nfs_uuid_t *nfs_uuid)
24 {
25         nfs_uuid->net = NULL;
26         nfs_uuid->dom = NULL;
27         INIT_LIST_HEAD(&nfs_uuid->list);
28 }
29 EXPORT_SYMBOL_GPL(nfs_uuid_init);
30
31 bool nfs_uuid_begin(nfs_uuid_t *nfs_uuid)
32 {
33         spin_lock(&nfs_uuid_lock);
34         /* Is this nfs_uuid already in use? */
35         if (!list_empty(&nfs_uuid->list)) {
36                 spin_unlock(&nfs_uuid_lock);
37                 return false;
38         }
39         uuid_gen(&nfs_uuid->uuid);
40         list_add_tail(&nfs_uuid->list, &nfs_uuids);
41         spin_unlock(&nfs_uuid_lock);
42
43         return true;
44 }
45 EXPORT_SYMBOL_GPL(nfs_uuid_begin);
46
47 void nfs_uuid_end(nfs_uuid_t *nfs_uuid)
48 {
49         if (nfs_uuid->net == NULL) {
50                 spin_lock(&nfs_uuid_lock);
51                 if (nfs_uuid->net == NULL)
52                         list_del_init(&nfs_uuid->list);
53                 spin_unlock(&nfs_uuid_lock);
54         }
55 }
56 EXPORT_SYMBOL_GPL(nfs_uuid_end);
57
58 static nfs_uuid_t * nfs_uuid_lookup_locked(const uuid_t *uuid)
59 {
60         nfs_uuid_t *nfs_uuid;
61
62         list_for_each_entry(nfs_uuid, &nfs_uuids, list)
63                 if (uuid_equal(&nfs_uuid->uuid, uuid))
64                         return nfs_uuid;
65
66         return NULL;
67 }
68
69 static struct module *nfsd_mod;
70
71 void nfs_uuid_is_local(const uuid_t *uuid, struct list_head *list,
72                        struct net *net, struct auth_domain *dom,
73                        struct module *mod)
74 {
75         nfs_uuid_t *nfs_uuid;
76
77         spin_lock(&nfs_uuid_lock);
78         nfs_uuid = nfs_uuid_lookup_locked(uuid);
79         if (nfs_uuid) {
80                 kref_get(&dom->ref);
81                 nfs_uuid->dom = dom;
82                 /*
83                  * We don't hold a ref on the net, but instead put
84                  * ourselves on a list so the net pointer can be
85                  * invalidated.
86                  */
87                 list_move(&nfs_uuid->list, list);
88                 rcu_assign_pointer(nfs_uuid->net, net);
89
90                 __module_get(mod);
91                 nfsd_mod = mod;
92         }
93         spin_unlock(&nfs_uuid_lock);
94 }
95 EXPORT_SYMBOL_GPL(nfs_uuid_is_local);
96
97 static void nfs_uuid_put_locked(nfs_uuid_t *nfs_uuid)
98 {
99         if (nfs_uuid->net) {
100                 module_put(nfsd_mod);
101                 nfs_uuid->net = NULL;
102         }
103         if (nfs_uuid->dom) {
104                 auth_domain_put(nfs_uuid->dom);
105                 nfs_uuid->dom = NULL;
106         }
107         list_del_init(&nfs_uuid->list);
108 }
109
110 void nfs_uuid_invalidate_clients(struct list_head *list)
111 {
112         nfs_uuid_t *nfs_uuid, *tmp;
113
114         spin_lock(&nfs_uuid_lock);
115         list_for_each_entry_safe(nfs_uuid, tmp, list, list)
116                 nfs_uuid_put_locked(nfs_uuid);
117         spin_unlock(&nfs_uuid_lock);
118 }
119 EXPORT_SYMBOL_GPL(nfs_uuid_invalidate_clients);
120
121 void nfs_uuid_invalidate_one_client(nfs_uuid_t *nfs_uuid)
122 {
123         if (nfs_uuid->net) {
124                 spin_lock(&nfs_uuid_lock);
125                 nfs_uuid_put_locked(nfs_uuid);
126                 spin_unlock(&nfs_uuid_lock);
127         }
128 }
129 EXPORT_SYMBOL_GPL(nfs_uuid_invalidate_one_client);
130
131 struct nfsd_file *nfs_open_local_fh(nfs_uuid_t *uuid,
132                    struct rpc_clnt *rpc_clnt, const struct cred *cred,
133                    const struct nfs_fh *nfs_fh, const fmode_t fmode)
134 {
135         struct net *net;
136         struct nfsd_file *localio;
137
138         /*
139          * Not running in nfsd context, so must safely get reference on nfsd_serv.
140          * But the server may already be shutting down, if so disallow new localio.
141          * uuid->net is NOT a counted reference, but rcu_read_lock() ensures that
142          * if uuid->net is not NULL, then calling nfsd_serv_try_get() is safe
143          * and if it succeeds we will have an implied reference to the net.
144          *
145          * Otherwise NFS may not have ref on NFSD and therefore cannot safely
146          * make 'nfs_to' calls.
147          */
148         rcu_read_lock();
149         net = rcu_dereference(uuid->net);
150         if (!net || !nfs_to->nfsd_serv_try_get(net)) {
151                 rcu_read_unlock();
152                 return ERR_PTR(-ENXIO);
153         }
154         rcu_read_unlock();
155         /* We have an implied reference to net thanks to nfsd_serv_try_get */
156         localio = nfs_to->nfsd_open_local_fh(net, uuid->dom, rpc_clnt,
157                                              cred, nfs_fh, fmode);
158         if (IS_ERR(localio))
159                 nfs_to_nfsd_net_put(net);
160
161         return localio;
162 }
163 EXPORT_SYMBOL_GPL(nfs_open_local_fh);
164
165 /*
166  * The NFS LOCALIO code needs to call into NFSD using various symbols,
167  * but cannot be statically linked, because that will make the NFS
168  * module always depend on the NFSD module.
169  *
170  * 'nfs_to' provides NFS access to NFSD functions needed for LOCALIO,
171  * its lifetime is tightly coupled to the NFSD module and will always
172  * be available to NFS LOCALIO because any successful client<->server
173  * LOCALIO handshake results in a reference on the NFSD module (above),
174  * so NFS implicitly holds a reference to the NFSD module and its
175  * functions in the 'nfs_to' nfsd_localio_operations cannot disappear.
176  *
177  * If the last NFS client using LOCALIO disconnects (and its reference
178  * on NFSD dropped) then NFSD could be unloaded, resulting in 'nfs_to'
179  * functions being invalid pointers. But if NFSD isn't loaded then NFS
180  * will not be able to handshake with NFSD and will have no cause to
181  * try to call 'nfs_to' function pointers. If/when NFSD is reloaded it
182  * will reinitialize the 'nfs_to' function pointers and make LOCALIO
183  * possible.
184  */
185 const struct nfsd_localio_operations *nfs_to;
186 EXPORT_SYMBOL_GPL(nfs_to);
This page took 0.034241 seconds and 4 git commands to generate.