Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* client.c: NFS client sharing and management code
3 : : *
4 : : * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
5 : : * Written by David Howells (dhowells@redhat.com)
6 : : */
7 : :
8 : :
9 : : #include <linux/module.h>
10 : : #include <linux/init.h>
11 : : #include <linux/sched.h>
12 : : #include <linux/time.h>
13 : : #include <linux/kernel.h>
14 : : #include <linux/mm.h>
15 : : #include <linux/string.h>
16 : : #include <linux/stat.h>
17 : : #include <linux/errno.h>
18 : : #include <linux/unistd.h>
19 : : #include <linux/sunrpc/addr.h>
20 : : #include <linux/sunrpc/clnt.h>
21 : : #include <linux/sunrpc/stats.h>
22 : : #include <linux/sunrpc/metrics.h>
23 : : #include <linux/sunrpc/xprtsock.h>
24 : : #include <linux/sunrpc/xprtrdma.h>
25 : : #include <linux/nfs_fs.h>
26 : : #include <linux/nfs_mount.h>
27 : : #include <linux/nfs4_mount.h>
28 : : #include <linux/lockd/bind.h>
29 : : #include <linux/seq_file.h>
30 : : #include <linux/mount.h>
31 : : #include <linux/vfs.h>
32 : : #include <linux/inet.h>
33 : : #include <linux/in6.h>
34 : : #include <linux/slab.h>
35 : : #include <linux/idr.h>
36 : : #include <net/ipv6.h>
37 : : #include <linux/nfs_xdr.h>
38 : : #include <linux/sunrpc/bc_xprt.h>
39 : : #include <linux/nsproxy.h>
40 : : #include <linux/pid_namespace.h>
41 : :
42 : :
43 : : #include "nfs4_fs.h"
44 : : #include "callback.h"
45 : : #include "delegation.h"
46 : : #include "iostat.h"
47 : : #include "internal.h"
48 : : #include "fscache.h"
49 : : #include "pnfs.h"
50 : : #include "nfs.h"
51 : : #include "netns.h"
52 : : #include "sysfs.h"
53 : :
54 : : #define NFSDBG_FACILITY NFSDBG_CLIENT
55 : :
56 : : static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
57 : : static DEFINE_SPINLOCK(nfs_version_lock);
58 : : static DEFINE_MUTEX(nfs_version_mutex);
59 : : static LIST_HEAD(nfs_versions);
60 : :
61 : : /*
62 : : * RPC cruft for NFS
63 : : */
64 : : static const struct rpc_version *nfs_version[5] = {
65 : : [2] = NULL,
66 : : [3] = NULL,
67 : : [4] = NULL,
68 : : };
69 : :
70 : : const struct rpc_program nfs_program = {
71 : : .name = "nfs",
72 : : .number = NFS_PROGRAM,
73 : : .nrvers = ARRAY_SIZE(nfs_version),
74 : : .version = nfs_version,
75 : : .stats = &nfs_rpcstat,
76 : : .pipe_dir_name = NFS_PIPE_DIRNAME,
77 : : };
78 : :
79 : : struct rpc_stat nfs_rpcstat = {
80 : : .program = &nfs_program
81 : : };
82 : :
83 : 0 : static struct nfs_subversion *find_nfs_version(unsigned int version)
84 : : {
85 : 0 : struct nfs_subversion *nfs;
86 : 0 : spin_lock(&nfs_version_lock);
87 : :
88 [ # # ]: 0 : list_for_each_entry(nfs, &nfs_versions, list) {
89 [ # # ]: 0 : if (nfs->rpc_ops->version == version) {
90 : 0 : spin_unlock(&nfs_version_lock);
91 : 0 : return nfs;
92 : : }
93 : : }
94 : :
95 : 0 : spin_unlock(&nfs_version_lock);
96 : 0 : return ERR_PTR(-EPROTONOSUPPORT);
97 : : }
98 : :
99 : 0 : struct nfs_subversion *get_nfs_version(unsigned int version)
100 : : {
101 : 0 : struct nfs_subversion *nfs = find_nfs_version(version);
102 : :
103 [ # # ]: 0 : if (IS_ERR(nfs)) {
104 : 0 : mutex_lock(&nfs_version_mutex);
105 : 0 : request_module("nfsv%d", version);
106 : 0 : nfs = find_nfs_version(version);
107 : 0 : mutex_unlock(&nfs_version_mutex);
108 : : }
109 : :
110 [ # # # # ]: 0 : if (!IS_ERR(nfs) && !try_module_get(nfs->owner))
111 : 0 : return ERR_PTR(-EAGAIN);
112 : : return nfs;
113 : : }
114 : :
115 : 0 : void put_nfs_version(struct nfs_subversion *nfs)
116 : : {
117 : 0 : module_put(nfs->owner);
118 : 0 : }
119 : :
120 : 33 : void register_nfs_version(struct nfs_subversion *nfs)
121 : : {
122 : 33 : spin_lock(&nfs_version_lock);
123 : :
124 : 33 : list_add(&nfs->list, &nfs_versions);
125 : 33 : nfs_version[nfs->rpc_ops->version] = nfs->rpc_vers;
126 : :
127 : 33 : spin_unlock(&nfs_version_lock);
128 : 33 : }
129 : : EXPORT_SYMBOL_GPL(register_nfs_version);
130 : :
131 : 0 : void unregister_nfs_version(struct nfs_subversion *nfs)
132 : : {
133 : 0 : spin_lock(&nfs_version_lock);
134 : :
135 : 0 : nfs_version[nfs->rpc_ops->version] = NULL;
136 : 0 : list_del(&nfs->list);
137 : :
138 : 0 : spin_unlock(&nfs_version_lock);
139 : 0 : }
140 : : EXPORT_SYMBOL_GPL(unregister_nfs_version);
141 : :
142 : : /*
143 : : * Allocate a shared client record
144 : : *
145 : : * Since these are allocated/deallocated very rarely, we don't
146 : : * bother putting them in a slab cache...
147 : : */
148 : 0 : struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
149 : : {
150 : 0 : struct nfs_client *clp;
151 : 0 : int err = -ENOMEM;
152 : :
153 [ # # ]: 0 : if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
154 : 0 : goto error_0;
155 : :
156 : 0 : clp->cl_minorversion = cl_init->minorversion;
157 : 0 : clp->cl_nfs_mod = cl_init->nfs_mod;
158 [ # # ]: 0 : if (!try_module_get(clp->cl_nfs_mod->owner))
159 : 0 : goto error_dealloc;
160 : :
161 : 0 : clp->rpc_ops = clp->cl_nfs_mod->rpc_ops;
162 : :
163 : 0 : refcount_set(&clp->cl_count, 1);
164 : 0 : clp->cl_cons_state = NFS_CS_INITING;
165 : :
166 : 0 : memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
167 : 0 : clp->cl_addrlen = cl_init->addrlen;
168 : :
169 [ # # ]: 0 : if (cl_init->hostname) {
170 : 0 : err = -ENOMEM;
171 : 0 : clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
172 [ # # ]: 0 : if (!clp->cl_hostname)
173 : 0 : goto error_cleanup;
174 : : }
175 : :
176 : 0 : INIT_LIST_HEAD(&clp->cl_superblocks);
177 : 0 : clp->cl_rpcclient = ERR_PTR(-EINVAL);
178 : :
179 : 0 : clp->cl_proto = cl_init->proto;
180 : 0 : clp->cl_nconnect = cl_init->nconnect;
181 : 0 : clp->cl_net = get_net(cl_init->net);
182 : :
183 : 0 : clp->cl_principal = "*";
184 : 0 : nfs_fscache_get_client_cookie(clp);
185 : :
186 : 0 : return clp;
187 : :
188 : : error_cleanup:
189 : 0 : put_nfs_version(clp->cl_nfs_mod);
190 : 0 : error_dealloc:
191 : 0 : kfree(clp);
192 : : error_0:
193 : : return ERR_PTR(err);
194 : : }
195 : : EXPORT_SYMBOL_GPL(nfs_alloc_client);
196 : :
197 : : #if IS_ENABLED(CONFIG_NFS_V4)
198 : 0 : static void nfs_cleanup_cb_ident_idr(struct net *net)
199 : : {
200 : 0 : struct nfs_net *nn = net_generic(net, nfs_net_id);
201 : :
202 : 0 : idr_destroy(&nn->cb_ident_idr);
203 : : }
204 : :
205 : : /* nfs_client_lock held */
206 : 0 : static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
207 : : {
208 : 0 : struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
209 : :
210 [ # # ]: 0 : if (clp->cl_cb_ident)
211 : 0 : idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident);
212 : : }
213 : :
214 : 0 : static void pnfs_init_server(struct nfs_server *server)
215 : : {
216 : 0 : rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
217 : : }
218 : :
219 : : #else
220 : : static void nfs_cleanup_cb_ident_idr(struct net *net)
221 : : {
222 : : }
223 : :
224 : : static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
225 : : {
226 : : }
227 : :
228 : : static void pnfs_init_server(struct nfs_server *server)
229 : : {
230 : : }
231 : :
232 : : #endif /* CONFIG_NFS_V4 */
233 : :
234 : : /*
235 : : * Destroy a shared client record
236 : : */
237 : 0 : void nfs_free_client(struct nfs_client *clp)
238 : : {
239 [ # # ]: 0 : nfs_fscache_release_client_cookie(clp);
240 : :
241 : : /* -EIO all pending I/O */
242 [ # # ]: 0 : if (!IS_ERR(clp->cl_rpcclient))
243 : 0 : rpc_shutdown_client(clp->cl_rpcclient);
244 : :
245 : 0 : put_net(clp->cl_net);
246 : 0 : put_nfs_version(clp->cl_nfs_mod);
247 : 0 : kfree(clp->cl_hostname);
248 : 0 : kfree(clp->cl_acceptor);
249 : 0 : kfree(clp);
250 : 0 : }
251 : : EXPORT_SYMBOL_GPL(nfs_free_client);
252 : :
253 : : /*
254 : : * Release a reference to a shared client record
255 : : */
256 : 0 : void nfs_put_client(struct nfs_client *clp)
257 : : {
258 : 0 : struct nfs_net *nn;
259 : :
260 [ # # ]: 0 : if (!clp)
261 : : return;
262 : :
263 : 0 : nn = net_generic(clp->cl_net, nfs_net_id);
264 : :
265 [ # # ]: 0 : if (refcount_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) {
266 : 0 : list_del(&clp->cl_share_link);
267 : 0 : nfs_cb_idr_remove_locked(clp);
268 : 0 : spin_unlock(&nn->nfs_client_lock);
269 : :
270 [ # # ]: 0 : WARN_ON_ONCE(!list_empty(&clp->cl_superblocks));
271 : :
272 : 0 : clp->rpc_ops->free_client(clp);
273 : : }
274 : : }
275 : : EXPORT_SYMBOL_GPL(nfs_put_client);
276 : :
277 : : /*
278 : : * Find an nfs_client on the list that matches the initialisation data
279 : : * that is supplied.
280 : : */
281 : 0 : static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
282 : : {
283 : 0 : struct nfs_client *clp;
284 : 0 : const struct sockaddr *sap = data->addr;
285 : 0 : struct nfs_net *nn = net_generic(data->net, nfs_net_id);
286 : 0 : int error;
287 : :
288 : 0 : again:
289 [ # # ]: 0 : list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
290 : 0 : const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
291 : : /* Don't match clients that failed to initialise properly */
292 [ # # ]: 0 : if (clp->cl_cons_state < 0)
293 : 0 : continue;
294 : :
295 : : /* If a client is still initializing then we need to wait */
296 [ # # ]: 0 : if (clp->cl_cons_state > NFS_CS_READY) {
297 : 0 : refcount_inc(&clp->cl_count);
298 : 0 : spin_unlock(&nn->nfs_client_lock);
299 : 0 : error = nfs_wait_client_init_complete(clp);
300 : 0 : nfs_put_client(clp);
301 : 0 : spin_lock(&nn->nfs_client_lock);
302 [ # # ]: 0 : if (error < 0)
303 : 0 : return ERR_PTR(error);
304 : 0 : goto again;
305 : : }
306 : :
307 : : /* Different NFS versions cannot share the same nfs_client */
308 [ # # ]: 0 : if (clp->rpc_ops != data->nfs_mod->rpc_ops)
309 : 0 : continue;
310 : :
311 [ # # ]: 0 : if (clp->cl_proto != data->proto)
312 : 0 : continue;
313 : : /* Match nfsv4 minorversion */
314 [ # # ]: 0 : if (clp->cl_minorversion != data->minorversion)
315 : 0 : continue;
316 : :
317 : : /* Match request for a dedicated DS */
318 [ # # ]: 0 : if (test_bit(NFS_CS_DS, &data->init_flags) !=
319 : 0 : test_bit(NFS_CS_DS, &clp->cl_flags))
320 : 0 : continue;
321 : :
322 : : /* Match the full socket address */
323 [ # # ]: 0 : if (!rpc_cmp_addr_port(sap, clap))
324 : : /* Match all xprt_switch full socket addresses */
325 [ # # # # ]: 0 : if (IS_ERR(clp->cl_rpcclient) ||
326 : 0 : !rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient,
327 : : sap))
328 : 0 : continue;
329 : :
330 : 0 : refcount_inc(&clp->cl_count);
331 : 0 : return clp;
332 : : }
333 : : return NULL;
334 : : }
335 : :
336 : : /*
337 : : * Return true if @clp is done initializing, false if still working on it.
338 : : *
339 : : * Use nfs_client_init_status to check if it was successful.
340 : : */
341 : 0 : bool nfs_client_init_is_complete(const struct nfs_client *clp)
342 : : {
343 : 0 : return clp->cl_cons_state <= NFS_CS_READY;
344 : : }
345 : : EXPORT_SYMBOL_GPL(nfs_client_init_is_complete);
346 : :
347 : : /*
348 : : * Return 0 if @clp was successfully initialized, -errno otherwise.
349 : : *
350 : : * This must be called *after* nfs_client_init_is_complete() returns true,
351 : : * otherwise it will pop WARN_ON_ONCE and return -EINVAL
352 : : */
353 : 0 : int nfs_client_init_status(const struct nfs_client *clp)
354 : : {
355 : : /* called without checking nfs_client_init_is_complete */
356 [ # # ]: 0 : if (clp->cl_cons_state > NFS_CS_READY) {
357 : 0 : WARN_ON_ONCE(1);
358 : 0 : return -EINVAL;
359 : : }
360 : : return clp->cl_cons_state;
361 : : }
362 : : EXPORT_SYMBOL_GPL(nfs_client_init_status);
363 : :
364 : 0 : int nfs_wait_client_init_complete(const struct nfs_client *clp)
365 : : {
366 [ # # # # : 0 : return wait_event_killable(nfs_client_active_wq,
# # ]
367 : : nfs_client_init_is_complete(clp));
368 : : }
369 : : EXPORT_SYMBOL_GPL(nfs_wait_client_init_complete);
370 : :
371 : : /*
372 : : * Found an existing client. Make sure it's ready before returning.
373 : : */
374 : : static struct nfs_client *
375 : : nfs_found_client(const struct nfs_client_initdata *cl_init,
376 : : struct nfs_client *clp)
377 : : {
378 : : int error;
379 : :
380 : : error = nfs_wait_client_init_complete(clp);
381 : : if (error < 0) {
382 : : nfs_put_client(clp);
383 : : return ERR_PTR(-ERESTARTSYS);
384 : : }
385 : :
386 : : if (clp->cl_cons_state < NFS_CS_READY) {
387 : : error = clp->cl_cons_state;
388 : : nfs_put_client(clp);
389 : : return ERR_PTR(error);
390 : : }
391 : :
392 : : smp_rmb();
393 : : return clp;
394 : : }
395 : :
396 : : /*
397 : : * Look up a client by IP address and protocol version
398 : : * - creates a new record if one doesn't yet exist
399 : : */
400 : 0 : struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
401 : : {
402 : 0 : struct nfs_client *clp, *new = NULL;
403 : 0 : struct nfs_net *nn = net_generic(cl_init->net, nfs_net_id);
404 : 0 : const struct nfs_rpc_ops *rpc_ops = cl_init->nfs_mod->rpc_ops;
405 : :
406 [ # # ]: 0 : if (cl_init->hostname == NULL) {
407 : 0 : WARN_ON(1);
408 : 0 : return NULL;
409 : : }
410 : :
411 : : /* see if the client already exists */
412 : 0 : do {
413 : 0 : spin_lock(&nn->nfs_client_lock);
414 : :
415 : 0 : clp = nfs_match_client(cl_init);
416 [ # # ]: 0 : if (clp) {
417 : 0 : spin_unlock(&nn->nfs_client_lock);
418 [ # # ]: 0 : if (new)
419 : 0 : new->rpc_ops->free_client(new);
420 [ # # ]: 0 : if (IS_ERR(clp))
421 : : return clp;
422 : 0 : return nfs_found_client(cl_init, clp);
423 : : }
424 [ # # ]: 0 : if (new) {
425 : 0 : list_add_tail(&new->cl_share_link,
426 : : &nn->nfs_client_list);
427 : 0 : spin_unlock(&nn->nfs_client_lock);
428 : 0 : new->cl_flags = cl_init->init_flags;
429 : 0 : return rpc_ops->init_client(new, cl_init);
430 : : }
431 : :
432 : 0 : spin_unlock(&nn->nfs_client_lock);
433 : :
434 : 0 : new = rpc_ops->alloc_client(cl_init);
435 [ # # ]: 0 : } while (!IS_ERR(new));
436 : :
437 : : return new;
438 : : }
439 : : EXPORT_SYMBOL_GPL(nfs_get_client);
440 : :
441 : : /*
442 : : * Mark a server as ready or failed
443 : : */
444 : 0 : void nfs_mark_client_ready(struct nfs_client *clp, int state)
445 : : {
446 : 0 : smp_wmb();
447 : 0 : clp->cl_cons_state = state;
448 : 0 : wake_up_all(&nfs_client_active_wq);
449 : 0 : }
450 : : EXPORT_SYMBOL_GPL(nfs_mark_client_ready);
451 : :
452 : : /*
453 : : * Initialise the timeout values for a connection
454 : : */
455 : 0 : void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
456 : : int timeo, int retrans)
457 : : {
458 : 0 : to->to_initval = timeo * HZ / 10;
459 : 0 : to->to_retries = retrans;
460 : :
461 [ # # ]: 0 : switch (proto) {
462 : 0 : case XPRT_TRANSPORT_TCP:
463 : : case XPRT_TRANSPORT_RDMA:
464 [ # # ]: 0 : if (retrans == NFS_UNSPEC_RETRANS)
465 : 0 : to->to_retries = NFS_DEF_TCP_RETRANS;
466 [ # # # # ]: 0 : if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
467 : 0 : to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
468 [ # # ]: 0 : if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
469 : 0 : to->to_initval = NFS_MAX_TCP_TIMEOUT;
470 : 0 : to->to_increment = to->to_initval;
471 : 0 : to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
472 [ # # ]: 0 : if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
473 : 0 : to->to_maxval = NFS_MAX_TCP_TIMEOUT;
474 [ # # ]: 0 : if (to->to_maxval < to->to_initval)
475 : 0 : to->to_maxval = to->to_initval;
476 : 0 : to->to_exponential = 0;
477 : 0 : break;
478 : : #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
479 : : case XPRT_TRANSPORT_UDP:
480 : : if (retrans == NFS_UNSPEC_RETRANS)
481 : : to->to_retries = NFS_DEF_UDP_RETRANS;
482 : : if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
483 : : to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
484 : : if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
485 : : to->to_initval = NFS_MAX_UDP_TIMEOUT;
486 : : to->to_maxval = NFS_MAX_UDP_TIMEOUT;
487 : : to->to_exponential = 1;
488 : : break;
489 : : #endif
490 : 0 : default:
491 : 0 : BUG();
492 : : }
493 : 0 : }
494 : : EXPORT_SYMBOL_GPL(nfs_init_timeout_values);
495 : :
496 : : /*
497 : : * Create an RPC client handle
498 : : */
499 : 0 : int nfs_create_rpc_client(struct nfs_client *clp,
500 : : const struct nfs_client_initdata *cl_init,
501 : : rpc_authflavor_t flavor)
502 : : {
503 : 0 : struct rpc_clnt *clnt = NULL;
504 : 0 : struct rpc_create_args args = {
505 : 0 : .net = clp->cl_net,
506 : 0 : .protocol = clp->cl_proto,
507 : 0 : .nconnect = clp->cl_nconnect,
508 : 0 : .address = (struct sockaddr *)&clp->cl_addr,
509 : 0 : .addrsize = clp->cl_addrlen,
510 : 0 : .timeout = cl_init->timeparms,
511 : 0 : .servername = clp->cl_hostname,
512 : 0 : .nodename = cl_init->nodename,
513 : : .program = &nfs_program,
514 : 0 : .version = clp->rpc_ops->version,
515 : : .authflavor = flavor,
516 : 0 : .cred = cl_init->cred,
517 : : };
518 : :
519 [ # # ]: 0 : if (test_bit(NFS_CS_DISCRTRY, &clp->cl_flags))
520 : 0 : args.flags |= RPC_CLNT_CREATE_DISCRTRY;
521 [ # # ]: 0 : if (test_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags))
522 : 0 : args.flags |= RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT;
523 [ # # ]: 0 : if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags))
524 : 0 : args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
525 [ # # ]: 0 : if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags))
526 : 0 : args.flags |= RPC_CLNT_CREATE_INFINITE_SLOTS;
527 [ # # ]: 0 : if (test_bit(NFS_CS_NOPING, &clp->cl_flags))
528 : 0 : args.flags |= RPC_CLNT_CREATE_NOPING;
529 [ # # ]: 0 : if (test_bit(NFS_CS_REUSEPORT, &clp->cl_flags))
530 : 0 : args.flags |= RPC_CLNT_CREATE_REUSEPORT;
531 : :
532 [ # # ]: 0 : if (!IS_ERR(clp->cl_rpcclient))
533 : : return 0;
534 : :
535 : 0 : clnt = rpc_create(&args);
536 [ # # ]: 0 : if (IS_ERR(clnt)) {
537 : 0 : dprintk("%s: cannot create RPC client. Error = %ld\n",
538 : : __func__, PTR_ERR(clnt));
539 : 0 : return PTR_ERR(clnt);
540 : : }
541 : :
542 : 0 : clnt->cl_principal = clp->cl_principal;
543 : 0 : clp->cl_rpcclient = clnt;
544 : 0 : return 0;
545 : : }
546 : : EXPORT_SYMBOL_GPL(nfs_create_rpc_client);
547 : :
548 : : /*
549 : : * Version 2 or 3 client destruction
550 : : */
551 : 0 : static void nfs_destroy_server(struct nfs_server *server)
552 : : {
553 [ # # ]: 0 : if (server->nlm_host)
554 : 0 : nlmclnt_done(server->nlm_host);
555 : 0 : }
556 : :
557 : : /*
558 : : * Version 2 or 3 lockd setup
559 : : */
560 : 0 : static int nfs_start_lockd(struct nfs_server *server)
561 : : {
562 : 0 : struct nlm_host *host;
563 : 0 : struct nfs_client *clp = server->nfs_client;
564 : 0 : struct nlmclnt_initdata nlm_init = {
565 : 0 : .hostname = clp->cl_hostname,
566 : 0 : .address = (struct sockaddr *)&clp->cl_addr,
567 : 0 : .addrlen = clp->cl_addrlen,
568 : 0 : .nfs_version = clp->rpc_ops->version,
569 : 0 : .noresvport = server->flags & NFS_MOUNT_NORESVPORT ?
570 : 0 : 1 : 0,
571 : 0 : .net = clp->cl_net,
572 : 0 : .nlmclnt_ops = clp->cl_nfs_mod->rpc_ops->nlmclnt_ops,
573 [ # # ]: 0 : .cred = current_cred(),
574 : : };
575 : :
576 [ # # ]: 0 : if (nlm_init.nfs_version > 3)
577 : : return 0;
578 [ # # ]: 0 : if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&
579 : : (server->flags & NFS_MOUNT_LOCAL_FCNTL))
580 : : return 0;
581 : :
582 : 0 : switch (clp->cl_proto) {
583 : : default:
584 : 0 : nlm_init.protocol = IPPROTO_TCP;
585 : 0 : break;
586 : : #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
587 : : case XPRT_TRANSPORT_UDP:
588 : : nlm_init.protocol = IPPROTO_UDP;
589 : : #endif
590 : : }
591 : :
592 : 0 : host = nlmclnt_init(&nlm_init);
593 [ # # ]: 0 : if (IS_ERR(host))
594 : 0 : return PTR_ERR(host);
595 : :
596 : 0 : server->nlm_host = host;
597 : 0 : server->destroy = nfs_destroy_server;
598 : 0 : return 0;
599 : : }
600 : :
601 : : /*
602 : : * Create a general RPC client
603 : : */
604 : 0 : int nfs_init_server_rpcclient(struct nfs_server *server,
605 : : const struct rpc_timeout *timeo,
606 : : rpc_authflavor_t pseudoflavour)
607 : : {
608 : 0 : struct nfs_client *clp = server->nfs_client;
609 : :
610 : 0 : server->client = rpc_clone_client_set_auth(clp->cl_rpcclient,
611 : : pseudoflavour);
612 [ # # ]: 0 : if (IS_ERR(server->client)) {
613 : 0 : dprintk("%s: couldn't create rpc_client!\n", __func__);
614 : 0 : return PTR_ERR(server->client);
615 : : }
616 : :
617 : 0 : memcpy(&server->client->cl_timeout_default,
618 : : timeo,
619 : : sizeof(server->client->cl_timeout_default));
620 : 0 : server->client->cl_timeout = &server->client->cl_timeout_default;
621 : 0 : server->client->cl_softrtry = 0;
622 [ # # ]: 0 : if (server->flags & NFS_MOUNT_SOFTERR)
623 : 0 : server->client->cl_softerr = 1;
624 [ # # ]: 0 : if (server->flags & NFS_MOUNT_SOFT)
625 : 0 : server->client->cl_softrtry = 1;
626 : :
627 : : return 0;
628 : : }
629 : : EXPORT_SYMBOL_GPL(nfs_init_server_rpcclient);
630 : :
631 : : /**
632 : : * nfs_init_client - Initialise an NFS2 or NFS3 client
633 : : *
634 : : * @clp: nfs_client to initialise
635 : : * @cl_init: Initialisation parameters
636 : : *
637 : : * Returns pointer to an NFS client, or an ERR_PTR value.
638 : : */
639 : 0 : struct nfs_client *nfs_init_client(struct nfs_client *clp,
640 : : const struct nfs_client_initdata *cl_init)
641 : : {
642 : 0 : int error;
643 : :
644 : : /* the client is already initialised */
645 [ # # ]: 0 : if (clp->cl_cons_state == NFS_CS_READY)
646 : : return clp;
647 : :
648 : : /*
649 : : * Create a client RPC handle for doing FSSTAT with UNIX auth only
650 : : * - RFC 2623, sec 2.3.2
651 : : */
652 : 0 : error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX);
653 : 0 : nfs_mark_client_ready(clp, error == 0 ? NFS_CS_READY : error);
654 [ # # ]: 0 : if (error < 0) {
655 : 0 : nfs_put_client(clp);
656 : 0 : clp = ERR_PTR(error);
657 : : }
658 : : return clp;
659 : : }
660 : : EXPORT_SYMBOL_GPL(nfs_init_client);
661 : :
662 : : /*
663 : : * Create a version 2 or 3 client
664 : : */
665 : 0 : static int nfs_init_server(struct nfs_server *server,
666 : : const struct fs_context *fc)
667 : : {
668 : 0 : const struct nfs_fs_context *ctx = nfs_fc2context(fc);
669 : 0 : struct rpc_timeout timeparms;
670 : 0 : struct nfs_client_initdata cl_init = {
671 : 0 : .hostname = ctx->nfs_server.hostname,
672 : 0 : .addr = (const struct sockaddr *)&ctx->nfs_server.address,
673 : 0 : .addrlen = ctx->nfs_server.addrlen,
674 : 0 : .nfs_mod = ctx->nfs_mod,
675 : 0 : .proto = ctx->nfs_server.protocol,
676 : 0 : .net = fc->net_ns,
677 : : .timeparms = &timeparms,
678 : 0 : .cred = server->cred,
679 : 0 : .nconnect = ctx->nfs_server.nconnect,
680 : : .init_flags = (1UL << NFS_CS_REUSEPORT),
681 : : };
682 : 0 : struct nfs_client *clp;
683 : 0 : int error;
684 : :
685 : 0 : nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
686 : 0 : ctx->timeo, ctx->retrans);
687 [ # # ]: 0 : if (ctx->flags & NFS_MOUNT_NORESVPORT)
688 : 0 : set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
689 : :
690 : : /* Allocate or find a client reference we can use */
691 : 0 : clp = nfs_get_client(&cl_init);
692 [ # # ]: 0 : if (IS_ERR(clp))
693 : 0 : return PTR_ERR(clp);
694 : :
695 : 0 : server->nfs_client = clp;
696 : :
697 : : /* Initialise the client representation from the mount data */
698 : 0 : server->flags = ctx->flags;
699 : 0 : server->options = ctx->options;
700 : 0 : server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
701 : : NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
702 : : NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
703 : :
704 [ # # ]: 0 : if (ctx->rsize)
705 [ # # ]: 0 : server->rsize = nfs_block_size(ctx->rsize, NULL);
706 [ # # ]: 0 : if (ctx->wsize)
707 [ # # ]: 0 : server->wsize = nfs_block_size(ctx->wsize, NULL);
708 : :
709 : 0 : server->acregmin = ctx->acregmin * HZ;
710 : 0 : server->acregmax = ctx->acregmax * HZ;
711 : 0 : server->acdirmin = ctx->acdirmin * HZ;
712 : 0 : server->acdirmax = ctx->acdirmax * HZ;
713 : :
714 : : /* Start lockd here, before we might error out */
715 : 0 : error = nfs_start_lockd(server);
716 [ # # ]: 0 : if (error < 0)
717 : 0 : goto error;
718 : :
719 : 0 : server->port = ctx->nfs_server.port;
720 : 0 : server->auth_info = ctx->auth_info;
721 : :
722 : 0 : error = nfs_init_server_rpcclient(server, &timeparms,
723 : : ctx->selected_flavor);
724 [ # # ]: 0 : if (error < 0)
725 : 0 : goto error;
726 : :
727 : : /* Preserve the values of mount_server-related mount options */
728 [ # # ]: 0 : if (ctx->mount_server.addrlen) {
729 : 0 : memcpy(&server->mountd_address, &ctx->mount_server.address,
730 : : ctx->mount_server.addrlen);
731 : 0 : server->mountd_addrlen = ctx->mount_server.addrlen;
732 : : }
733 : 0 : server->mountd_version = ctx->mount_server.version;
734 : 0 : server->mountd_port = ctx->mount_server.port;
735 : 0 : server->mountd_protocol = ctx->mount_server.protocol;
736 : :
737 : 0 : server->namelen = ctx->namlen;
738 : 0 : return 0;
739 : :
740 : 0 : error:
741 : 0 : server->nfs_client = NULL;
742 : 0 : nfs_put_client(clp);
743 : 0 : return error;
744 : : }
745 : :
746 : : /*
747 : : * Load up the server record from information gained in an fsinfo record
748 : : */
749 : 0 : static void nfs_server_set_fsinfo(struct nfs_server *server,
750 : : struct nfs_fsinfo *fsinfo)
751 : : {
752 : 0 : unsigned long max_rpc_payload;
753 : :
754 : : /* Work out a lot of parameters */
755 [ # # ]: 0 : if (server->rsize == 0)
756 [ # # ]: 0 : server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
757 [ # # ]: 0 : if (server->wsize == 0)
758 [ # # ]: 0 : server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
759 : :
760 [ # # # # ]: 0 : if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
761 [ # # ]: 0 : server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
762 [ # # # # ]: 0 : if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
763 [ # # ]: 0 : server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
764 : :
765 : 0 : max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
766 [ # # ]: 0 : if (server->rsize > max_rpc_payload)
767 : 0 : server->rsize = max_rpc_payload;
768 [ # # ]: 0 : if (server->rsize > NFS_MAX_FILE_IO_SIZE)
769 : 0 : server->rsize = NFS_MAX_FILE_IO_SIZE;
770 : 0 : server->rpages = (server->rsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
771 : :
772 [ # # ]: 0 : if (server->wsize > max_rpc_payload)
773 : 0 : server->wsize = max_rpc_payload;
774 [ # # ]: 0 : if (server->wsize > NFS_MAX_FILE_IO_SIZE)
775 : 0 : server->wsize = NFS_MAX_FILE_IO_SIZE;
776 : 0 : server->wpages = (server->wsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
777 : :
778 [ # # ]: 0 : server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
779 : :
780 [ # # ]: 0 : server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
781 [ # # ]: 0 : if (server->dtsize > PAGE_SIZE * NFS_MAX_READDIR_PAGES)
782 : 0 : server->dtsize = PAGE_SIZE * NFS_MAX_READDIR_PAGES;
783 [ # # ]: 0 : if (server->dtsize > server->rsize)
784 : 0 : server->dtsize = server->rsize;
785 : :
786 [ # # ]: 0 : if (server->flags & NFS_MOUNT_NOAC) {
787 : 0 : server->acregmin = server->acregmax = 0;
788 : 0 : server->acdirmin = server->acdirmax = 0;
789 : : }
790 : :
791 : 0 : server->maxfilesize = fsinfo->maxfilesize;
792 : :
793 : 0 : server->time_delta = fsinfo->time_delta;
794 : :
795 : 0 : server->clone_blksize = fsinfo->clone_blksize;
796 : : /* We're airborne Set socket buffersize */
797 : 0 : rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
798 : 0 : }
799 : :
800 : : /*
801 : : * Probe filesystem information, including the FSID on v2/v3
802 : : */
803 : 0 : int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
804 : : {
805 : 0 : struct nfs_fsinfo fsinfo;
806 : 0 : struct nfs_client *clp = server->nfs_client;
807 : 0 : int error;
808 : :
809 [ # # ]: 0 : if (clp->rpc_ops->set_capabilities != NULL) {
810 : 0 : error = clp->rpc_ops->set_capabilities(server, mntfh);
811 [ # # ]: 0 : if (error < 0)
812 : : return error;
813 : : }
814 : :
815 : 0 : fsinfo.fattr = fattr;
816 : 0 : fsinfo.nlayouttypes = 0;
817 : 0 : memset(fsinfo.layouttype, 0, sizeof(fsinfo.layouttype));
818 : 0 : error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
819 [ # # ]: 0 : if (error < 0)
820 : : return error;
821 : :
822 : 0 : nfs_server_set_fsinfo(server, &fsinfo);
823 : :
824 : : /* Get some general file system info */
825 [ # # ]: 0 : if (server->namelen == 0) {
826 : 0 : struct nfs_pathconf pathinfo;
827 : :
828 : 0 : pathinfo.fattr = fattr;
829 : 0 : nfs_fattr_init(fattr);
830 : :
831 [ # # ]: 0 : if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
832 : 0 : server->namelen = pathinfo.max_namelen;
833 : : }
834 : :
835 : : return 0;
836 : : }
837 : : EXPORT_SYMBOL_GPL(nfs_probe_fsinfo);
838 : :
839 : : /*
840 : : * Copy useful information when duplicating a server record
841 : : */
842 : 0 : void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
843 : : {
844 : 0 : target->flags = source->flags;
845 : 0 : target->rsize = source->rsize;
846 : 0 : target->wsize = source->wsize;
847 : 0 : target->acregmin = source->acregmin;
848 : 0 : target->acregmax = source->acregmax;
849 : 0 : target->acdirmin = source->acdirmin;
850 : 0 : target->acdirmax = source->acdirmax;
851 : 0 : target->caps = source->caps;
852 : 0 : target->options = source->options;
853 : 0 : target->auth_info = source->auth_info;
854 : 0 : target->port = source->port;
855 : 0 : }
856 : : EXPORT_SYMBOL_GPL(nfs_server_copy_userdata);
857 : :
858 : 0 : void nfs_server_insert_lists(struct nfs_server *server)
859 : : {
860 : 0 : struct nfs_client *clp = server->nfs_client;
861 : 0 : struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
862 : :
863 : 0 : spin_lock(&nn->nfs_client_lock);
864 : 0 : list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);
865 : 0 : list_add_tail(&server->master_link, &nn->nfs_volume_list);
866 : 0 : clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
867 : 0 : spin_unlock(&nn->nfs_client_lock);
868 : :
869 : 0 : }
870 : : EXPORT_SYMBOL_GPL(nfs_server_insert_lists);
871 : :
872 : 0 : void nfs_server_remove_lists(struct nfs_server *server)
873 : : {
874 : 0 : struct nfs_client *clp = server->nfs_client;
875 : 0 : struct nfs_net *nn;
876 : :
877 [ # # ]: 0 : if (clp == NULL)
878 : : return;
879 : 0 : nn = net_generic(clp->cl_net, nfs_net_id);
880 : 0 : spin_lock(&nn->nfs_client_lock);
881 [ # # ]: 0 : list_del_rcu(&server->client_link);
882 [ # # ]: 0 : if (list_empty(&clp->cl_superblocks))
883 : 0 : set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
884 : 0 : list_del(&server->master_link);
885 : 0 : spin_unlock(&nn->nfs_client_lock);
886 : :
887 : 0 : synchronize_rcu();
888 : : }
889 : : EXPORT_SYMBOL_GPL(nfs_server_remove_lists);
890 : :
891 : : /*
892 : : * Allocate and initialise a server record
893 : : */
894 : 0 : struct nfs_server *nfs_alloc_server(void)
895 : : {
896 : 0 : struct nfs_server *server;
897 : :
898 : 0 : server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
899 [ # # ]: 0 : if (!server)
900 : : return NULL;
901 : :
902 : 0 : server->client = server->client_acl = ERR_PTR(-EINVAL);
903 : :
904 : : /* Zero out the NFS state stuff */
905 : 0 : INIT_LIST_HEAD(&server->client_link);
906 : 0 : INIT_LIST_HEAD(&server->master_link);
907 : 0 : INIT_LIST_HEAD(&server->delegations);
908 : 0 : INIT_LIST_HEAD(&server->layouts);
909 : 0 : INIT_LIST_HEAD(&server->state_owners_lru);
910 : 0 : INIT_LIST_HEAD(&server->ss_copies);
911 : :
912 : 0 : atomic_set(&server->active, 0);
913 : :
914 : 0 : server->io_stats = nfs_alloc_iostats();
915 [ # # ]: 0 : if (!server->io_stats) {
916 : 0 : kfree(server);
917 : 0 : return NULL;
918 : : }
919 : :
920 : 0 : ida_init(&server->openowner_id);
921 : 0 : ida_init(&server->lockowner_id);
922 : 0 : pnfs_init_server(server);
923 : 0 : rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");
924 : :
925 : 0 : return server;
926 : : }
927 : : EXPORT_SYMBOL_GPL(nfs_alloc_server);
928 : :
929 : : /*
930 : : * Free up a server record
931 : : */
932 : 0 : void nfs_free_server(struct nfs_server *server)
933 : : {
934 : 0 : nfs_server_remove_lists(server);
935 : :
936 [ # # ]: 0 : if (server->destroy != NULL)
937 : 0 : server->destroy(server);
938 : :
939 [ # # ]: 0 : if (!IS_ERR(server->client_acl))
940 : 0 : rpc_shutdown_client(server->client_acl);
941 [ # # ]: 0 : if (!IS_ERR(server->client))
942 : 0 : rpc_shutdown_client(server->client);
943 : :
944 : 0 : nfs_put_client(server->nfs_client);
945 : :
946 : 0 : ida_destroy(&server->lockowner_id);
947 : 0 : ida_destroy(&server->openowner_id);
948 [ # # ]: 0 : nfs_free_iostats(server->io_stats);
949 : 0 : put_cred(server->cred);
950 : 0 : kfree(server);
951 : 0 : nfs_release_automount_timer();
952 : 0 : }
953 : : EXPORT_SYMBOL_GPL(nfs_free_server);
954 : :
955 : : /*
956 : : * Create a version 2 or 3 volume record
957 : : * - keyed on server and FSID
958 : : */
959 : 0 : struct nfs_server *nfs_create_server(struct fs_context *fc)
960 : : {
961 : 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
962 : 0 : struct nfs_server *server;
963 : 0 : struct nfs_fattr *fattr;
964 : 0 : int error;
965 : :
966 : 0 : server = nfs_alloc_server();
967 [ # # ]: 0 : if (!server)
968 : : return ERR_PTR(-ENOMEM);
969 : :
970 [ # # ]: 0 : server->cred = get_cred(current_cred());
971 : :
972 : 0 : error = -ENOMEM;
973 : 0 : fattr = nfs_alloc_fattr();
974 [ # # ]: 0 : if (fattr == NULL)
975 : 0 : goto error;
976 : :
977 : : /* Get a client representation */
978 : 0 : error = nfs_init_server(server, fc);
979 [ # # ]: 0 : if (error < 0)
980 : 0 : goto error;
981 : :
982 : : /* Probe the root fh to retrieve its FSID */
983 : 0 : error = nfs_probe_fsinfo(server, ctx->mntfh, fattr);
984 [ # # ]: 0 : if (error < 0)
985 : 0 : goto error;
986 [ # # ]: 0 : if (server->nfs_client->rpc_ops->version == 3) {
987 [ # # ]: 0 : if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
988 : 0 : server->namelen = NFS3_MAXNAMLEN;
989 [ # # ]: 0 : if (!(ctx->flags & NFS_MOUNT_NORDIRPLUS))
990 : 0 : server->caps |= NFS_CAP_READDIRPLUS;
991 : : } else {
992 [ # # ]: 0 : if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
993 : 0 : server->namelen = NFS2_MAXNAMLEN;
994 : : }
995 : :
996 [ # # ]: 0 : if (!(fattr->valid & NFS_ATTR_FATTR)) {
997 : 0 : error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,
998 : : fattr, NULL, NULL);
999 [ # # ]: 0 : if (error < 0) {
1000 : 0 : dprintk("nfs_create_server: getattr error = %d\n", -error);
1001 : 0 : goto error;
1002 : : }
1003 : : }
1004 : 0 : memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
1005 : :
1006 : 0 : dprintk("Server FSID: %llx:%llx\n",
1007 : : (unsigned long long) server->fsid.major,
1008 : : (unsigned long long) server->fsid.minor);
1009 : :
1010 : 0 : nfs_server_insert_lists(server);
1011 : 0 : server->mount_time = jiffies;
1012 : 0 : nfs_free_fattr(fattr);
1013 : 0 : return server;
1014 : :
1015 : 0 : error:
1016 : 0 : nfs_free_fattr(fattr);
1017 : 0 : nfs_free_server(server);
1018 : 0 : return ERR_PTR(error);
1019 : : }
1020 : : EXPORT_SYMBOL_GPL(nfs_create_server);
1021 : :
1022 : : /*
1023 : : * Clone an NFS2, NFS3 or NFS4 server record
1024 : : */
1025 : 0 : struct nfs_server *nfs_clone_server(struct nfs_server *source,
1026 : : struct nfs_fh *fh,
1027 : : struct nfs_fattr *fattr,
1028 : : rpc_authflavor_t flavor)
1029 : : {
1030 : 0 : struct nfs_server *server;
1031 : 0 : struct nfs_fattr *fattr_fsinfo;
1032 : 0 : int error;
1033 : :
1034 : 0 : server = nfs_alloc_server();
1035 [ # # ]: 0 : if (!server)
1036 : : return ERR_PTR(-ENOMEM);
1037 : :
1038 [ # # ]: 0 : server->cred = get_cred(source->cred);
1039 : :
1040 : 0 : error = -ENOMEM;
1041 : 0 : fattr_fsinfo = nfs_alloc_fattr();
1042 [ # # ]: 0 : if (fattr_fsinfo == NULL)
1043 : 0 : goto out_free_server;
1044 : :
1045 : : /* Copy data from the source */
1046 : 0 : server->nfs_client = source->nfs_client;
1047 : 0 : server->destroy = source->destroy;
1048 : 0 : refcount_inc(&server->nfs_client->cl_count);
1049 : 0 : nfs_server_copy_userdata(server, source);
1050 : :
1051 : 0 : server->fsid = fattr->fsid;
1052 : :
1053 : 0 : error = nfs_init_server_rpcclient(server,
1054 : 0 : source->client->cl_timeout,
1055 : : flavor);
1056 [ # # ]: 0 : if (error < 0)
1057 : 0 : goto out_free_server;
1058 : :
1059 : : /* probe the filesystem info for this server filesystem */
1060 : 0 : error = nfs_probe_fsinfo(server, fh, fattr_fsinfo);
1061 [ # # ]: 0 : if (error < 0)
1062 : 0 : goto out_free_server;
1063 : :
1064 [ # # ]: 0 : if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1065 : 0 : server->namelen = NFS4_MAXNAMLEN;
1066 : :
1067 : 0 : error = nfs_start_lockd(server);
1068 [ # # ]: 0 : if (error < 0)
1069 : 0 : goto out_free_server;
1070 : :
1071 : 0 : nfs_server_insert_lists(server);
1072 : 0 : server->mount_time = jiffies;
1073 : :
1074 : 0 : nfs_free_fattr(fattr_fsinfo);
1075 : 0 : return server;
1076 : :
1077 : 0 : out_free_server:
1078 : 0 : nfs_free_fattr(fattr_fsinfo);
1079 : 0 : nfs_free_server(server);
1080 : 0 : return ERR_PTR(error);
1081 : : }
1082 : : EXPORT_SYMBOL_GPL(nfs_clone_server);
1083 : :
1084 : 11 : void nfs_clients_init(struct net *net)
1085 : : {
1086 : 11 : struct nfs_net *nn = net_generic(net, nfs_net_id);
1087 : :
1088 : 11 : INIT_LIST_HEAD(&nn->nfs_client_list);
1089 : 11 : INIT_LIST_HEAD(&nn->nfs_volume_list);
1090 : : #if IS_ENABLED(CONFIG_NFS_V4)
1091 : 11 : idr_init(&nn->cb_ident_idr);
1092 : : #endif
1093 : 11 : spin_lock_init(&nn->nfs_client_lock);
1094 : 11 : nn->boot_time = ktime_get_real();
1095 : :
1096 : 11 : nfs_netns_sysfs_setup(nn, net);
1097 : 11 : }
1098 : :
1099 : 0 : void nfs_clients_exit(struct net *net)
1100 : : {
1101 : 0 : struct nfs_net *nn = net_generic(net, nfs_net_id);
1102 : :
1103 : 0 : nfs_netns_sysfs_destroy(nn);
1104 : 0 : nfs_cleanup_cb_ident_idr(net);
1105 [ # # ]: 0 : WARN_ON_ONCE(!list_empty(&nn->nfs_client_list));
1106 [ # # ]: 0 : WARN_ON_ONCE(!list_empty(&nn->nfs_volume_list));
1107 : 0 : }
1108 : :
1109 : : #ifdef CONFIG_PROC_FS
1110 : : static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
1111 : : static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
1112 : : static void nfs_server_list_stop(struct seq_file *p, void *v);
1113 : : static int nfs_server_list_show(struct seq_file *m, void *v);
1114 : :
1115 : : static const struct seq_operations nfs_server_list_ops = {
1116 : : .start = nfs_server_list_start,
1117 : : .next = nfs_server_list_next,
1118 : : .stop = nfs_server_list_stop,
1119 : : .show = nfs_server_list_show,
1120 : : };
1121 : :
1122 : : static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
1123 : : static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
1124 : : static void nfs_volume_list_stop(struct seq_file *p, void *v);
1125 : : static int nfs_volume_list_show(struct seq_file *m, void *v);
1126 : :
1127 : : static const struct seq_operations nfs_volume_list_ops = {
1128 : : .start = nfs_volume_list_start,
1129 : : .next = nfs_volume_list_next,
1130 : : .stop = nfs_volume_list_stop,
1131 : : .show = nfs_volume_list_show,
1132 : : };
1133 : :
1134 : : /*
1135 : : * set up the iterator to start reading from the server list and return the first item
1136 : : */
1137 : 0 : static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
1138 : : __acquires(&nn->nfs_client_lock)
1139 : : {
1140 : 0 : struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1141 : :
1142 : : /* lock the list against modification */
1143 : 0 : spin_lock(&nn->nfs_client_lock);
1144 : 0 : return seq_list_start_head(&nn->nfs_client_list, *_pos);
1145 : : }
1146 : :
1147 : : /*
1148 : : * move to next server
1149 : : */
1150 : 0 : static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
1151 : : {
1152 : 0 : struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1153 : :
1154 : 0 : return seq_list_next(v, &nn->nfs_client_list, pos);
1155 : : }
1156 : :
1157 : : /*
1158 : : * clean up after reading from the transports list
1159 : : */
1160 : 0 : static void nfs_server_list_stop(struct seq_file *p, void *v)
1161 : : __releases(&nn->nfs_client_lock)
1162 : : {
1163 : 0 : struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1164 : :
1165 : 0 : spin_unlock(&nn->nfs_client_lock);
1166 : 0 : }
1167 : :
1168 : : /*
1169 : : * display a header line followed by a load of call lines
1170 : : */
1171 : 0 : static int nfs_server_list_show(struct seq_file *m, void *v)
1172 : : {
1173 : 0 : struct nfs_client *clp;
1174 : 0 : struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1175 : :
1176 : : /* display header on line 1 */
1177 [ # # ]: 0 : if (v == &nn->nfs_client_list) {
1178 : 0 : seq_puts(m, "NV SERVER PORT USE HOSTNAME\n");
1179 : 0 : return 0;
1180 : : }
1181 : :
1182 : : /* display one transport per line on subsequent lines */
1183 : 0 : clp = list_entry(v, struct nfs_client, cl_share_link);
1184 : :
1185 : : /* Check if the client is initialized */
1186 [ # # ]: 0 : if (clp->cl_cons_state != NFS_CS_READY)
1187 : : return 0;
1188 : :
1189 : 0 : rcu_read_lock();
1190 : 0 : seq_printf(m, "v%u %s %s %3d %s\n",
1191 : 0 : clp->rpc_ops->version,
1192 : : rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1193 : : rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1194 : : refcount_read(&clp->cl_count),
1195 : : clp->cl_hostname);
1196 : 0 : rcu_read_unlock();
1197 : :
1198 : 0 : return 0;
1199 : : }
1200 : :
1201 : : /*
1202 : : * set up the iterator to start reading from the volume list and return the first item
1203 : : */
1204 : 0 : static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
1205 : : __acquires(&nn->nfs_client_lock)
1206 : : {
1207 : 0 : struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1208 : :
1209 : : /* lock the list against modification */
1210 : 0 : spin_lock(&nn->nfs_client_lock);
1211 : 0 : return seq_list_start_head(&nn->nfs_volume_list, *_pos);
1212 : : }
1213 : :
1214 : : /*
1215 : : * move to next volume
1216 : : */
1217 : 0 : static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
1218 : : {
1219 : 0 : struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1220 : :
1221 : 0 : return seq_list_next(v, &nn->nfs_volume_list, pos);
1222 : : }
1223 : :
1224 : : /*
1225 : : * clean up after reading from the transports list
1226 : : */
1227 : 0 : static void nfs_volume_list_stop(struct seq_file *p, void *v)
1228 : : __releases(&nn->nfs_client_lock)
1229 : : {
1230 : 0 : struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1231 : :
1232 : 0 : spin_unlock(&nn->nfs_client_lock);
1233 : 0 : }
1234 : :
1235 : : /*
1236 : : * display a header line followed by a load of call lines
1237 : : */
1238 : 0 : static int nfs_volume_list_show(struct seq_file *m, void *v)
1239 : : {
1240 : 0 : struct nfs_server *server;
1241 : 0 : struct nfs_client *clp;
1242 : 0 : char dev[13]; // 8 for 2^24, 1 for ':', 3 for 2^8, 1 for '\0'
1243 : 0 : char fsid[34]; // 2 * 16 for %llx, 1 for ':', 1 for '\0'
1244 : 0 : struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1245 : :
1246 : : /* display header on line 1 */
1247 [ # # ]: 0 : if (v == &nn->nfs_volume_list) {
1248 : 0 : seq_puts(m, "NV SERVER PORT DEV FSID"
1249 : : " FSC\n");
1250 : 0 : return 0;
1251 : : }
1252 : : /* display one transport per line on subsequent lines */
1253 : 0 : server = list_entry(v, struct nfs_server, master_link);
1254 : 0 : clp = server->nfs_client;
1255 : :
1256 : 0 : snprintf(dev, sizeof(dev), "%u:%u",
1257 : 0 : MAJOR(server->s_dev), MINOR(server->s_dev));
1258 : :
1259 : 0 : snprintf(fsid, sizeof(fsid), "%llx:%llx",
1260 : 0 : (unsigned long long) server->fsid.major,
1261 : 0 : (unsigned long long) server->fsid.minor);
1262 : :
1263 : 0 : rcu_read_lock();
1264 : 0 : seq_printf(m, "v%u %s %s %-12s %-33s %s\n",
1265 : 0 : clp->rpc_ops->version,
1266 : : rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1267 : : rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1268 : : dev,
1269 : : fsid,
1270 : : nfs_server_fscache_state(server));
1271 : 0 : rcu_read_unlock();
1272 : :
1273 : 0 : return 0;
1274 : : }
1275 : :
1276 : 11 : int nfs_fs_proc_net_init(struct net *net)
1277 : : {
1278 : 11 : struct nfs_net *nn = net_generic(net, nfs_net_id);
1279 : 11 : struct proc_dir_entry *p;
1280 : :
1281 : 11 : nn->proc_nfsfs = proc_net_mkdir(net, "nfsfs", net->proc_net);
1282 [ - + ]: 11 : if (!nn->proc_nfsfs)
1283 : 0 : goto error_0;
1284 : :
1285 : : /* a file of servers with which we're dealing */
1286 : 11 : p = proc_create_net("servers", S_IFREG|S_IRUGO, nn->proc_nfsfs,
1287 : : &nfs_server_list_ops, sizeof(struct seq_net_private));
1288 [ - + ]: 11 : if (!p)
1289 : 0 : goto error_1;
1290 : :
1291 : : /* a file of volumes that we have mounted */
1292 : 11 : p = proc_create_net("volumes", S_IFREG|S_IRUGO, nn->proc_nfsfs,
1293 : : &nfs_volume_list_ops, sizeof(struct seq_net_private));
1294 [ - + ]: 11 : if (!p)
1295 : 0 : goto error_1;
1296 : : return 0;
1297 : :
1298 : 0 : error_1:
1299 : 0 : remove_proc_subtree("nfsfs", net->proc_net);
1300 : : error_0:
1301 : : return -ENOMEM;
1302 : : }
1303 : :
1304 : 0 : void nfs_fs_proc_net_exit(struct net *net)
1305 : : {
1306 : 0 : remove_proc_subtree("nfsfs", net->proc_net);
1307 : 0 : }
1308 : :
1309 : : /*
1310 : : * initialise the /proc/fs/nfsfs/ directory
1311 : : */
1312 : 11 : int __init nfs_fs_proc_init(void)
1313 : : {
1314 [ - + ]: 11 : if (!proc_mkdir("fs/nfsfs", NULL))
1315 : 0 : goto error_0;
1316 : :
1317 : : /* a file of servers with which we're dealing */
1318 [ - + ]: 11 : if (!proc_symlink("fs/nfsfs/servers", NULL, "../../net/nfsfs/servers"))
1319 : 0 : goto error_1;
1320 : :
1321 : : /* a file of volumes that we have mounted */
1322 [ - + ]: 11 : if (!proc_symlink("fs/nfsfs/volumes", NULL, "../../net/nfsfs/volumes"))
1323 : 0 : goto error_1;
1324 : :
1325 : : return 0;
1326 : 0 : error_1:
1327 : 0 : remove_proc_subtree("fs/nfsfs", NULL);
1328 : : error_0:
1329 : : return -ENOMEM;
1330 : : }
1331 : :
1332 : : /*
1333 : : * clean up the /proc/fs/nfsfs/ directory
1334 : : */
1335 : 0 : void nfs_fs_proc_exit(void)
1336 : : {
1337 : 0 : remove_proc_subtree("fs/nfsfs", NULL);
1338 : 0 : }
1339 : :
1340 : : #endif /* CONFIG_PROC_FS */
|
