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