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>
39 #include <linux/nfs_xdr.h>
41 #include <asm/system.h>
45 #include "delegation.h"
49 #define NFSDBG_FACILITY NFSDBG_CLIENT
51 static DEFINE_SPINLOCK(nfs_client_lock
);
52 static LIST_HEAD(nfs_client_list
);
53 static LIST_HEAD(nfs_volume_list
);
54 static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq
);
59 static struct rpc_version
*nfs_version
[5] = {
69 struct rpc_program nfs_program
= {
71 .number
= NFS_PROGRAM
,
72 .nrvers
= ARRAY_SIZE(nfs_version
),
73 .version
= nfs_version
,
74 .stats
= &nfs_rpcstat
,
75 .pipe_dir_name
= "/nfs",
78 struct rpc_stat nfs_rpcstat
= {
79 .program
= &nfs_program
83 #ifdef CONFIG_NFS_V3_ACL
84 static struct rpc_stat nfsacl_rpcstat
= { &nfsacl_program
};
85 static struct rpc_version
* nfsacl_version
[] = {
86 [3] = &nfsacl_version3
,
89 struct rpc_program nfsacl_program
= {
91 .number
= NFS_ACL_PROGRAM
,
92 .nrvers
= ARRAY_SIZE(nfsacl_version
),
93 .version
= nfsacl_version
,
94 .stats
= &nfsacl_rpcstat
,
96 #endif /* CONFIG_NFS_V3_ACL */
98 struct nfs_client_initdata
{
100 const struct sockaddr_in
*addr
;
102 const struct nfs_rpc_ops
*rpc_ops
;
106 * Allocate a shared client record
108 * Since these are allocated/deallocated very rarely, we don't
109 * bother putting them in a slab cache...
111 static struct nfs_client
*nfs_alloc_client(const struct nfs_client_initdata
*cl_init
)
113 struct nfs_client
*clp
;
115 if ((clp
= kzalloc(sizeof(*clp
), GFP_KERNEL
)) == NULL
)
118 clp
->rpc_ops
= cl_init
->rpc_ops
;
120 if (cl_init
->rpc_ops
->version
== 4) {
121 if (nfs_callback_up() < 0)
123 __set_bit(NFS_CS_CALLBACK
, &clp
->cl_res_state
);
126 atomic_set(&clp
->cl_count
, 1);
127 clp
->cl_cons_state
= NFS_CS_INITING
;
129 memcpy(&clp
->cl_addr
, cl_init
->addr
, cl_init
->addrlen
);
130 clp
->cl_addrlen
= cl_init
->addrlen
;
132 if (cl_init
->hostname
) {
133 clp
->cl_hostname
= kstrdup(cl_init
->hostname
, GFP_KERNEL
);
134 if (!clp
->cl_hostname
)
138 INIT_LIST_HEAD(&clp
->cl_superblocks
);
139 clp
->cl_rpcclient
= ERR_PTR(-EINVAL
);
142 init_rwsem(&clp
->cl_sem
);
143 INIT_LIST_HEAD(&clp
->cl_delegations
);
144 spin_lock_init(&clp
->cl_lock
);
145 INIT_DELAYED_WORK(&clp
->cl_renewd
, nfs4_renew_state
);
146 rpc_init_wait_queue(&clp
->cl_rpcwaitq
, "NFS client");
147 clp
->cl_boot_time
= CURRENT_TIME
;
148 clp
->cl_state
= 1 << NFS4CLNT_LEASE_EXPIRED
;
154 if (__test_and_clear_bit(NFS_CS_CALLBACK
, &clp
->cl_res_state
))
162 static void nfs4_shutdown_client(struct nfs_client
*clp
)
165 if (__test_and_clear_bit(NFS_CS_RENEWD
, &clp
->cl_res_state
))
166 nfs4_kill_renewd(clp
);
167 BUG_ON(!RB_EMPTY_ROOT(&clp
->cl_state_owners
));
168 if (__test_and_clear_bit(NFS_CS_IDMAP
, &clp
->cl_res_state
))
169 nfs_idmap_delete(clp
);
174 * Destroy a shared client record
176 static void nfs_free_client(struct nfs_client
*clp
)
178 dprintk("--> nfs_free_client(%u)\n", clp
->rpc_ops
->version
);
180 nfs4_shutdown_client(clp
);
182 /* -EIO all pending I/O */
183 if (!IS_ERR(clp
->cl_rpcclient
))
184 rpc_shutdown_client(clp
->cl_rpcclient
);
186 if (__test_and_clear_bit(NFS_CS_CALLBACK
, &clp
->cl_res_state
))
189 kfree(clp
->cl_hostname
);
192 dprintk("<-- nfs_free_client()\n");
196 * Release a reference to a shared client record
198 void nfs_put_client(struct nfs_client
*clp
)
203 dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp
->cl_count
));
205 if (atomic_dec_and_lock(&clp
->cl_count
, &nfs_client_lock
)) {
206 list_del(&clp
->cl_share_link
);
207 spin_unlock(&nfs_client_lock
);
209 BUG_ON(!list_empty(&clp
->cl_superblocks
));
211 nfs_free_client(clp
);
215 static int nfs_sockaddr_match_ipaddr4(const struct sockaddr_in
*sa1
,
216 const struct sockaddr_in
*sa2
)
218 return sa1
->sin_addr
.s_addr
== sa2
->sin_addr
.s_addr
;
221 static int nfs_sockaddr_match_ipaddr6(const struct sockaddr_in6
*sa1
,
222 const struct sockaddr_in6
*sa2
)
224 return ipv6_addr_equal(&sa1
->sin6_addr
, &sa2
->sin6_addr
);
227 static int nfs_sockaddr_match_ipaddr(const struct sockaddr
*sa1
,
228 const struct sockaddr
*sa2
)
230 switch (sa1
->sa_family
) {
232 return nfs_sockaddr_match_ipaddr4((const struct sockaddr_in
*)sa1
,
233 (const struct sockaddr_in
*)sa2
);
235 return nfs_sockaddr_match_ipaddr6((const struct sockaddr_in6
*)sa1
,
236 (const struct sockaddr_in6
*)sa2
);
242 * Find a client by IP address and protocol version
243 * - returns NULL if no such client
245 struct nfs_client
*nfs_find_client(const struct sockaddr
*addr
, u32 nfsversion
)
247 struct nfs_client
*clp
;
249 spin_lock(&nfs_client_lock
);
250 list_for_each_entry(clp
, &nfs_client_list
, cl_share_link
) {
251 struct sockaddr
*clap
= (struct sockaddr
*)&clp
->cl_addr
;
253 /* Don't match clients that failed to initialise properly */
254 if (clp
->cl_cons_state
!= NFS_CS_READY
)
257 /* Different NFS versions cannot share the same nfs_client */
258 if (clp
->rpc_ops
->version
!= nfsversion
)
261 if (addr
->sa_family
!= clap
->sa_family
)
263 /* Match only the IP address, not the port number */
264 if (!nfs_sockaddr_match_ipaddr(addr
, clap
))
267 atomic_inc(&clp
->cl_count
);
268 spin_unlock(&nfs_client_lock
);
271 spin_unlock(&nfs_client_lock
);
276 * Find an nfs_client on the list that matches the initialisation data
279 static struct nfs_client
*nfs_match_client(const struct nfs_client_initdata
*data
)
281 struct nfs_client
*clp
;
283 list_for_each_entry(clp
, &nfs_client_list
, cl_share_link
) {
284 /* Don't match clients that failed to initialise properly */
285 if (clp
->cl_cons_state
< 0)
288 /* Different NFS versions cannot share the same nfs_client */
289 if (clp
->rpc_ops
!= data
->rpc_ops
)
292 /* Match the full socket address */
293 if (memcmp(&clp
->cl_addr
, data
->addr
, sizeof(clp
->cl_addr
)) != 0)
296 atomic_inc(&clp
->cl_count
);
303 * Look up a client by IP address and protocol version
304 * - creates a new record if one doesn't yet exist
306 static struct nfs_client
*nfs_get_client(const struct nfs_client_initdata
*cl_init
)
308 struct nfs_client
*clp
, *new = NULL
;
311 dprintk("--> nfs_get_client(%s,"NIPQUAD_FMT
":%d,%u)\n",
312 cl_init
->hostname
?: "", NIPQUAD(cl_init
->addr
->sin_addr
),
313 cl_init
->addr
->sin_port
, cl_init
->rpc_ops
->version
);
315 /* see if the client already exists */
317 spin_lock(&nfs_client_lock
);
319 clp
= nfs_match_client(cl_init
);
325 spin_unlock(&nfs_client_lock
);
327 new = nfs_alloc_client(cl_init
);
330 return ERR_PTR(-ENOMEM
);
332 /* install a new client and return with it unready */
335 list_add(&clp
->cl_share_link
, &nfs_client_list
);
336 spin_unlock(&nfs_client_lock
);
337 dprintk("--> nfs_get_client() = %p [new]\n", clp
);
340 /* found an existing client
341 * - make sure it's ready before returning
344 spin_unlock(&nfs_client_lock
);
347 nfs_free_client(new);
349 error
= wait_event_interruptible(nfs_client_active_wq
,
350 clp
->cl_cons_state
!= NFS_CS_INITING
);
353 return ERR_PTR(-ERESTARTSYS
);
356 if (clp
->cl_cons_state
< NFS_CS_READY
) {
357 error
= clp
->cl_cons_state
;
359 return ERR_PTR(error
);
362 BUG_ON(clp
->cl_cons_state
!= NFS_CS_READY
);
364 dprintk("--> nfs_get_client() = %p [share]\n", clp
);
369 * Mark a server as ready or failed
371 static void nfs_mark_client_ready(struct nfs_client
*clp
, int state
)
373 clp
->cl_cons_state
= state
;
374 wake_up_all(&nfs_client_active_wq
);
378 * Initialise the timeout values for a connection
380 static void nfs_init_timeout_values(struct rpc_timeout
*to
, int proto
,
381 unsigned int timeo
, unsigned int retrans
)
383 to
->to_initval
= timeo
* HZ
/ 10;
384 to
->to_retries
= retrans
;
389 case XPRT_TRANSPORT_TCP
:
390 case XPRT_TRANSPORT_RDMA
:
392 to
->to_initval
= 60 * HZ
;
393 if (to
->to_initval
> NFS_MAX_TCP_TIMEOUT
)
394 to
->to_initval
= NFS_MAX_TCP_TIMEOUT
;
395 to
->to_increment
= to
->to_initval
;
396 to
->to_maxval
= to
->to_initval
+ (to
->to_increment
* to
->to_retries
);
397 to
->to_exponential
= 0;
399 case XPRT_TRANSPORT_UDP
:
402 to
->to_initval
= 11 * HZ
/ 10;
403 if (to
->to_initval
> NFS_MAX_UDP_TIMEOUT
)
404 to
->to_initval
= NFS_MAX_UDP_TIMEOUT
;
405 to
->to_maxval
= NFS_MAX_UDP_TIMEOUT
;
406 to
->to_exponential
= 1;
412 * Create an RPC client handle
414 static int nfs_create_rpc_client(struct nfs_client
*clp
, int proto
,
416 unsigned int retrans
,
417 rpc_authflavor_t flavor
,
420 struct rpc_timeout timeparms
;
421 struct rpc_clnt
*clnt
= NULL
;
422 struct rpc_create_args args
= {
424 .address
= (struct sockaddr
*)&clp
->cl_addr
,
425 .addrsize
= clp
->cl_addrlen
,
426 .timeout
= &timeparms
,
427 .servername
= clp
->cl_hostname
,
428 .program
= &nfs_program
,
429 .version
= clp
->rpc_ops
->version
,
430 .authflavor
= flavor
,
434 if (!IS_ERR(clp
->cl_rpcclient
))
437 nfs_init_timeout_values(&timeparms
, proto
, timeo
, retrans
);
438 clp
->retrans_timeo
= timeparms
.to_initval
;
439 clp
->retrans_count
= timeparms
.to_retries
;
441 clnt
= rpc_create(&args
);
443 dprintk("%s: cannot create RPC client. Error = %ld\n",
444 __FUNCTION__
, PTR_ERR(clnt
));
445 return PTR_ERR(clnt
);
448 clp
->cl_rpcclient
= clnt
;
453 * Version 2 or 3 client destruction
455 static void nfs_destroy_server(struct nfs_server
*server
)
457 if (!(server
->flags
& NFS_MOUNT_NONLM
))
458 lockd_down(); /* release rpc.lockd */
462 * Version 2 or 3 lockd setup
464 static int nfs_start_lockd(struct nfs_server
*server
)
468 if (server
->nfs_client
->rpc_ops
->version
> 3)
470 if (server
->flags
& NFS_MOUNT_NONLM
)
472 error
= lockd_up((server
->flags
& NFS_MOUNT_TCP
) ?
473 IPPROTO_TCP
: IPPROTO_UDP
);
475 server
->flags
|= NFS_MOUNT_NONLM
;
477 server
->destroy
= nfs_destroy_server
;
483 * Initialise an NFSv3 ACL client connection
485 #ifdef CONFIG_NFS_V3_ACL
486 static void nfs_init_server_aclclient(struct nfs_server
*server
)
488 if (server
->nfs_client
->rpc_ops
->version
!= 3)
490 if (server
->flags
& NFS_MOUNT_NOACL
)
493 server
->client_acl
= rpc_bind_new_program(server
->client
, &nfsacl_program
, 3);
494 if (IS_ERR(server
->client_acl
))
497 /* No errors! Assume that Sun nfsacls are supported */
498 server
->caps
|= NFS_CAP_ACLS
;
502 server
->caps
&= ~NFS_CAP_ACLS
;
505 static inline void nfs_init_server_aclclient(struct nfs_server
*server
)
507 server
->flags
&= ~NFS_MOUNT_NOACL
;
508 server
->caps
&= ~NFS_CAP_ACLS
;
513 * Create a general RPC client
515 static int nfs_init_server_rpcclient(struct nfs_server
*server
, rpc_authflavor_t pseudoflavour
)
517 struct nfs_client
*clp
= server
->nfs_client
;
519 server
->client
= rpc_clone_client(clp
->cl_rpcclient
);
520 if (IS_ERR(server
->client
)) {
521 dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__
);
522 return PTR_ERR(server
->client
);
525 if (pseudoflavour
!= clp
->cl_rpcclient
->cl_auth
->au_flavor
) {
526 struct rpc_auth
*auth
;
528 auth
= rpcauth_create(pseudoflavour
, server
->client
);
530 dprintk("%s: couldn't create credcache!\n", __FUNCTION__
);
531 return PTR_ERR(auth
);
534 server
->client
->cl_softrtry
= 0;
535 if (server
->flags
& NFS_MOUNT_SOFT
)
536 server
->client
->cl_softrtry
= 1;
538 server
->client
->cl_intr
= 0;
539 if (server
->flags
& NFS4_MOUNT_INTR
)
540 server
->client
->cl_intr
= 1;
546 * Initialise an NFS2 or NFS3 client
548 static int nfs_init_client(struct nfs_client
*clp
,
549 const struct nfs_parsed_mount_data
*data
)
553 if (clp
->cl_cons_state
== NFS_CS_READY
) {
554 /* the client is already initialised */
555 dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp
);
560 * Create a client RPC handle for doing FSSTAT with UNIX auth only
561 * - RFC 2623, sec 2.3.2
563 error
= nfs_create_rpc_client(clp
, data
->nfs_server
.protocol
,
564 data
->timeo
, data
->retrans
, RPC_AUTH_UNIX
, 0);
567 nfs_mark_client_ready(clp
, NFS_CS_READY
);
571 nfs_mark_client_ready(clp
, error
);
572 dprintk("<-- nfs_init_client() = xerror %d\n", error
);
577 * Create a version 2 or 3 client
579 static int nfs_init_server(struct nfs_server
*server
,
580 const struct nfs_parsed_mount_data
*data
)
582 struct nfs_client_initdata cl_init
= {
583 .hostname
= data
->nfs_server
.hostname
,
584 .addr
= &data
->nfs_server
.address
,
585 .addrlen
= sizeof(data
->nfs_server
.address
),
586 .rpc_ops
= &nfs_v2_clientops
,
588 struct nfs_client
*clp
;
591 dprintk("--> nfs_init_server()\n");
594 if (data
->flags
& NFS_MOUNT_VER3
)
595 cl_init
.rpc_ops
= &nfs_v3_clientops
;
598 /* Allocate or find a client reference we can use */
599 clp
= nfs_get_client(&cl_init
);
601 dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp
));
605 error
= nfs_init_client(clp
, data
);
609 server
->nfs_client
= clp
;
611 /* Initialise the client representation from the mount data */
612 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
615 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
617 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
619 server
->acregmin
= data
->acregmin
* HZ
;
620 server
->acregmax
= data
->acregmax
* HZ
;
621 server
->acdirmin
= data
->acdirmin
* HZ
;
622 server
->acdirmax
= data
->acdirmax
* HZ
;
624 /* Start lockd here, before we might error out */
625 error
= nfs_start_lockd(server
);
629 error
= nfs_init_server_rpcclient(server
, data
->auth_flavors
[0]);
633 server
->namelen
= data
->namlen
;
634 /* Create a client RPC handle for the NFSv3 ACL management interface */
635 nfs_init_server_aclclient(server
);
636 dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp
);
640 server
->nfs_client
= NULL
;
642 dprintk("<-- nfs_init_server() = xerror %d\n", error
);
647 * Load up the server record from information gained in an fsinfo record
649 static void nfs_server_set_fsinfo(struct nfs_server
*server
, struct nfs_fsinfo
*fsinfo
)
651 unsigned long max_rpc_payload
;
653 /* Work out a lot of parameters */
654 if (server
->rsize
== 0)
655 server
->rsize
= nfs_block_size(fsinfo
->rtpref
, NULL
);
656 if (server
->wsize
== 0)
657 server
->wsize
= nfs_block_size(fsinfo
->wtpref
, NULL
);
659 if (fsinfo
->rtmax
>= 512 && server
->rsize
> fsinfo
->rtmax
)
660 server
->rsize
= nfs_block_size(fsinfo
->rtmax
, NULL
);
661 if (fsinfo
->wtmax
>= 512 && server
->wsize
> fsinfo
->wtmax
)
662 server
->wsize
= nfs_block_size(fsinfo
->wtmax
, NULL
);
664 max_rpc_payload
= nfs_block_size(rpc_max_payload(server
->client
), NULL
);
665 if (server
->rsize
> max_rpc_payload
)
666 server
->rsize
= max_rpc_payload
;
667 if (server
->rsize
> NFS_MAX_FILE_IO_SIZE
)
668 server
->rsize
= NFS_MAX_FILE_IO_SIZE
;
669 server
->rpages
= (server
->rsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
671 server
->backing_dev_info
.ra_pages
= server
->rpages
* NFS_MAX_READAHEAD
;
673 if (server
->wsize
> max_rpc_payload
)
674 server
->wsize
= max_rpc_payload
;
675 if (server
->wsize
> NFS_MAX_FILE_IO_SIZE
)
676 server
->wsize
= NFS_MAX_FILE_IO_SIZE
;
677 server
->wpages
= (server
->wsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
678 server
->wtmult
= nfs_block_bits(fsinfo
->wtmult
, NULL
);
680 server
->dtsize
= nfs_block_size(fsinfo
->dtpref
, NULL
);
681 if (server
->dtsize
> PAGE_CACHE_SIZE
)
682 server
->dtsize
= PAGE_CACHE_SIZE
;
683 if (server
->dtsize
> server
->rsize
)
684 server
->dtsize
= server
->rsize
;
686 if (server
->flags
& NFS_MOUNT_NOAC
) {
687 server
->acregmin
= server
->acregmax
= 0;
688 server
->acdirmin
= server
->acdirmax
= 0;
691 server
->maxfilesize
= fsinfo
->maxfilesize
;
693 /* We're airborne Set socket buffersize */
694 rpc_setbufsize(server
->client
, server
->wsize
+ 100, server
->rsize
+ 100);
698 * Probe filesystem information, including the FSID on v2/v3
700 static int nfs_probe_fsinfo(struct nfs_server
*server
, struct nfs_fh
*mntfh
, struct nfs_fattr
*fattr
)
702 struct nfs_fsinfo fsinfo
;
703 struct nfs_client
*clp
= server
->nfs_client
;
706 dprintk("--> nfs_probe_fsinfo()\n");
708 if (clp
->rpc_ops
->set_capabilities
!= NULL
) {
709 error
= clp
->rpc_ops
->set_capabilities(server
, mntfh
);
714 fsinfo
.fattr
= fattr
;
715 nfs_fattr_init(fattr
);
716 error
= clp
->rpc_ops
->fsinfo(server
, mntfh
, &fsinfo
);
720 nfs_server_set_fsinfo(server
, &fsinfo
);
721 error
= bdi_init(&server
->backing_dev_info
);
726 /* Get some general file system info */
727 if (server
->namelen
== 0) {
728 struct nfs_pathconf pathinfo
;
730 pathinfo
.fattr
= fattr
;
731 nfs_fattr_init(fattr
);
733 if (clp
->rpc_ops
->pathconf(server
, mntfh
, &pathinfo
) >= 0)
734 server
->namelen
= pathinfo
.max_namelen
;
737 dprintk("<-- nfs_probe_fsinfo() = 0\n");
741 dprintk("nfs_probe_fsinfo: error = %d\n", -error
);
746 * Copy useful information when duplicating a server record
748 static void nfs_server_copy_userdata(struct nfs_server
*target
, struct nfs_server
*source
)
750 target
->flags
= source
->flags
;
751 target
->acregmin
= source
->acregmin
;
752 target
->acregmax
= source
->acregmax
;
753 target
->acdirmin
= source
->acdirmin
;
754 target
->acdirmax
= source
->acdirmax
;
755 target
->caps
= source
->caps
;
759 * Allocate and initialise a server record
761 static struct nfs_server
*nfs_alloc_server(void)
763 struct nfs_server
*server
;
765 server
= kzalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
769 server
->client
= server
->client_acl
= ERR_PTR(-EINVAL
);
771 /* Zero out the NFS state stuff */
772 INIT_LIST_HEAD(&server
->client_link
);
773 INIT_LIST_HEAD(&server
->master_link
);
775 init_waitqueue_head(&server
->active_wq
);
776 atomic_set(&server
->active
, 0);
778 server
->io_stats
= nfs_alloc_iostats();
779 if (!server
->io_stats
) {
788 * Free up a server record
790 void nfs_free_server(struct nfs_server
*server
)
792 dprintk("--> nfs_free_server()\n");
794 spin_lock(&nfs_client_lock
);
795 list_del(&server
->client_link
);
796 list_del(&server
->master_link
);
797 spin_unlock(&nfs_client_lock
);
799 if (server
->destroy
!= NULL
)
800 server
->destroy(server
);
802 if (!IS_ERR(server
->client_acl
))
803 rpc_shutdown_client(server
->client_acl
);
804 if (!IS_ERR(server
->client
))
805 rpc_shutdown_client(server
->client
);
807 nfs_put_client(server
->nfs_client
);
809 nfs_free_iostats(server
->io_stats
);
810 bdi_destroy(&server
->backing_dev_info
);
812 nfs_release_automount_timer();
813 dprintk("<-- nfs_free_server()\n");
817 * Create a version 2 or 3 volume record
818 * - keyed on server and FSID
820 struct nfs_server
*nfs_create_server(const struct nfs_parsed_mount_data
*data
,
821 struct nfs_fh
*mntfh
)
823 struct nfs_server
*server
;
824 struct nfs_fattr fattr
;
827 server
= nfs_alloc_server();
829 return ERR_PTR(-ENOMEM
);
831 /* Get a client representation */
832 error
= nfs_init_server(server
, data
);
836 BUG_ON(!server
->nfs_client
);
837 BUG_ON(!server
->nfs_client
->rpc_ops
);
838 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
840 /* Probe the root fh to retrieve its FSID */
841 error
= nfs_probe_fsinfo(server
, mntfh
, &fattr
);
844 if (server
->nfs_client
->rpc_ops
->version
== 3) {
845 if (server
->namelen
== 0 || server
->namelen
> NFS3_MAXNAMLEN
)
846 server
->namelen
= NFS3_MAXNAMLEN
;
847 if (!(data
->flags
& NFS_MOUNT_NORDIRPLUS
))
848 server
->caps
|= NFS_CAP_READDIRPLUS
;
850 if (server
->namelen
== 0 || server
->namelen
> NFS2_MAXNAMLEN
)
851 server
->namelen
= NFS2_MAXNAMLEN
;
854 if (!(fattr
.valid
& NFS_ATTR_FATTR
)) {
855 error
= server
->nfs_client
->rpc_ops
->getattr(server
, mntfh
, &fattr
);
857 dprintk("nfs_create_server: getattr error = %d\n", -error
);
861 memcpy(&server
->fsid
, &fattr
.fsid
, sizeof(server
->fsid
));
863 dprintk("Server FSID: %llx:%llx\n",
864 (unsigned long long) server
->fsid
.major
,
865 (unsigned long long) server
->fsid
.minor
);
867 BUG_ON(!server
->nfs_client
);
868 BUG_ON(!server
->nfs_client
->rpc_ops
);
869 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
871 spin_lock(&nfs_client_lock
);
872 list_add_tail(&server
->client_link
, &server
->nfs_client
->cl_superblocks
);
873 list_add_tail(&server
->master_link
, &nfs_volume_list
);
874 spin_unlock(&nfs_client_lock
);
876 server
->mount_time
= jiffies
;
880 nfs_free_server(server
);
881 return ERR_PTR(error
);
886 * Initialise an NFS4 client record
888 static int nfs4_init_client(struct nfs_client
*clp
,
889 int proto
, int timeo
, int retrans
,
891 rpc_authflavor_t authflavour
)
895 if (clp
->cl_cons_state
== NFS_CS_READY
) {
896 /* the client is initialised already */
897 dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp
);
901 /* Check NFS protocol revision and initialize RPC op vector */
902 clp
->rpc_ops
= &nfs_v4_clientops
;
904 error
= nfs_create_rpc_client(clp
, proto
, timeo
, retrans
, authflavour
,
905 RPC_CLNT_CREATE_DISCRTRY
);
908 memcpy(clp
->cl_ipaddr
, ip_addr
, sizeof(clp
->cl_ipaddr
));
910 error
= nfs_idmap_new(clp
);
912 dprintk("%s: failed to create idmapper. Error = %d\n",
913 __FUNCTION__
, error
);
916 __set_bit(NFS_CS_IDMAP
, &clp
->cl_res_state
);
918 nfs_mark_client_ready(clp
, NFS_CS_READY
);
922 nfs_mark_client_ready(clp
, error
);
923 dprintk("<-- nfs4_init_client() = xerror %d\n", error
);
928 * Set up an NFS4 client
930 static int nfs4_set_client(struct nfs_server
*server
,
931 const char *hostname
, const struct sockaddr_in
*addr
,
933 rpc_authflavor_t authflavour
,
934 int proto
, int timeo
, int retrans
)
936 struct nfs_client_initdata cl_init
= {
937 .hostname
= hostname
,
939 .addrlen
= sizeof(*addr
),
940 .rpc_ops
= &nfs_v4_clientops
,
942 struct nfs_client
*clp
;
945 dprintk("--> nfs4_set_client()\n");
947 /* Allocate or find a client reference we can use */
948 clp
= nfs_get_client(&cl_init
);
950 error
= PTR_ERR(clp
);
953 error
= nfs4_init_client(clp
, proto
, timeo
, retrans
, ip_addr
, authflavour
);
957 server
->nfs_client
= clp
;
958 dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp
);
964 dprintk("<-- nfs4_set_client() = xerror %d\n", error
);
969 * Create a version 4 volume record
971 static int nfs4_init_server(struct nfs_server
*server
,
972 const struct nfs_parsed_mount_data
*data
)
976 dprintk("--> nfs4_init_server()\n");
978 /* Initialise the client representation from the mount data */
979 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
980 server
->caps
|= NFS_CAP_ATOMIC_OPEN
;
983 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
985 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
987 server
->acregmin
= data
->acregmin
* HZ
;
988 server
->acregmax
= data
->acregmax
* HZ
;
989 server
->acdirmin
= data
->acdirmin
* HZ
;
990 server
->acdirmax
= data
->acdirmax
* HZ
;
992 error
= nfs_init_server_rpcclient(server
, data
->auth_flavors
[0]);
995 dprintk("<-- nfs4_init_server() = %d\n", error
);
1000 * Create a version 4 volume record
1001 * - keyed on server and FSID
1003 struct nfs_server
*nfs4_create_server(const struct nfs_parsed_mount_data
*data
,
1004 struct nfs_fh
*mntfh
)
1006 struct nfs_fattr fattr
;
1007 struct nfs_server
*server
;
1010 dprintk("--> nfs4_create_server()\n");
1012 server
= nfs_alloc_server();
1014 return ERR_PTR(-ENOMEM
);
1016 /* Get a client record */
1017 error
= nfs4_set_client(server
,
1018 data
->nfs_server
.hostname
,
1019 &data
->nfs_server
.address
,
1020 data
->client_address
,
1021 data
->auth_flavors
[0],
1022 data
->nfs_server
.protocol
,
1023 data
->timeo
, data
->retrans
);
1027 /* set up the general RPC client */
1028 error
= nfs4_init_server(server
, data
);
1032 BUG_ON(!server
->nfs_client
);
1033 BUG_ON(!server
->nfs_client
->rpc_ops
);
1034 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
1036 /* Probe the root fh to retrieve its FSID */
1037 error
= nfs4_path_walk(server
, mntfh
, data
->nfs_server
.export_path
);
1041 dprintk("Server FSID: %llx:%llx\n",
1042 (unsigned long long) server
->fsid
.major
,
1043 (unsigned long long) server
->fsid
.minor
);
1044 dprintk("Mount FH: %d\n", mntfh
->size
);
1046 error
= nfs_probe_fsinfo(server
, mntfh
, &fattr
);
1050 if (server
->namelen
== 0 || server
->namelen
> NFS4_MAXNAMLEN
)
1051 server
->namelen
= NFS4_MAXNAMLEN
;
1053 BUG_ON(!server
->nfs_client
);
1054 BUG_ON(!server
->nfs_client
->rpc_ops
);
1055 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
1057 spin_lock(&nfs_client_lock
);
1058 list_add_tail(&server
->client_link
, &server
->nfs_client
->cl_superblocks
);
1059 list_add_tail(&server
->master_link
, &nfs_volume_list
);
1060 spin_unlock(&nfs_client_lock
);
1062 server
->mount_time
= jiffies
;
1063 dprintk("<-- nfs4_create_server() = %p\n", server
);
1067 nfs_free_server(server
);
1068 dprintk("<-- nfs4_create_server() = error %d\n", error
);
1069 return ERR_PTR(error
);
1073 * Create an NFS4 referral server record
1075 struct nfs_server
*nfs4_create_referral_server(struct nfs_clone_mount
*data
,
1076 struct nfs_fh
*mntfh
)
1078 struct nfs_client
*parent_client
;
1079 struct nfs_server
*server
, *parent_server
;
1080 struct nfs_fattr fattr
;
1083 dprintk("--> nfs4_create_referral_server()\n");
1085 server
= nfs_alloc_server();
1087 return ERR_PTR(-ENOMEM
);
1089 parent_server
= NFS_SB(data
->sb
);
1090 parent_client
= parent_server
->nfs_client
;
1092 /* Get a client representation.
1093 * Note: NFSv4 always uses TCP, */
1094 error
= nfs4_set_client(server
, data
->hostname
, data
->addr
,
1095 parent_client
->cl_ipaddr
,
1097 parent_server
->client
->cl_xprt
->prot
,
1098 parent_client
->retrans_timeo
,
1099 parent_client
->retrans_count
);
1103 /* Initialise the client representation from the parent server */
1104 nfs_server_copy_userdata(server
, parent_server
);
1105 server
->caps
|= NFS_CAP_ATOMIC_OPEN
;
1107 error
= nfs_init_server_rpcclient(server
, data
->authflavor
);
1111 BUG_ON(!server
->nfs_client
);
1112 BUG_ON(!server
->nfs_client
->rpc_ops
);
1113 BUG_ON(!server
->nfs_client
->rpc_ops
->file_inode_ops
);
1115 /* Probe the root fh to retrieve its FSID and filehandle */
1116 error
= nfs4_path_walk(server
, mntfh
, data
->mnt_path
);
1120 /* probe the filesystem info for this server filesystem */
1121 error
= nfs_probe_fsinfo(server
, mntfh
, &fattr
);
1125 if (server
->namelen
== 0 || server
->namelen
> NFS4_MAXNAMLEN
)
1126 server
->namelen
= NFS4_MAXNAMLEN
;
1128 dprintk("Referral FSID: %llx:%llx\n",
1129 (unsigned long long) server
->fsid
.major
,
1130 (unsigned long long) server
->fsid
.minor
);
1132 spin_lock(&nfs_client_lock
);
1133 list_add_tail(&server
->client_link
, &server
->nfs_client
->cl_superblocks
);
1134 list_add_tail(&server
->master_link
, &nfs_volume_list
);
1135 spin_unlock(&nfs_client_lock
);
1137 server
->mount_time
= jiffies
;
1139 dprintk("<-- nfs_create_referral_server() = %p\n", server
);
1143 nfs_free_server(server
);
1144 dprintk("<-- nfs4_create_referral_server() = error %d\n", error
);
1145 return ERR_PTR(error
);
1148 #endif /* CONFIG_NFS_V4 */
1151 * Clone an NFS2, NFS3 or NFS4 server record
1153 struct nfs_server
*nfs_clone_server(struct nfs_server
*source
,
1155 struct nfs_fattr
*fattr
)
1157 struct nfs_server
*server
;
1158 struct nfs_fattr fattr_fsinfo
;
1161 dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
1162 (unsigned long long) fattr
->fsid
.major
,
1163 (unsigned long long) fattr
->fsid
.minor
);
1165 server
= nfs_alloc_server();
1167 return ERR_PTR(-ENOMEM
);
1169 /* Copy data from the source */
1170 server
->nfs_client
= source
->nfs_client
;
1171 atomic_inc(&server
->nfs_client
->cl_count
);
1172 nfs_server_copy_userdata(server
, source
);
1174 server
->fsid
= fattr
->fsid
;
1176 error
= nfs_init_server_rpcclient(server
, source
->client
->cl_auth
->au_flavor
);
1178 goto out_free_server
;
1179 if (!IS_ERR(source
->client_acl
))
1180 nfs_init_server_aclclient(server
);
1182 /* probe the filesystem info for this server filesystem */
1183 error
= nfs_probe_fsinfo(server
, fh
, &fattr_fsinfo
);
1185 goto out_free_server
;
1187 if (server
->namelen
== 0 || server
->namelen
> NFS4_MAXNAMLEN
)
1188 server
->namelen
= NFS4_MAXNAMLEN
;
1190 dprintk("Cloned FSID: %llx:%llx\n",
1191 (unsigned long long) server
->fsid
.major
,
1192 (unsigned long long) server
->fsid
.minor
);
1194 error
= nfs_start_lockd(server
);
1196 goto out_free_server
;
1198 spin_lock(&nfs_client_lock
);
1199 list_add_tail(&server
->client_link
, &server
->nfs_client
->cl_superblocks
);
1200 list_add_tail(&server
->master_link
, &nfs_volume_list
);
1201 spin_unlock(&nfs_client_lock
);
1203 server
->mount_time
= jiffies
;
1205 dprintk("<-- nfs_clone_server() = %p\n", server
);
1209 nfs_free_server(server
);
1210 dprintk("<-- nfs_clone_server() = error %d\n", error
);
1211 return ERR_PTR(error
);
1214 #ifdef CONFIG_PROC_FS
1215 static struct proc_dir_entry
*proc_fs_nfs
;
1217 static int nfs_server_list_open(struct inode
*inode
, struct file
*file
);
1218 static void *nfs_server_list_start(struct seq_file
*p
, loff_t
*pos
);
1219 static void *nfs_server_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
);
1220 static void nfs_server_list_stop(struct seq_file
*p
, void *v
);
1221 static int nfs_server_list_show(struct seq_file
*m
, void *v
);
1223 static struct seq_operations nfs_server_list_ops
= {
1224 .start
= nfs_server_list_start
,
1225 .next
= nfs_server_list_next
,
1226 .stop
= nfs_server_list_stop
,
1227 .show
= nfs_server_list_show
,
1230 static const struct file_operations nfs_server_list_fops
= {
1231 .open
= nfs_server_list_open
,
1233 .llseek
= seq_lseek
,
1234 .release
= seq_release
,
1237 static int nfs_volume_list_open(struct inode
*inode
, struct file
*file
);
1238 static void *nfs_volume_list_start(struct seq_file
*p
, loff_t
*pos
);
1239 static void *nfs_volume_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
);
1240 static void nfs_volume_list_stop(struct seq_file
*p
, void *v
);
1241 static int nfs_volume_list_show(struct seq_file
*m
, void *v
);
1243 static struct seq_operations nfs_volume_list_ops
= {
1244 .start
= nfs_volume_list_start
,
1245 .next
= nfs_volume_list_next
,
1246 .stop
= nfs_volume_list_stop
,
1247 .show
= nfs_volume_list_show
,
1250 static const struct file_operations nfs_volume_list_fops
= {
1251 .open
= nfs_volume_list_open
,
1253 .llseek
= seq_lseek
,
1254 .release
= seq_release
,
1258 * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
1261 static int nfs_server_list_open(struct inode
*inode
, struct file
*file
)
1266 ret
= seq_open(file
, &nfs_server_list_ops
);
1270 m
= file
->private_data
;
1271 m
->private = PDE(inode
)->data
;
1277 * set up the iterator to start reading from the server list and return the first item
1279 static void *nfs_server_list_start(struct seq_file
*m
, loff_t
*_pos
)
1281 /* lock the list against modification */
1282 spin_lock(&nfs_client_lock
);
1283 return seq_list_start_head(&nfs_client_list
, *_pos
);
1287 * move to next server
1289 static void *nfs_server_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
)
1291 return seq_list_next(v
, &nfs_client_list
, pos
);
1295 * clean up after reading from the transports list
1297 static void nfs_server_list_stop(struct seq_file
*p
, void *v
)
1299 spin_unlock(&nfs_client_lock
);
1303 * display a header line followed by a load of call lines
1305 static int nfs_server_list_show(struct seq_file
*m
, void *v
)
1307 struct nfs_client
*clp
;
1309 /* display header on line 1 */
1310 if (v
== &nfs_client_list
) {
1311 seq_puts(m
, "NV SERVER PORT USE HOSTNAME\n");
1315 /* display one transport per line on subsequent lines */
1316 clp
= list_entry(v
, struct nfs_client
, cl_share_link
);
1318 seq_printf(m
, "v%u %s %s %3d %s\n",
1319 clp
->rpc_ops
->version
,
1320 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_ADDR
),
1321 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_PORT
),
1322 atomic_read(&clp
->cl_count
),
1329 * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
1331 static int nfs_volume_list_open(struct inode
*inode
, struct file
*file
)
1336 ret
= seq_open(file
, &nfs_volume_list_ops
);
1340 m
= file
->private_data
;
1341 m
->private = PDE(inode
)->data
;
1347 * set up the iterator to start reading from the volume list and return the first item
1349 static void *nfs_volume_list_start(struct seq_file
*m
, loff_t
*_pos
)
1351 /* lock the list against modification */
1352 spin_lock(&nfs_client_lock
);
1353 return seq_list_start_head(&nfs_volume_list
, *_pos
);
1357 * move to next volume
1359 static void *nfs_volume_list_next(struct seq_file
*p
, void *v
, loff_t
*pos
)
1361 return seq_list_next(v
, &nfs_volume_list
, pos
);
1365 * clean up after reading from the transports list
1367 static void nfs_volume_list_stop(struct seq_file
*p
, void *v
)
1369 spin_unlock(&nfs_client_lock
);
1373 * display a header line followed by a load of call lines
1375 static int nfs_volume_list_show(struct seq_file
*m
, void *v
)
1377 struct nfs_server
*server
;
1378 struct nfs_client
*clp
;
1379 char dev
[8], fsid
[17];
1381 /* display header on line 1 */
1382 if (v
== &nfs_volume_list
) {
1383 seq_puts(m
, "NV SERVER PORT DEV FSID\n");
1386 /* display one transport per line on subsequent lines */
1387 server
= list_entry(v
, struct nfs_server
, master_link
);
1388 clp
= server
->nfs_client
;
1390 snprintf(dev
, 8, "%u:%u",
1391 MAJOR(server
->s_dev
), MINOR(server
->s_dev
));
1393 snprintf(fsid
, 17, "%llx:%llx",
1394 (unsigned long long) server
->fsid
.major
,
1395 (unsigned long long) server
->fsid
.minor
);
1397 seq_printf(m
, "v%u %s %s %-7s %-17s\n",
1398 clp
->rpc_ops
->version
,
1399 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_ADDR
),
1400 rpc_peeraddr2str(clp
->cl_rpcclient
, RPC_DISPLAY_HEX_PORT
),
1408 * initialise the /proc/fs/nfsfs/ directory
1410 int __init
nfs_fs_proc_init(void)
1412 struct proc_dir_entry
*p
;
1414 proc_fs_nfs
= proc_mkdir("nfsfs", proc_root_fs
);
1418 proc_fs_nfs
->owner
= THIS_MODULE
;
1420 /* a file of servers with which we're dealing */
1421 p
= create_proc_entry("servers", S_IFREG
|S_IRUGO
, proc_fs_nfs
);
1425 p
->proc_fops
= &nfs_server_list_fops
;
1426 p
->owner
= THIS_MODULE
;
1428 /* a file of volumes that we have mounted */
1429 p
= create_proc_entry("volumes", S_IFREG
|S_IRUGO
, proc_fs_nfs
);
1433 p
->proc_fops
= &nfs_volume_list_fops
;
1434 p
->owner
= THIS_MODULE
;
1438 remove_proc_entry("servers", proc_fs_nfs
);
1440 remove_proc_entry("nfsfs", proc_root_fs
);
1446 * clean up the /proc/fs/nfsfs/ directory
1448 void nfs_fs_proc_exit(void)
1450 remove_proc_entry("volumes", proc_fs_nfs
);
1451 remove_proc_entry("servers", proc_fs_nfs
);
1452 remove_proc_entry("nfsfs", proc_root_fs
);
1455 #endif /* CONFIG_PROC_FS */