1 /* client.c: NFS client sharing and management code
3 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/sched.h>
16 #include <linux/time.h>
17 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/stat.h>
21 #include <linux/errno.h>
22 #include <linux/unistd.h>
23 #include <linux/sunrpc/clnt.h>
24 #include <linux/sunrpc/stats.h>
25 #include <linux/sunrpc/metrics.h>
26 #include <linux/sunrpc/xprtsock.h>
27 #include <linux/sunrpc/xprtrdma.h>
28 #include <linux/nfs_fs.h>
29 #include <linux/nfs_mount.h>
30 #include <linux/nfs4_mount.h>
31 #include <linux/lockd/bind.h>
32 #include <linux/seq_file.h>
33 #include <linux/mount.h>
34 #include <linux/nfs_idmap.h>
35 #include <linux/vfs.h>
36 #include <linux/inet.h>
37 #include <linux/in6.h>
38 #include <linux/slab.h>
39 #include <linux/idr.h>
41 #include <linux/nfs_xdr.h>
42 #include <linux/sunrpc/bc_xprt.h>
43 #include <linux/nsproxy.h>
44 #include <linux/pid_namespace.h>
49 #include "delegation.h"
56 #define NFSDBG_FACILITY NFSDBG_CLIENT
58 static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq
);
62 * Get a unique NFSv4.0 callback identifier which will be used
63 * by the V4.0 callback service to lookup the nfs_client struct
65 static int nfs_get_cb_ident_idr(struct nfs_client
*clp
, int minorversion
)
68 struct nfs_net
*nn
= net_generic(clp
->net
, nfs_net_id
);
70 if (clp
->rpc_ops
->version
!= 4 || minorversion
!= 0)
73 if (!idr_pre_get(&nn
->cb_ident_idr
, GFP_KERNEL
))
75 spin_lock(&nn
->nfs_client_lock
);
76 ret
= idr_get_new(&nn
->cb_ident_idr
, clp
, &clp
->cl_cb_ident
);
77 spin_unlock(&nn
->nfs_client_lock
);
82 #endif /* CONFIG_NFS_V4 */
85 * Turn off NFSv4 uid/gid mapping when using AUTH_SYS
87 static bool nfs4_disable_idmapping
= true;
92 static const struct rpc_version
*nfs_version
[5] = {
104 const struct rpc_program nfs_program
= {
106 .number
= NFS_PROGRAM
,
107 .nrvers
= ARRAY_SIZE(nfs_version
),
108 .version
= nfs_version
,
109 .stats
= &nfs_rpcstat
,
110 .pipe_dir_name
= NFS_PIPE_DIRNAME
,
113 struct rpc_stat nfs_rpcstat
= {
114 .program
= &nfs_program
118 #ifdef CONFIG_NFS_V3_ACL
119 static struct rpc_stat nfsacl_rpcstat
= { &nfsacl_program
};
120 static const struct rpc_version
*nfsacl_version
[] = {
121 [3] = &nfsacl_version3
,
124 const struct rpc_program nfsacl_program
= {
126 .number
= NFS_ACL_PROGRAM
,
127 .nrvers
= ARRAY_SIZE(nfsacl_version
),
128 .version
= nfsacl_version
,
129 .stats
= &nfsacl_rpcstat
,
131 #endif /* CONFIG_NFS_V3_ACL */
133 struct nfs_client_initdata
{
134 const char *hostname
;
135 const struct sockaddr
*addr
;
137 const struct nfs_rpc_ops
*rpc_ops
;
144 * Allocate a shared client record
146 * Since these are allocated/deallocated very rarely, we don't
147 * bother putting them in a slab cache...
149 static struct nfs_client
*nfs_alloc_client(const struct nfs_client_initdata
*cl_init
)
151 struct nfs_client
*clp
;
152 struct rpc_cred
*cred
;
155 if ((clp
= kzalloc(sizeof(*clp
), GFP_KERNEL
)) == NULL
)
158 clp
->rpc_ops
= cl_init
->rpc_ops
;
160 atomic_set(&clp
->cl_count
, 1);
161 clp
->cl_cons_state
= NFS_CS_INITING
;
163 memcpy(&clp
->cl_addr
, cl_init
->addr
, cl_init
->addrlen
);
164 clp
->cl_addrlen
= cl_init
->addrlen
;
166 if (cl_init
->hostname
) {
168 clp
->cl_hostname
= kstrdup(cl_init
->hostname
, GFP_KERNEL
);
169 if (!clp
->cl_hostname
)
173 INIT_LIST_HEAD(&clp
->cl_superblocks
);
174 clp
->cl_rpcclient
= ERR_PTR(-EINVAL
);
176 clp
->cl_proto
= cl_init
->proto
;
177 clp
->net
= get_net(cl_init
->net
);
180 err
= nfs_get_cb_ident_idr(clp
, cl_init
->minorversion
);
184 spin_lock_init(&clp
->cl_lock
);
185 INIT_DELAYED_WORK(&clp
->cl_renewd
, nfs4_renew_state
);
186 rpc_init_wait_queue(&clp
->cl_rpcwaitq
, "NFS client");
187 clp
->cl_boot_time
= CURRENT_TIME
;
188 clp
->cl_state
= 1 << NFS4CLNT_LEASE_EXPIRED
;
189 clp
->cl_minorversion
= cl_init
->minorversion
;
190 clp
->cl_mvops
= nfs_v4_minor_ops
[cl_init
->minorversion
];
192 cred
= rpc_lookup_machine_cred("*");
194 clp
->cl_machine_cred
= cred
;
195 nfs_fscache_get_client_cookie(clp
);
206 #ifdef CONFIG_NFS_V4_1
207 static void nfs4_shutdown_session(struct nfs_client
*clp
)
209 if (nfs4_has_session(clp
)) {
210 nfs4_deviceid_purge_client(clp
);
211 nfs4_destroy_session(clp
->cl_session
);
215 #else /* CONFIG_NFS_V4_1 */
216 static void nfs4_shutdown_session(struct nfs_client
*clp
)
219 #endif /* CONFIG_NFS_V4_1 */
222 * Destroy the NFS4 callback service
224 static void nfs4_destroy_callback(struct nfs_client
*clp
)
226 if (__test_and_clear_bit(NFS_CS_CALLBACK
, &clp
->cl_res_state
))
227 nfs_callback_down(clp
->cl_mvops
->minor_version
);
230 static void nfs4_shutdown_client(struct nfs_client
*clp
)
232 if (__test_and_clear_bit(NFS_CS_RENEWD
, &clp
->cl_res_state
))
233 nfs4_kill_renewd(clp
);
234 nfs4_shutdown_session(clp
);
235 nfs4_destroy_callback(clp
);
236 if (__test_and_clear_bit(NFS_CS_IDMAP
, &clp
->cl_res_state
))
237 nfs_idmap_delete(clp
);
239 rpc_destroy_wait_queue(&clp
->cl_rpcwaitq
);
240 kfree(clp
->cl_serverscope
);
241 kfree(clp
->cl_implid
);
244 /* idr_remove_all is not needed as all id's are removed by nfs_put_client */
245 void nfs_cleanup_cb_ident_idr(struct net
*net
)
247 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
249 idr_destroy(&nn
->cb_ident_idr
);
252 /* nfs_client_lock held */
253 static void nfs_cb_idr_remove_locked(struct nfs_client
*clp
)
255 struct nfs_net
*nn
= net_generic(clp
->net
, nfs_net_id
);
257 if (clp
->cl_cb_ident
)
258 idr_remove(&nn
->cb_ident_idr
, clp
->cl_cb_ident
);
261 static void pnfs_init_server(struct nfs_server
*server
)
263 rpc_init_wait_queue(&server
->roc_rpcwaitq
, "pNFS ROC");
266 static void nfs4_destroy_server(struct nfs_server
*server
)
268 nfs4_purge_state_owners(server
);
272 static void nfs4_shutdown_client(struct nfs_client
*clp
)
276 void nfs_cleanup_cb_ident_idr(struct net
*net
)
280 static void nfs_cb_idr_remove_locked(struct nfs_client
*clp
)
284 static void pnfs_init_server(struct nfs_server
*server
)
288 #endif /* CONFIG_NFS_V4 */
291 * Destroy a shared client record
293 static void nfs_free_client(struct nfs_client
*clp
)
295 dprintk("--> nfs_free_client(%u)\n", clp
->rpc_ops
->version
);
297 nfs4_shutdown_client(clp
);
299 nfs_fscache_release_client_cookie(clp
);
301 /* -EIO all pending I/O */
302 if (!IS_ERR(clp
->cl_rpcclient
))
303 rpc_shutdown_client(clp
->cl_rpcclient
);
305 if (clp
->cl_machine_cred
!= NULL
)
306 put_rpccred(clp
->cl_machine_cred
);
309 kfree(clp
->cl_hostname
);
312 dprintk("<-- nfs_free_client()\n");
316 * Release a reference to a shared client record
318 void nfs_put_client(struct nfs_client
*clp
)
325 dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp
->cl_count
));
326 nn
= net_generic(clp
->net
, nfs_net_id
);
328 if (atomic_dec_and_lock(&clp
->cl_count
, &nn
->nfs_client_lock
)) {
329 list_del(&clp
->cl_share_link
);
330 nfs_cb_idr_remove_locked(clp
);
331 spin_unlock(&nn
->nfs_client_lock
);
333 BUG_ON(!list_empty(&clp
->cl_superblocks
));
335 nfs_free_client(clp
);
338 EXPORT_SYMBOL_GPL(nfs_put_client
);
340 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
342 * Test if two ip6 socket addresses refer to the same socket by
343 * comparing relevant fields. The padding bytes specifically, are not
344 * compared. sin6_flowinfo is not compared because it only affects QoS
345 * and sin6_scope_id is only compared if the address is "link local"
346 * because "link local" addresses need only be unique to a specific
347 * link. Conversely, ordinary unicast addresses might have different
350 * The caller should ensure both socket addresses are AF_INET6.
352 static int nfs_sockaddr_match_ipaddr6(const struct sockaddr
*sa1
,
353 const struct sockaddr
*sa2
)
355 const struct sockaddr_in6
*sin1
= (const struct sockaddr_in6
*)sa1
;
356 const struct sockaddr_in6
*sin2
= (const struct sockaddr_in6
*)sa2
;
358 if (!ipv6_addr_equal(&sin1
->sin6_addr
, &sin2
->sin6_addr
))
360 else if (ipv6_addr_type(&sin1
->sin6_addr
) & IPV6_ADDR_LINKLOCAL
)
361 return sin1
->sin6_scope_id
== sin2
->sin6_scope_id
;
365 #else /* !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) */
366 static int nfs_sockaddr_match_ipaddr6(const struct sockaddr
*sa1
,
367 const struct sockaddr
*sa2
)
374 * Test if two ip4 socket addresses refer to the same socket, by
375 * comparing relevant fields. The padding bytes specifically, are
378 * The caller should ensure both socket addresses are AF_INET.
380 static int nfs_sockaddr_match_ipaddr4(const struct sockaddr
*sa1
,
381 const struct sockaddr
*sa2
)
383 const struct sockaddr_in
*sin1
= (const struct sockaddr_in
*)sa1
;
384 const struct sockaddr_in
*sin2
= (const struct sockaddr_in
*)sa2
;
386 return sin1
->sin_addr
.s_addr
== sin2
->sin_addr
.s_addr
;
389 static int nfs_sockaddr_cmp_ip6(const struct sockaddr
*sa1
,
390 const struct sockaddr
*sa2
)
392 const struct sockaddr_in6
*sin1
= (const struct sockaddr_in6
*)sa1
;
393 const struct sockaddr_in6
*sin2
= (const struct sockaddr_in6
*)sa2
;
395 return nfs_sockaddr_match_ipaddr6(sa1
, sa2
) &&
396 (sin1
->sin6_port
== sin2
->sin6_port
);
399 static int nfs_sockaddr_cmp_ip4(const struct sockaddr
*sa1
,
400 const struct sockaddr
*sa2
)
402 const struct sockaddr_in
*sin1
= (const struct sockaddr_in
*)sa1
;
403 const struct sockaddr_in
*sin2
= (const struct sockaddr_in
*)sa2
;
405 return nfs_sockaddr_match_ipaddr4(sa1
, sa2
) &&
406 (sin1
->sin_port
== sin2
->sin_port
);
409 #if defined(CONFIG_NFS_V4_1)
411 * Test if two socket addresses represent the same actual socket,
412 * by comparing (only) relevant fields, excluding the port number.
414 static int nfs_sockaddr_match_ipaddr(const struct sockaddr
*sa1
,
415 const struct sockaddr
*sa2
)
417 if (sa1
->sa_family
!= sa2
->sa_family
)
420 switch (sa1
->sa_family
) {
422 return nfs_sockaddr_match_ipaddr4(sa1
, sa2
);
424 return nfs_sockaddr_match_ipaddr6(sa1
, sa2
);
428 #endif /* CONFIG_NFS_V4_1 */
431 * Test if two socket addresses represent the same actual socket,
432 * by comparing (only) relevant fields, including the port number.
434 static int nfs_sockaddr_cmp(const struct sockaddr
*sa1
,
435 const struct sockaddr
*sa2
)
437 if (sa1
->sa_family
!= sa2
->sa_family
)
440 switch (sa1
->sa_family
) {
442 return nfs_sockaddr_cmp_ip4(sa1
, sa2
);
444 return nfs_sockaddr_cmp_ip6(sa1
, sa2
);
449 #if defined(CONFIG_NFS_V4_1)
450 /* Common match routine for v4.0 and v4.1 callback services */
451 static bool nfs4_cb_match_client(const struct sockaddr
*addr
,
452 struct nfs_client
*clp
, u32 minorversion
)
454 struct sockaddr
*clap
= (struct sockaddr
*)&clp
->cl_addr
;
456 /* Don't match clients that failed to initialise */
457 if (!(clp
->cl_cons_state
== NFS_CS_READY
||
458 clp
->cl_cons_state
== NFS_CS_SESSION_INITING
))
461 /* Match the version and minorversion */
462 if (clp
->rpc_ops
->version
!= 4 ||
463 clp
->cl_minorversion
!= minorversion
)
466 /* Match only the IP address, not the port number */
467 if (!nfs_sockaddr_match_ipaddr(addr
, clap
))
472 #endif /* CONFIG_NFS_V4_1 */
475 * Find an nfs_client on the list that matches the initialisation data
478 static struct nfs_client
*nfs_match_client(const struct nfs_client_initdata
*data
)
480 struct nfs_client
*clp
;
481 const struct sockaddr
*sap
= data
->addr
;
482 struct nfs_net
*nn
= net_generic(data
->net
, nfs_net_id
);
484 list_for_each_entry(clp
, &nn
->nfs_client_list
, cl_share_link
) {
485 const struct sockaddr
*clap
= (struct sockaddr
*)&clp
->cl_addr
;
486 /* Don't match clients that failed to initialise properly */
487 if (clp
->cl_cons_state
< 0)
490 /* Different NFS versions cannot share the same nfs_client */
491 if (clp
->rpc_ops
!= data
->rpc_ops
)
494 if (clp
->cl_proto
!= data
->proto
)
496 /* Match nfsv4 minorversion */
497 if (clp
->cl_minorversion
!= data
->minorversion
)
499 /* Match the full socket address */
500 if (!nfs_sockaddr_cmp(sap
, clap
))
503 atomic_inc(&clp
->cl_count
);
510 * Look up a client by IP address and protocol version
511 * - creates a new record if one doesn't yet exist
513 static struct nfs_client
*
514 nfs_get_client(const struct nfs_client_initdata
*cl_init
,
515 const struct rpc_timeout
*timeparms
,
517 rpc_authflavor_t authflavour
,
520 struct nfs_client
*clp
, *new = NULL
;
522 struct nfs_net
*nn
= net_generic(cl_init
->net
, nfs_net_id
);
524 dprintk("--> nfs_get_client(%s,v%u)\n",
525 cl_init
->hostname
?: "", cl_init
->rpc_ops
->version
);
527 /* see if the client already exists */
529 spin_lock(&nn
->nfs_client_lock
);
531 clp
= nfs_match_client(cl_init
);
537 spin_unlock(&nn
->nfs_client_lock
);
539 new = nfs_alloc_client(cl_init
);
540 } while (!IS_ERR(new));
542 dprintk("--> nfs_get_client() = %ld [failed]\n", PTR_ERR(new));
545 /* install a new client and return with it unready */
548 list_add(&clp
->cl_share_link
, &nn
->nfs_client_list
);
549 spin_unlock(&nn
->nfs_client_lock
);
551 error
= cl_init
->rpc_ops
->init_client(clp
, timeparms
, ip_addr
,
552 authflavour
, noresvport
);
555 return ERR_PTR(error
);
557 dprintk("--> nfs_get_client() = %p [new]\n", clp
);
560 /* found an existing client
561 * - make sure it's ready before returning
564 spin_unlock(&nn
->nfs_client_lock
);
567 nfs_free_client(new);
569 error
= wait_event_killable(nfs_client_active_wq
,
570 clp
->cl_cons_state
< NFS_CS_INITING
);
573 return ERR_PTR(-ERESTARTSYS
);
576 if (clp
->cl_cons_state
< NFS_CS_READY
) {
577 error
= clp
->cl_cons_state
;
579 return ERR_PTR(error
);
582 BUG_ON(clp
->cl_cons_state
!= NFS_CS_READY
);
584 dprintk("--> nfs_get_client() = %p [share]\n", clp
);
589 * Mark a server as ready or failed
591 void nfs_mark_client_ready(struct nfs_client
*clp
, int state
)
593 clp
->cl_cons_state
= state
;
594 wake_up_all(&nfs_client_active_wq
);
598 * With sessions, the client is not marked ready until after a
599 * successful EXCHANGE_ID and CREATE_SESSION.
601 * Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate
602 * other versions of NFS can be tried.
604 int nfs4_check_client_ready(struct nfs_client
*clp
)
606 if (!nfs4_has_session(clp
))
608 if (clp
->cl_cons_state
< NFS_CS_READY
)
609 return -EPROTONOSUPPORT
;
614 * Initialise the timeout values for a connection
616 static void nfs_init_timeout_values(struct rpc_timeout
*to
, int proto
,
617 unsigned int timeo
, unsigned int retrans
)
619 to
->to_initval
= timeo
* HZ
/ 10;
620 to
->to_retries
= retrans
;
623 case XPRT_TRANSPORT_TCP
:
624 case XPRT_TRANSPORT_RDMA
:
625 if (to
->to_retries
== 0)
626 to
->to_retries
= NFS_DEF_TCP_RETRANS
;
627 if (to
->to_initval
== 0)
628 to
->to_initval
= NFS_DEF_TCP_TIMEO
* HZ
/ 10;
629 if (to
->to_initval
> NFS_MAX_TCP_TIMEOUT
)
630 to
->to_initval
= NFS_MAX_TCP_TIMEOUT
;
631 to
->to_increment
= to
->to_initval
;
632 to
->to_maxval
= to
->to_initval
+ (to
->to_increment
* to
->to_retries
);
633 if (to
->to_maxval
> NFS_MAX_TCP_TIMEOUT
)
634 to
->to_maxval
= NFS_MAX_TCP_TIMEOUT
;
635 if (to
->to_maxval
< to
->to_initval
)
636 to
->to_maxval
= to
->to_initval
;
637 to
->to_exponential
= 0;
639 case XPRT_TRANSPORT_UDP
:
640 if (to
->to_retries
== 0)
641 to
->to_retries
= NFS_DEF_UDP_RETRANS
;
643 to
->to_initval
= NFS_DEF_UDP_TIMEO
* HZ
/ 10;
644 if (to
->to_initval
> NFS_MAX_UDP_TIMEOUT
)
645 to
->to_initval
= NFS_MAX_UDP_TIMEOUT
;
646 to
->to_maxval
= NFS_MAX_UDP_TIMEOUT
;
647 to
->to_exponential
= 1;
655 * Create an RPC client handle
657 static int nfs_create_rpc_client(struct nfs_client
*clp
,
658 const struct rpc_timeout
*timeparms
,
659 rpc_authflavor_t flavor
,
660 int discrtry
, int noresvport
)
662 struct rpc_clnt
*clnt
= NULL
;
663 struct rpc_create_args args
= {
665 .protocol
= clp
->cl_proto
,
666 .address
= (struct sockaddr
*)&clp
->cl_addr
,
667 .addrsize
= clp
->cl_addrlen
,
668 .timeout
= timeparms
,
669 .servername
= clp
->cl_hostname
,
670 .program
= &nfs_program
,
671 .version
= clp
->rpc_ops
->version
,
672 .authflavor
= flavor
,
676 args
.flags
|= RPC_CLNT_CREATE_DISCRTRY
;
678 args
.flags
|= RPC_CLNT_CREATE_NONPRIVPORT
;
680 if (!IS_ERR(clp
->cl_rpcclient
))
683 clnt
= rpc_create(&args
);
685 dprintk("%s: cannot create RPC client. Error = %ld\n",
686 __func__
, PTR_ERR(clnt
));
687 return PTR_ERR(clnt
);
690 clp
->cl_rpcclient
= clnt
;
695 * Version 2 or 3 client destruction
697 static void nfs_destroy_server(struct nfs_server
*server
)
699 if (!(server
->flags
& NFS_MOUNT_LOCAL_FLOCK
) ||
700 !(server
->flags
& NFS_MOUNT_LOCAL_FCNTL
))
701 nlmclnt_done(server
->nlm_host
);
705 * Version 2 or 3 lockd setup
707 static int nfs_start_lockd(struct nfs_server
*server
)
709 struct nlm_host
*host
;
710 struct nfs_client
*clp
= server
->nfs_client
;
711 struct nlmclnt_initdata nlm_init
= {
712 .hostname
= clp
->cl_hostname
,
713 .address
= (struct sockaddr
*)&clp
->cl_addr
,
714 .addrlen
= clp
->cl_addrlen
,
715 .nfs_version
= clp
->rpc_ops
->version
,
716 .noresvport
= server
->flags
& NFS_MOUNT_NORESVPORT
?
721 if (nlm_init
.nfs_version
> 3)
723 if ((server
->flags
& NFS_MOUNT_LOCAL_FLOCK
) &&
724 (server
->flags
& NFS_MOUNT_LOCAL_FCNTL
))
727 switch (clp
->cl_proto
) {
729 nlm_init
.protocol
= IPPROTO_TCP
;
731 case XPRT_TRANSPORT_UDP
:
732 nlm_init
.protocol
= IPPROTO_UDP
;
735 host
= nlmclnt_init(&nlm_init
);
737 return PTR_ERR(host
);
739 server
->nlm_host
= host
;
740 server
->destroy
= nfs_destroy_server
;
745 * Initialise an NFSv3 ACL client connection
747 #ifdef CONFIG_NFS_V3_ACL
748 static void nfs_init_server_aclclient(struct nfs_server
*server
)
750 if (server
->nfs_client
->rpc_ops
->version
!= 3)
752 if (server
->flags
& NFS_MOUNT_NOACL
)
755 server
->client_acl
= rpc_bind_new_program(server
->client
, &nfsacl_program
, 3);
756 if (IS_ERR(server
->client_acl
))
759 /* No errors! Assume that Sun nfsacls are supported */
760 server
->caps
|= NFS_CAP_ACLS
;
764 server
->caps
&= ~NFS_CAP_ACLS
;
767 static inline void nfs_init_server_aclclient(struct nfs_server
*server
)
769 server
->flags
&= ~NFS_MOUNT_NOACL
;
770 server
->caps
&= ~NFS_CAP_ACLS
;
775 * Create a general RPC client
777 static int nfs_init_server_rpcclient(struct nfs_server
*server
,
778 const struct rpc_timeout
*timeo
,
779 rpc_authflavor_t pseudoflavour
)
781 struct nfs_client
*clp
= server
->nfs_client
;
783 server
->client
= rpc_clone_client(clp
->cl_rpcclient
);
784 if (IS_ERR(server
->client
)) {
785 dprintk("%s: couldn't create rpc_client!\n", __func__
);
786 return PTR_ERR(server
->client
);
789 memcpy(&server
->client
->cl_timeout_default
,
791 sizeof(server
->client
->cl_timeout_default
));
792 server
->client
->cl_timeout
= &server
->client
->cl_timeout_default
;
794 if (pseudoflavour
!= clp
->cl_rpcclient
->cl_auth
->au_flavor
) {
795 struct rpc_auth
*auth
;
797 auth
= rpcauth_create(pseudoflavour
, server
->client
);
799 dprintk("%s: couldn't create credcache!\n", __func__
);
800 return PTR_ERR(auth
);
803 server
->client
->cl_softrtry
= 0;
804 if (server
->flags
& NFS_MOUNT_SOFT
)
805 server
->client
->cl_softrtry
= 1;
811 * Initialise an NFS2 or NFS3 client
813 int nfs_init_client(struct nfs_client
*clp
, const struct rpc_timeout
*timeparms
,
814 const char *ip_addr
, rpc_authflavor_t authflavour
,
819 if (clp
->cl_cons_state
== NFS_CS_READY
) {
820 /* the client is already initialised */
821 dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp
);
826 * Create a client RPC handle for doing FSSTAT with UNIX auth only
827 * - RFC 2623, sec 2.3.2
829 error
= nfs_create_rpc_client(clp
, timeparms
, RPC_AUTH_UNIX
,
833 nfs_mark_client_ready(clp
, NFS_CS_READY
);
837 nfs_mark_client_ready(clp
, error
);
838 dprintk("<-- nfs_init_client() = xerror %d\n", error
);
843 * Create a version 2 or 3 client
845 static int nfs_init_server(struct nfs_server
*server
,
846 const struct nfs_parsed_mount_data
*data
)
848 struct nfs_client_initdata cl_init
= {
849 .hostname
= data
->nfs_server
.hostname
,
850 .addr
= (const struct sockaddr
*)&data
->nfs_server
.address
,
851 .addrlen
= data
->nfs_server
.addrlen
,
853 .proto
= data
->nfs_server
.protocol
,
856 struct rpc_timeout timeparms
;
857 struct nfs_client
*clp
;
860 dprintk("--> nfs_init_server()\n");
862 switch (data
->version
) {
865 cl_init
.rpc_ops
= &nfs_v2_clientops
;
870 cl_init
.rpc_ops
= &nfs_v3_clientops
;
874 return -EPROTONOSUPPORT
;
877 nfs_init_timeout_values(&timeparms
, data
->nfs_server
.protocol
,
878 data
->timeo
, data
->retrans
);
880 /* Allocate or find a client reference we can use */
881 clp
= nfs_get_client(&cl_init
, &timeparms
, NULL
, RPC_AUTH_UNIX
,
882 data
->flags
& NFS_MOUNT_NORESVPORT
);
884 dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp
));
888 server
->nfs_client
= clp
;
890 /* Initialise the client representation from the mount data */
891 server
->flags
= data
->flags
;
892 server
->options
= data
->options
;
893 server
->caps
|= NFS_CAP_HARDLINKS
|NFS_CAP_SYMLINKS
|NFS_CAP_FILEID
|
894 NFS_CAP_MODE
|NFS_CAP_NLINK
|NFS_CAP_OWNER
|NFS_CAP_OWNER_GROUP
|
895 NFS_CAP_ATIME
|NFS_CAP_CTIME
|NFS_CAP_MTIME
|NFS_CAP_CHANGE_ATTR
;
898 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
900 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
902 server
->acregmin
= data
->acregmin
* HZ
;
903 server
->acregmax
= data
->acregmax
* HZ
;
904 server
->acdirmin
= data
->acdirmin
* HZ
;
905 server
->acdirmax
= data
->acdirmax
* HZ
;
907 /* Start lockd here, before we might error out */
908 error
= nfs_start_lockd(server
);
912 server
->port
= data
->nfs_server
.port
;
914 error
= nfs_init_server_rpcclient(server
, &timeparms
, data
->auth_flavors
[0]);
918 /* Preserve the values of mount_server-related mount options */
919 if (data
->mount_server
.addrlen
) {
920 memcpy(&server
->mountd_address
, &data
->mount_server
.address
,
921 data
->mount_server
.addrlen
);
922 server
->mountd_addrlen
= data
->mount_server
.addrlen
;
924 server
->mountd_version
= data
->mount_server
.version
;
925 server
->mountd_port
= data
->mount_server
.port
;
926 server
->mountd_protocol
= data
->mount_server
.protocol
;
928 server
->namelen
= data
->namlen
;
929 /* Create a client RPC handle for the NFSv3 ACL management interface */
930 nfs_init_server_aclclient(server
);
931 dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp
);
935 server
->nfs_client
= NULL
;
937 dprintk("<-- nfs_init_server() = xerror %d\n", error
);
942 * Load up the server record from information gained in an fsinfo record
944 static void nfs_server_set_fsinfo(struct nfs_server
*server
,
945 struct nfs_fh
*mntfh
,
946 struct nfs_fsinfo
*fsinfo
)
948 unsigned long max_rpc_payload
;
950 /* Work out a lot of parameters */
951 if (server
->rsize
== 0)
952 server
->rsize
= nfs_block_size(fsinfo
->rtpref
, NULL
);
953 if (server
->wsize
== 0)
954 server
->wsize
= nfs_block_size(fsinfo
->wtpref
, NULL
);
956 if (fsinfo
->rtmax
>= 512 && server
->rsize
> fsinfo
->rtmax
)
957 server
->rsize
= nfs_block_size(fsinfo
->rtmax
, NULL
);
958 if (fsinfo
->wtmax
>= 512 && server
->wsize
> fsinfo
->wtmax
)
959 server
->wsize
= nfs_block_size(fsinfo
->wtmax
, NULL
);
961 max_rpc_payload
= nfs_block_size(rpc_max_payload(server
->client
), NULL
);
962 if (server
->rsize
> max_rpc_payload
)
963 server
->rsize
= max_rpc_payload
;
964 if (server
->rsize
> NFS_MAX_FILE_IO_SIZE
)
965 server
->rsize
= NFS_MAX_FILE_IO_SIZE
;
966 server
->rpages
= (server
->rsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
968 server
->backing_dev_info
.name
= "nfs";
969 server
->backing_dev_info
.ra_pages
= server
->rpages
* NFS_MAX_READAHEAD
;
971 if (server
->wsize
> max_rpc_payload
)
972 server
->wsize
= max_rpc_payload
;
973 if (server
->wsize
> NFS_MAX_FILE_IO_SIZE
)
974 server
->wsize
= NFS_MAX_FILE_IO_SIZE
;
975 server
->wpages
= (server
->wsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
976 server
->pnfs_blksize
= fsinfo
->blksize
;
977 set_pnfs_layoutdriver(server
, mntfh
, fsinfo
->layouttype
);
979 server
->wtmult
= nfs_block_bits(fsinfo
->wtmult
, NULL
);
981 server
->dtsize
= nfs_block_size(fsinfo
->dtpref
, NULL
);
982 if (server
->dtsize
> PAGE_CACHE_SIZE
* NFS_MAX_READDIR_PAGES
)
983 server
->dtsize
= PAGE_CACHE_SIZE
* NFS_MAX_READDIR_PAGES
;
984 if (server
->dtsize
> server
->rsize
)
985 server
->dtsize
= server
->rsize
;
987 if (server
->flags
& NFS_MOUNT_NOAC
) {
988 server
->acregmin
= server
->acregmax
= 0;
989 server
->acdirmin
= server
->acdirmax
= 0;
992 server
->maxfilesize
= fsinfo
->maxfilesize
;
994 server
->time_delta
= fsinfo
->time_delta
;
996 /* We're airborne Set socket buffersize */
997 rpc_setbufsize(server
->client
, server
->wsize
+ 100, server
->rsize
+ 100);
1001 * Probe filesystem information, including the FSID on v2/v3
1003 static int nfs_probe_fsinfo(struct nfs_server
*server
, struct nfs_fh
*mntfh
, struct nfs_fattr
*fattr
)
1005 struct nfs_fsinfo fsinfo
;
1006 struct nfs_client
*clp
= server
->nfs_client
;
1009 dprintk("--> nfs_probe_fsinfo()\n");
1011 if (clp
->rpc_ops
->set_capabilities
!= NULL
) {
1012 error
= clp
->rpc_ops
->set_capabilities(server
, mntfh
);
1017 fsinfo
.fattr
= fattr
;
1018 fsinfo
.layouttype
= 0;
1019 error
= clp
->rpc_ops
->fsinfo(server
, mntfh
, &fsinfo
);
1023 nfs_server_set_fsinfo(server
, mntfh
, &fsinfo
);
1025 /* Get some general file system info */
1026 if (server
->namelen
== 0) {
1027 struct nfs_pathconf pathinfo
;
1029 pathinfo
.fattr
= fattr
;
1030 nfs_fattr_init(fattr
);
1032 if (clp
->rpc_ops
->pathconf(server
, mntfh
, &pathinfo
) >= 0)
1033 server
->namelen
= pathinfo
.max_namelen
;
1036 dprintk("<-- nfs_probe_fsinfo() = 0\n");
1040 dprintk("nfs_probe_fsinfo: error = %d\n", -error
);
1045 * Copy useful information when duplicating a server record
1047 static void nfs_server_copy_userdata(struct nfs_server
*target
, struct nfs_server
*source
)
1049 target
->flags
= source
->flags
;
1050 target
->rsize
= source
->rsize
;
1051 target
->wsize
= source
->wsize
;
1052 target
->acregmin
= source
->acregmin
;
1053 target
->acregmax
= source
->acregmax
;
1054 target
->acdirmin
= source
->acdirmin
;
1055 target
->acdirmax
= source
->acdirmax
;
1056 target
->caps
= source
->caps
;
1057 target
->options
= source
->options
;
1060 static void nfs_server_insert_lists(struct nfs_server
*server
)
1062 struct nfs_client
*clp
= server
->nfs_client
;
1063 struct nfs_net
*nn
= net_generic(clp
->net
, nfs_net_id
);
1065 spin_lock(&nn
->nfs_client_lock
);
1066 list_add_tail_rcu(&server
->client_link
, &clp
->cl_superblocks
);
1067 list_add_tail(&server
->master_link
, &nn
->nfs_volume_list
);
1068 clear_bit(NFS_CS_STOP_RENEW
, &clp
->cl_res_state
);
1069 spin_unlock(&nn
->nfs_client_lock
);
1073 static void nfs_server_remove_lists(struct nfs_server
*server
)
1075 struct nfs_client
*clp
= server
->nfs_client
;
1080 nn
= net_generic(clp
->net
, nfs_net_id
);
1081 spin_lock(&nn
->nfs_client_lock
);
1082 list_del_rcu(&server
->client_link
);
1083 if (list_empty(&clp
->cl_superblocks
))
1084 set_bit(NFS_CS_STOP_RENEW
, &clp
->cl_res_state
);
1085 list_del(&server
->master_link
);
1086 spin_unlock(&nn
->nfs_client_lock
);
1092 * Allocate and initialise a server record
1094 static struct nfs_server
*nfs_alloc_server(void)
1096 struct nfs_server
*server
;
1098 server
= kzalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1102 server
->client
= server
->client_acl
= ERR_PTR(-EINVAL
);
1104 /* Zero out the NFS state stuff */
1105 INIT_LIST_HEAD(&server
->client_link
);
1106 INIT_LIST_HEAD(&server
->master_link
);
1107 INIT_LIST_HEAD(&server
->delegations
);
1108 INIT_LIST_HEAD(&server
->layouts
);
1109 INIT_LIST_HEAD(&server
->state_owners_lru
);
1111 atomic_set(&server
->active
, 0);
1113 server
->io_stats
= nfs_alloc_iostats();
1114 if (!server
->io_stats
) {
1119 if (bdi_init(&server
->backing_dev_info
)) {
1120 nfs_free_iostats(server
->io_stats
);
1125 ida_init(&server
->openowner_id
);
1126 ida_init(&server
->lockowner_id
);
1127 pnfs_init_server(server
);
1133 * Free up a server record
1135 void nfs_free_server(struct nfs_server
*server
)
1137 dprintk("--> nfs_free_server()\n");
1139 nfs_server_remove_lists(server
);
1140 unset_pnfs_layoutdriver(server
);
1142 if (server
->destroy
!= NULL
)
1143 server
->destroy(server
);
1145 if (!IS_ERR(server
->client_acl
))
1146 rpc_shutdown_client(server
->client_acl
);
1147 if (!IS_ERR(server
->client
))
1148 rpc_shutdown_client(server
->client
);
1150 nfs_put_client(server
->nfs_client
);
1152 ida_destroy(&server
->lockowner_id
);
1153 ida_destroy(&server
->openowner_id
);
1154 nfs_free_iostats(server
->io_stats
);
1155 bdi_destroy(&server
->backing_dev_info
);
1157 nfs_release_automount_timer();
1158 dprintk("<-- nfs_free_server()\n");
1162 * Create a version 2 or 3 volume record
1163 * - keyed on server and FSID
1165 struct nfs_server
*nfs_create_server(const struct nfs_parsed_mount_data
*data
,
1166 struct nfs_fh
*mntfh
)
1168 struct nfs_server
*server
;
1169 struct nfs_fattr
*fattr
;
1172 server
= nfs_alloc_server();
1174 return ERR_PTR(-ENOMEM
);
1177 fattr
= nfs_alloc_fattr();
1181 /* Get a client representation */
1182 error
= nfs_init_server(server
, data
);
1186 BUG_ON(!server
->nfs_client
);
1187 BUG_ON(!server
->nfs_client
->rpc_ops
);
1188 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
1190 /* Probe the root fh to retrieve its FSID */
1191 error
= nfs_probe_fsinfo(server
, mntfh
, fattr
);
1194 if (server
->nfs_client
->rpc_ops
->version
== 3) {
1195 if (server
->namelen
== 0 || server
->namelen
> NFS3_MAXNAMLEN
)
1196 server
->namelen
= NFS3_MAXNAMLEN
;
1197 if (!(data
->flags
& NFS_MOUNT_NORDIRPLUS
))
1198 server
->caps
|= NFS_CAP_READDIRPLUS
;
1200 if (server
->namelen
== 0 || server
->namelen
> NFS2_MAXNAMLEN
)
1201 server
->namelen
= NFS2_MAXNAMLEN
;
1204 if (!(fattr
->valid
& NFS_ATTR_FATTR
)) {
1205 error
= server
->nfs_client
->rpc_ops
->getattr(server
, mntfh
, fattr
);
1207 dprintk("nfs_create_server: getattr error = %d\n", -error
);
1211 memcpy(&server
->fsid
, &fattr
->fsid
, sizeof(server
->fsid
));
1213 dprintk("Server FSID: %llx:%llx\n",
1214 (unsigned long long) server
->fsid
.major
,
1215 (unsigned long long) server
->fsid
.minor
);
1217 nfs_server_insert_lists(server
);
1218 server
->mount_time
= jiffies
;
1219 nfs_free_fattr(fattr
);
1223 nfs_free_fattr(fattr
);
1224 nfs_free_server(server
);
1225 return ERR_PTR(error
);
1228 #ifdef CONFIG_NFS_V4
1230 * NFSv4.0 callback thread helper
1232 * Find a client by callback identifier
1235 nfs4_find_client_ident(struct net
*net
, int cb_ident
)
1237 struct nfs_client
*clp
;
1238 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
1240 spin_lock(&nn
->nfs_client_lock
);
1241 clp
= idr_find(&nn
->cb_ident_idr
, cb_ident
);
1243 atomic_inc(&clp
->cl_count
);
1244 spin_unlock(&nn
->nfs_client_lock
);
1248 #if defined(CONFIG_NFS_V4_1)
1250 * NFSv4.1 callback thread helper
1251 * For CB_COMPOUND calls, find a client by IP address, protocol version,
1252 * minorversion, and sessionID
1254 * Returns NULL if no such client
1257 nfs4_find_client_sessionid(struct net
*net
, const struct sockaddr
*addr
,
1258 struct nfs4_sessionid
*sid
)
1260 struct nfs_client
*clp
;
1261 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
1263 spin_lock(&nn
->nfs_client_lock
);
1264 list_for_each_entry(clp
, &nn
->nfs_client_list
, cl_share_link
) {
1265 if (nfs4_cb_match_client(addr
, clp
, 1) == false)
1268 if (!nfs4_has_session(clp
))
1271 /* Match sessionid*/
1272 if (memcmp(clp
->cl_session
->sess_id
.data
,
1273 sid
->data
, NFS4_MAX_SESSIONID_LEN
) != 0)
1276 atomic_inc(&clp
->cl_count
);
1277 spin_unlock(&nn
->nfs_client_lock
);
1280 spin_unlock(&nn
->nfs_client_lock
);
1284 #else /* CONFIG_NFS_V4_1 */
1287 nfs4_find_client_sessionid(struct net
*net
, const struct sockaddr
*addr
,
1288 struct nfs4_sessionid
*sid
)
1292 #endif /* CONFIG_NFS_V4_1 */
1295 * Initialize the NFS4 callback service
1297 static int nfs4_init_callback(struct nfs_client
*clp
)
1301 if (clp
->rpc_ops
->version
== 4) {
1302 struct rpc_xprt
*xprt
;
1304 xprt
= rcu_dereference_raw(clp
->cl_rpcclient
->cl_xprt
);
1306 if (nfs4_has_session(clp
)) {
1307 error
= xprt_setup_backchannel(xprt
,
1308 NFS41_BC_MIN_CALLBACKS
);
1313 error
= nfs_callback_up(clp
->cl_mvops
->minor_version
, xprt
);
1315 dprintk("%s: failed to start callback. Error = %d\n",
1319 __set_bit(NFS_CS_CALLBACK
, &clp
->cl_res_state
);
1325 * Initialize the minor version specific parts of an NFS4 client record
1327 static int nfs4_init_client_minor_version(struct nfs_client
*clp
)
1329 #if defined(CONFIG_NFS_V4_1)
1330 if (clp
->cl_mvops
->minor_version
) {
1331 struct nfs4_session
*session
= NULL
;
1333 * Create the session and mark it expired.
1334 * When a SEQUENCE operation encounters the expired session
1335 * it will do session recovery to initialize it.
1337 session
= nfs4_alloc_session(clp
);
1341 clp
->cl_session
= session
;
1343 * The create session reply races with the server back
1344 * channel probe. Mark the client NFS_CS_SESSION_INITING
1345 * so that the client back channel can find the
1348 clp
->cl_cons_state
= NFS_CS_SESSION_INITING
;
1350 #endif /* CONFIG_NFS_V4_1 */
1352 return nfs4_init_callback(clp
);
1356 * Initialise an NFS4 client record
1358 int nfs4_init_client(struct nfs_client
*clp
,
1359 const struct rpc_timeout
*timeparms
,
1360 const char *ip_addr
,
1361 rpc_authflavor_t authflavour
,
1364 char buf
[INET6_ADDRSTRLEN
+ 1];
1367 if (clp
->cl_cons_state
== NFS_CS_READY
) {
1368 /* the client is initialised already */
1369 dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp
);
1373 /* Check NFS protocol revision and initialize RPC op vector */
1374 clp
->rpc_ops
= &nfs_v4_clientops
;
1376 error
= nfs_create_rpc_client(clp
, timeparms
, authflavour
,
1381 /* If no clientaddr= option was specified, find a usable cb address */
1382 if (ip_addr
== NULL
) {
1383 struct sockaddr_storage cb_addr
;
1384 struct sockaddr
*sap
= (struct sockaddr
*)&cb_addr
;
1386 error
= rpc_localaddr(clp
->cl_rpcclient
, sap
, sizeof(cb_addr
));
1389 error
= rpc_ntop(sap
, buf
, sizeof(buf
));
1392 ip_addr
= (const char *)buf
;
1394 strlcpy(clp
->cl_ipaddr
, ip_addr
, sizeof(clp
->cl_ipaddr
));
1396 error
= nfs_idmap_new(clp
);
1398 dprintk("%s: failed to create idmapper. Error = %d\n",
1402 __set_bit(NFS_CS_IDMAP
, &clp
->cl_res_state
);
1404 error
= nfs4_init_client_minor_version(clp
);
1408 if (!nfs4_has_session(clp
))
1409 nfs_mark_client_ready(clp
, NFS_CS_READY
);
1413 nfs_mark_client_ready(clp
, error
);
1414 dprintk("<-- nfs4_init_client() = xerror %d\n", error
);
1419 * Set up an NFS4 client
1421 static int nfs4_set_client(struct nfs_server
*server
,
1422 const char *hostname
,
1423 const struct sockaddr
*addr
,
1424 const size_t addrlen
,
1425 const char *ip_addr
,
1426 rpc_authflavor_t authflavour
,
1427 int proto
, const struct rpc_timeout
*timeparms
,
1428 u32 minorversion
, struct net
*net
)
1430 struct nfs_client_initdata cl_init
= {
1431 .hostname
= hostname
,
1434 .rpc_ops
= &nfs_v4_clientops
,
1436 .minorversion
= minorversion
,
1439 struct nfs_client
*clp
;
1442 dprintk("--> nfs4_set_client()\n");
1444 /* Allocate or find a client reference we can use */
1445 clp
= nfs_get_client(&cl_init
, timeparms
, ip_addr
, authflavour
,
1446 server
->flags
& NFS_MOUNT_NORESVPORT
);
1448 error
= PTR_ERR(clp
);
1453 * Query for the lease time on clientid setup or renewal
1455 * Note that this will be set on nfs_clients that were created
1456 * only for the DS role and did not set this bit, but now will
1457 * serve a dual role.
1459 set_bit(NFS_CS_CHECK_LEASE_TIME
, &clp
->cl_res_state
);
1461 server
->nfs_client
= clp
;
1462 dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp
);
1465 dprintk("<-- nfs4_set_client() = xerror %d\n", error
);
1470 * Set up a pNFS Data Server client.
1472 * Return any existing nfs_client that matches server address,port,version
1475 * For a new nfs_client, use a soft mount (default), a low retrans and a
1476 * low timeout interval so that if a connection is lost, we retry through
1479 struct nfs_client
*nfs4_set_ds_client(struct nfs_client
* mds_clp
,
1480 const struct sockaddr
*ds_addr
, int ds_addrlen
,
1481 int ds_proto
, unsigned int ds_timeo
, unsigned int ds_retrans
)
1483 struct nfs_client_initdata cl_init
= {
1485 .addrlen
= ds_addrlen
,
1486 .rpc_ops
= &nfs_v4_clientops
,
1488 .minorversion
= mds_clp
->cl_minorversion
,
1489 .net
= mds_clp
->net
,
1491 struct rpc_timeout ds_timeout
;
1492 struct nfs_client
*clp
;
1495 * Set an authflavor equual to the MDS value. Use the MDS nfs_client
1496 * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS
1497 * (section 13.1 RFC 5661).
1499 nfs_init_timeout_values(&ds_timeout
, ds_proto
, ds_timeo
, ds_retrans
);
1500 clp
= nfs_get_client(&cl_init
, &ds_timeout
, mds_clp
->cl_ipaddr
,
1501 mds_clp
->cl_rpcclient
->cl_auth
->au_flavor
, 0);
1503 dprintk("<-- %s %p\n", __func__
, clp
);
1506 EXPORT_SYMBOL_GPL(nfs4_set_ds_client
);
1509 * Session has been established, and the client marked ready.
1510 * Set the mount rsize and wsize with negotiated fore channel
1511 * attributes which will be bound checked in nfs_server_set_fsinfo.
1513 static void nfs4_session_set_rwsize(struct nfs_server
*server
)
1515 #ifdef CONFIG_NFS_V4_1
1516 struct nfs4_session
*sess
;
1520 if (!nfs4_has_session(server
->nfs_client
))
1522 sess
= server
->nfs_client
->cl_session
;
1523 server_resp_sz
= sess
->fc_attrs
.max_resp_sz
- nfs41_maxread_overhead
;
1524 server_rqst_sz
= sess
->fc_attrs
.max_rqst_sz
- nfs41_maxwrite_overhead
;
1526 if (server
->rsize
> server_resp_sz
)
1527 server
->rsize
= server_resp_sz
;
1528 if (server
->wsize
> server_rqst_sz
)
1529 server
->wsize
= server_rqst_sz
;
1530 #endif /* CONFIG_NFS_V4_1 */
1533 static int nfs4_server_common_setup(struct nfs_server
*server
,
1534 struct nfs_fh
*mntfh
)
1536 struct nfs_fattr
*fattr
;
1539 BUG_ON(!server
->nfs_client
);
1540 BUG_ON(!server
->nfs_client
->rpc_ops
);
1541 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
1543 /* data servers support only a subset of NFSv4.1 */
1544 if (is_ds_only_client(server
->nfs_client
))
1545 return -EPROTONOSUPPORT
;
1547 fattr
= nfs_alloc_fattr();
1551 /* We must ensure the session is initialised first */
1552 error
= nfs4_init_session(server
);
1556 /* Probe the root fh to retrieve its FSID and filehandle */
1557 error
= nfs4_get_rootfh(server
, mntfh
);
1561 dprintk("Server FSID: %llx:%llx\n",
1562 (unsigned long long) server
->fsid
.major
,
1563 (unsigned long long) server
->fsid
.minor
);
1564 dprintk("Mount FH: %d\n", mntfh
->size
);
1566 nfs4_session_set_rwsize(server
);
1568 error
= nfs_probe_fsinfo(server
, mntfh
, fattr
);
1572 if (server
->namelen
== 0 || server
->namelen
> NFS4_MAXNAMLEN
)
1573 server
->namelen
= NFS4_MAXNAMLEN
;
1575 nfs_server_insert_lists(server
);
1576 server
->mount_time
= jiffies
;
1577 server
->destroy
= nfs4_destroy_server
;
1579 nfs_free_fattr(fattr
);
1584 * Create a version 4 volume record
1586 static int nfs4_init_server(struct nfs_server
*server
,
1587 const struct nfs_parsed_mount_data
*data
)
1589 struct rpc_timeout timeparms
;
1592 dprintk("--> nfs4_init_server()\n");
1594 nfs_init_timeout_values(&timeparms
, data
->nfs_server
.protocol
,
1595 data
->timeo
, data
->retrans
);
1597 /* Initialise the client representation from the mount data */
1598 server
->flags
= data
->flags
;
1599 server
->caps
|= NFS_CAP_ATOMIC_OPEN
|NFS_CAP_CHANGE_ATTR
|NFS_CAP_POSIX_LOCK
;
1600 if (!(data
->flags
& NFS_MOUNT_NORDIRPLUS
))
1601 server
->caps
|= NFS_CAP_READDIRPLUS
;
1602 server
->options
= data
->options
;
1604 /* Get a client record */
1605 error
= nfs4_set_client(server
,
1606 data
->nfs_server
.hostname
,
1607 (const struct sockaddr
*)&data
->nfs_server
.address
,
1608 data
->nfs_server
.addrlen
,
1609 data
->client_address
,
1610 data
->auth_flavors
[0],
1611 data
->nfs_server
.protocol
,
1619 * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower
1622 if (nfs4_disable_idmapping
&& data
->auth_flavors
[0] == RPC_AUTH_UNIX
)
1623 server
->caps
|= NFS_CAP_UIDGID_NOMAP
;
1626 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
1628 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
1630 server
->acregmin
= data
->acregmin
* HZ
;
1631 server
->acregmax
= data
->acregmax
* HZ
;
1632 server
->acdirmin
= data
->acdirmin
* HZ
;
1633 server
->acdirmax
= data
->acdirmax
* HZ
;
1635 server
->port
= data
->nfs_server
.port
;
1637 error
= nfs_init_server_rpcclient(server
, &timeparms
, data
->auth_flavors
[0]);
1641 dprintk("<-- nfs4_init_server() = %d\n", error
);
1646 * Create a version 4 volume record
1647 * - keyed on server and FSID
1649 struct nfs_server
*nfs4_create_server(const struct nfs_parsed_mount_data
*data
,
1650 struct nfs_fh
*mntfh
)
1652 struct nfs_server
*server
;
1655 dprintk("--> nfs4_create_server()\n");
1657 server
= nfs_alloc_server();
1659 return ERR_PTR(-ENOMEM
);
1661 /* set up the general RPC client */
1662 error
= nfs4_init_server(server
, data
);
1666 error
= nfs4_server_common_setup(server
, mntfh
);
1670 dprintk("<-- nfs4_create_server() = %p\n", server
);
1674 nfs_free_server(server
);
1675 dprintk("<-- nfs4_create_server() = error %d\n", error
);
1676 return ERR_PTR(error
);
1680 * Create an NFS4 referral server record
1682 struct nfs_server
*nfs4_create_referral_server(struct nfs_clone_mount
*data
,
1683 struct nfs_fh
*mntfh
)
1685 struct nfs_client
*parent_client
;
1686 struct nfs_server
*server
, *parent_server
;
1689 dprintk("--> nfs4_create_referral_server()\n");
1691 server
= nfs_alloc_server();
1693 return ERR_PTR(-ENOMEM
);
1695 parent_server
= NFS_SB(data
->sb
);
1696 parent_client
= parent_server
->nfs_client
;
1698 /* Initialise the client representation from the parent server */
1699 nfs_server_copy_userdata(server
, parent_server
);
1700 server
->caps
|= NFS_CAP_ATOMIC_OPEN
|NFS_CAP_CHANGE_ATTR
;
1702 /* Get a client representation.
1703 * Note: NFSv4 always uses TCP, */
1704 error
= nfs4_set_client(server
, data
->hostname
,
1707 parent_client
->cl_ipaddr
,
1709 rpc_protocol(parent_server
->client
),
1710 parent_server
->client
->cl_timeout
,
1711 parent_client
->cl_mvops
->minor_version
,
1712 parent_client
->net
);
1716 error
= nfs_init_server_rpcclient(server
, parent_server
->client
->cl_timeout
, data
->authflavor
);
1720 error
= nfs4_server_common_setup(server
, mntfh
);
1724 dprintk("<-- nfs_create_referral_server() = %p\n", server
);
1728 nfs_free_server(server
);
1729 dprintk("<-- nfs4_create_referral_server() = error %d\n", error
);
1730 return ERR_PTR(error
);
1733 #endif /* CONFIG_NFS_V4 */
1736 * Clone an NFS2, NFS3 or NFS4 server record
1738 struct nfs_server
*nfs_clone_server(struct nfs_server
*source
,
1740 struct nfs_fattr
*fattr
,
1741 rpc_authflavor_t flavor
)
1743 struct nfs_server
*server
;
1744 struct nfs_fattr
*fattr_fsinfo
;
1747 dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
1748 (unsigned long long) fattr
->fsid
.major
,
1749 (unsigned long long) fattr
->fsid
.minor
);
1751 server
= nfs_alloc_server();
1753 return ERR_PTR(-ENOMEM
);
1756 fattr_fsinfo
= nfs_alloc_fattr();
1757 if (fattr_fsinfo
== NULL
)
1758 goto out_free_server
;
1760 /* Copy data from the source */
1761 server
->nfs_client
= source
->nfs_client
;
1762 server
->destroy
= source
->destroy
;
1763 atomic_inc(&server
->nfs_client
->cl_count
);
1764 nfs_server_copy_userdata(server
, source
);
1766 server
->fsid
= fattr
->fsid
;
1768 error
= nfs_init_server_rpcclient(server
,
1769 source
->client
->cl_timeout
,
1772 goto out_free_server
;
1773 if (!IS_ERR(source
->client_acl
))
1774 nfs_init_server_aclclient(server
);
1776 /* probe the filesystem info for this server filesystem */
1777 error
= nfs_probe_fsinfo(server
, fh
, fattr_fsinfo
);
1779 goto out_free_server
;
1781 if (server
->namelen
== 0 || server
->namelen
> NFS4_MAXNAMLEN
)
1782 server
->namelen
= NFS4_MAXNAMLEN
;
1784 dprintk("Cloned FSID: %llx:%llx\n",
1785 (unsigned long long) server
->fsid
.major
,
1786 (unsigned long long) server
->fsid
.minor
);
1788 error
= nfs_start_lockd(server
);
1790 goto out_free_server
;
1792 nfs_server_insert_lists(server
);
1793 server
->mount_time
= jiffies
;
1795 nfs_free_fattr(fattr_fsinfo
);
1796 dprintk("<-- nfs_clone_server() = %p\n", server
);
1800 nfs_free_fattr(fattr_fsinfo
);
1801 nfs_free_server(server
);
1802 dprintk("<-- nfs_clone_server() = error %d\n", error
);
1803 return ERR_PTR(error
);
1806 void nfs_clients_init(struct net
*net
)
1808 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
1810 INIT_LIST_HEAD(&nn
->nfs_client_list
);
1811 INIT_LIST_HEAD(&nn
->nfs_volume_list
);
1812 #ifdef CONFIG_NFS_V4
1813 idr_init(&nn
->cb_ident_idr
);
1815 spin_lock_init(&nn
->nfs_client_lock
);
1818 #ifdef CONFIG_PROC_FS
1819 static struct proc_dir_entry
*proc_fs_nfs
;
1821 static int nfs_server_list_open(struct inode
*inode
, struct file
*file
);
1822 static void *nfs_server_list_start(struct seq_file
*p
, loff_t
*pos
);
1823 static void *nfs_server_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
);
1824 static void nfs_server_list_stop(struct seq_file
*p
, void *v
);
1825 static int nfs_server_list_show(struct seq_file
*m
, void *v
);
1827 static const struct seq_operations nfs_server_list_ops
= {
1828 .start
= nfs_server_list_start
,
1829 .next
= nfs_server_list_next
,
1830 .stop
= nfs_server_list_stop
,
1831 .show
= nfs_server_list_show
,
1834 static const struct file_operations nfs_server_list_fops
= {
1835 .open
= nfs_server_list_open
,
1837 .llseek
= seq_lseek
,
1838 .release
= seq_release
,
1839 .owner
= THIS_MODULE
,
1842 static int nfs_volume_list_open(struct inode
*inode
, struct file
*file
);
1843 static void *nfs_volume_list_start(struct seq_file
*p
, loff_t
*pos
);
1844 static void *nfs_volume_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
);
1845 static void nfs_volume_list_stop(struct seq_file
*p
, void *v
);
1846 static int nfs_volume_list_show(struct seq_file
*m
, void *v
);
1848 static const struct seq_operations nfs_volume_list_ops
= {
1849 .start
= nfs_volume_list_start
,
1850 .next
= nfs_volume_list_next
,
1851 .stop
= nfs_volume_list_stop
,
1852 .show
= nfs_volume_list_show
,
1855 static const struct file_operations nfs_volume_list_fops
= {
1856 .open
= nfs_volume_list_open
,
1858 .llseek
= seq_lseek
,
1859 .release
= seq_release
,
1860 .owner
= THIS_MODULE
,
1864 * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
1867 static int nfs_server_list_open(struct inode
*inode
, struct file
*file
)
1871 struct pid_namespace
*pid_ns
= file
->f_dentry
->d_sb
->s_fs_info
;
1872 struct net
*net
= pid_ns
->child_reaper
->nsproxy
->net_ns
;
1874 ret
= seq_open(file
, &nfs_server_list_ops
);
1878 m
= file
->private_data
;
1885 * set up the iterator to start reading from the server list and return the first item
1887 static void *nfs_server_list_start(struct seq_file
*m
, loff_t
*_pos
)
1889 struct nfs_net
*nn
= net_generic(m
->private, nfs_net_id
);
1891 /* lock the list against modification */
1892 spin_lock(&nn
->nfs_client_lock
);
1893 return seq_list_start_head(&nn
->nfs_client_list
, *_pos
);
1897 * move to next server
1899 static void *nfs_server_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
)
1901 struct nfs_net
*nn
= net_generic(p
->private, nfs_net_id
);
1903 return seq_list_next(v
, &nn
->nfs_client_list
, pos
);
1907 * clean up after reading from the transports list
1909 static void nfs_server_list_stop(struct seq_file
*p
, void *v
)
1911 struct nfs_net
*nn
= net_generic(p
->private, nfs_net_id
);
1913 spin_unlock(&nn
->nfs_client_lock
);
1917 * display a header line followed by a load of call lines
1919 static int nfs_server_list_show(struct seq_file
*m
, void *v
)
1921 struct nfs_client
*clp
;
1922 struct nfs_net
*nn
= net_generic(m
->private, nfs_net_id
);
1924 /* display header on line 1 */
1925 if (v
== &nn
->nfs_client_list
) {
1926 seq_puts(m
, "NV SERVER PORT USE HOSTNAME\n");
1930 /* display one transport per line on subsequent lines */
1931 clp
= list_entry(v
, struct nfs_client
, cl_share_link
);
1933 /* Check if the client is initialized */
1934 if (clp
->cl_cons_state
!= NFS_CS_READY
)
1938 seq_printf(m
, "v%u %s %s %3d %s\n",
1939 clp
->rpc_ops
->version
,
1940 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_ADDR
),
1941 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_PORT
),
1942 atomic_read(&clp
->cl_count
),
1950 * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
1952 static int nfs_volume_list_open(struct inode
*inode
, struct file
*file
)
1956 struct pid_namespace
*pid_ns
= file
->f_dentry
->d_sb
->s_fs_info
;
1957 struct net
*net
= pid_ns
->child_reaper
->nsproxy
->net_ns
;
1959 ret
= seq_open(file
, &nfs_volume_list_ops
);
1963 m
= file
->private_data
;
1970 * set up the iterator to start reading from the volume list and return the first item
1972 static void *nfs_volume_list_start(struct seq_file
*m
, loff_t
*_pos
)
1974 struct nfs_net
*nn
= net_generic(m
->private, nfs_net_id
);
1976 /* lock the list against modification */
1977 spin_lock(&nn
->nfs_client_lock
);
1978 return seq_list_start_head(&nn
->nfs_volume_list
, *_pos
);
1982 * move to next volume
1984 static void *nfs_volume_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
)
1986 struct nfs_net
*nn
= net_generic(p
->private, nfs_net_id
);
1988 return seq_list_next(v
, &nn
->nfs_volume_list
, pos
);
1992 * clean up after reading from the transports list
1994 static void nfs_volume_list_stop(struct seq_file
*p
, void *v
)
1996 struct nfs_net
*nn
= net_generic(p
->private, nfs_net_id
);
1998 spin_unlock(&nn
->nfs_client_lock
);
2002 * display a header line followed by a load of call lines
2004 static int nfs_volume_list_show(struct seq_file
*m
, void *v
)
2006 struct nfs_server
*server
;
2007 struct nfs_client
*clp
;
2008 char dev
[8], fsid
[17];
2009 struct nfs_net
*nn
= net_generic(m
->private, nfs_net_id
);
2011 /* display header on line 1 */
2012 if (v
== &nn
->nfs_volume_list
) {
2013 seq_puts(m
, "NV SERVER PORT DEV FSID FSC\n");
2016 /* display one transport per line on subsequent lines */
2017 server
= list_entry(v
, struct nfs_server
, master_link
);
2018 clp
= server
->nfs_client
;
2020 snprintf(dev
, 8, "%u:%u",
2021 MAJOR(server
->s_dev
), MINOR(server
->s_dev
));
2023 snprintf(fsid
, 17, "%llx:%llx",
2024 (unsigned long long) server
->fsid
.major
,
2025 (unsigned long long) server
->fsid
.minor
);
2028 seq_printf(m
, "v%u %s %s %-7s %-17s %s\n",
2029 clp
->rpc_ops
->version
,
2030 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_ADDR
),
2031 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_PORT
),
2034 nfs_server_fscache_state(server
));
2041 * initialise the /proc/fs/nfsfs/ directory
2043 int __init
nfs_fs_proc_init(void)
2045 struct proc_dir_entry
*p
;
2047 proc_fs_nfs
= proc_mkdir("fs/nfsfs", NULL
);
2051 /* a file of servers with which we're dealing */
2052 p
= proc_create("servers", S_IFREG
|S_IRUGO
,
2053 proc_fs_nfs
, &nfs_server_list_fops
);
2057 /* a file of volumes that we have mounted */
2058 p
= proc_create("volumes", S_IFREG
|S_IRUGO
,
2059 proc_fs_nfs
, &nfs_volume_list_fops
);
2065 remove_proc_entry("servers", proc_fs_nfs
);
2067 remove_proc_entry("fs/nfsfs", NULL
);
2073 * clean up the /proc/fs/nfsfs/ directory
2075 void nfs_fs_proc_exit(void)
2077 remove_proc_entry("volumes", proc_fs_nfs
);
2078 remove_proc_entry("servers", proc_fs_nfs
);
2079 remove_proc_entry("fs/nfsfs", NULL
);
2082 #endif /* CONFIG_PROC_FS */
2084 module_param(nfs4_disable_idmapping
, bool, 0644);
2085 MODULE_PARM_DESC(nfs4_disable_idmapping
,
2086 "Turn off NFSv4 idmapping when using 'sec=sys'");