4 * Copyright (C) 1992 Rick Sladkey
6 * nfs superblock handling functions
8 * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
9 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12 * J.S.Peatfield@damtp.cam.ac.uk
14 * Split from inode.c by David Howells <dhowells@redhat.com>
18 #include <linux/config.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
22 #include <linux/time.h>
23 #include <linux/kernel.h>
25 #include <linux/string.h>
26 #include <linux/stat.h>
27 #include <linux/errno.h>
28 #include <linux/unistd.h>
29 #include <linux/sunrpc/clnt.h>
30 #include <linux/sunrpc/stats.h>
31 #include <linux/sunrpc/metrics.h>
32 #include <linux/nfs_fs.h>
33 #include <linux/nfs_mount.h>
34 #include <linux/nfs4_mount.h>
35 #include <linux/lockd/bind.h>
36 #include <linux/smp_lock.h>
37 #include <linux/seq_file.h>
38 #include <linux/mount.h>
39 #include <linux/nfs_idmap.h>
40 #include <linux/vfs.h>
41 #include <linux/inet.h>
42 #include <linux/nfs_xdr.h>
44 #include <asm/system.h>
45 #include <asm/uaccess.h>
49 #include "delegation.h"
53 #define NFSDBG_FACILITY NFSDBG_VFS
55 /* Maximum number of readahead requests
56 * FIXME: this should really be a sysctl so that users may tune it to suit
57 * their needs. People that do NFS over a slow network, might for
58 * instance want to reduce it to something closer to 1 for improved
59 * interactive response.
61 #define NFS_MAX_READAHEAD (RPC_DEF_SLOT_TABLE - 1)
66 static struct rpc_version
* nfs_version
[] = {
70 #if defined(CONFIG_NFS_V3)
72 #elif defined(CONFIG_NFS_V4)
75 #if defined(CONFIG_NFS_V4)
80 static struct rpc_program nfs_program
= {
82 .number
= NFS_PROGRAM
,
83 .nrvers
= ARRAY_SIZE(nfs_version
),
84 .version
= nfs_version
,
85 .stats
= &nfs_rpcstat
,
86 .pipe_dir_name
= "/nfs",
89 struct rpc_stat nfs_rpcstat
= {
90 .program
= &nfs_program
94 #ifdef CONFIG_NFS_V3_ACL
95 static struct rpc_stat nfsacl_rpcstat
= { &nfsacl_program
};
96 static struct rpc_version
* nfsacl_version
[] = {
97 [3] = &nfsacl_version3
,
100 struct rpc_program nfsacl_program
= {
102 .number
= NFS_ACL_PROGRAM
,
103 .nrvers
= ARRAY_SIZE(nfsacl_version
),
104 .version
= nfsacl_version
,
105 .stats
= &nfsacl_rpcstat
,
107 #endif /* CONFIG_NFS_V3_ACL */
109 static void nfs_umount_begin(struct vfsmount
*, int);
110 static int nfs_statfs(struct dentry
*, struct kstatfs
*);
111 static int nfs_show_options(struct seq_file
*, struct vfsmount
*);
112 static int nfs_show_stats(struct seq_file
*, struct vfsmount
*);
113 static int nfs_get_sb(struct file_system_type
*, int, const char *, void *, struct vfsmount
*);
114 static int nfs_clone_nfs_sb(struct file_system_type
*fs_type
,
115 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
116 static void nfs_kill_super(struct super_block
*);
118 static struct file_system_type nfs_fs_type
= {
119 .owner
= THIS_MODULE
,
121 .get_sb
= nfs_get_sb
,
122 .kill_sb
= nfs_kill_super
,
123 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
126 struct file_system_type clone_nfs_fs_type
= {
127 .owner
= THIS_MODULE
,
129 .get_sb
= nfs_clone_nfs_sb
,
130 .kill_sb
= nfs_kill_super
,
131 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
134 static struct super_operations nfs_sops
= {
135 .alloc_inode
= nfs_alloc_inode
,
136 .destroy_inode
= nfs_destroy_inode
,
137 .write_inode
= nfs_write_inode
,
138 .statfs
= nfs_statfs
,
139 .clear_inode
= nfs_clear_inode
,
140 .umount_begin
= nfs_umount_begin
,
141 .show_options
= nfs_show_options
,
142 .show_stats
= nfs_show_stats
,
146 static int nfs4_get_sb(struct file_system_type
*fs_type
,
147 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
148 static int nfs_clone_nfs4_sb(struct file_system_type
*fs_type
,
149 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
150 static int nfs_referral_nfs4_sb(struct file_system_type
*fs_type
,
151 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
152 static void nfs4_kill_super(struct super_block
*sb
);
154 static struct file_system_type nfs4_fs_type
= {
155 .owner
= THIS_MODULE
,
157 .get_sb
= nfs4_get_sb
,
158 .kill_sb
= nfs4_kill_super
,
159 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
162 struct file_system_type clone_nfs4_fs_type
= {
163 .owner
= THIS_MODULE
,
165 .get_sb
= nfs_clone_nfs4_sb
,
166 .kill_sb
= nfs4_kill_super
,
167 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
170 struct file_system_type nfs_referral_nfs4_fs_type
= {
171 .owner
= THIS_MODULE
,
173 .get_sb
= nfs_referral_nfs4_sb
,
174 .kill_sb
= nfs4_kill_super
,
175 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
178 static struct super_operations nfs4_sops
= {
179 .alloc_inode
= nfs_alloc_inode
,
180 .destroy_inode
= nfs_destroy_inode
,
181 .write_inode
= nfs_write_inode
,
182 .statfs
= nfs_statfs
,
183 .clear_inode
= nfs4_clear_inode
,
184 .umount_begin
= nfs_umount_begin
,
185 .show_options
= nfs_show_options
,
186 .show_stats
= nfs_show_stats
,
191 static const int nfs_set_port_min
= 0;
192 static const int nfs_set_port_max
= 65535;
194 static int param_set_port(const char *val
, struct kernel_param
*kp
)
197 int num
= simple_strtol(val
, &endp
, 0);
198 if (endp
== val
|| *endp
|| num
< nfs_set_port_min
|| num
> nfs_set_port_max
)
200 *((int *)kp
->arg
) = num
;
204 module_param_call(callback_tcpport
, param_set_port
, param_get_int
,
205 &nfs_callback_set_tcpport
, 0644);
209 static int param_set_idmap_timeout(const char *val
, struct kernel_param
*kp
)
212 int num
= simple_strtol(val
, &endp
, 0);
214 if (endp
== val
|| *endp
|| num
< 0 || jif
< num
)
216 *((int *)kp
->arg
) = jif
;
220 module_param_call(idmap_cache_timeout
, param_set_idmap_timeout
, param_get_int
,
221 &nfs_idmap_cache_timeout
, 0644);
224 static struct shrinker
*acl_shrinker
;
227 * Register the NFS filesystems
229 int __init
register_nfs_fs(void)
233 ret
= register_filesystem(&nfs_fs_type
);
238 ret
= nfs_register_sysctl();
241 ret
= register_filesystem(&nfs4_fs_type
);
245 acl_shrinker
= set_shrinker(DEFAULT_SEEKS
, nfs_access_cache_shrinker
);
250 nfs_unregister_sysctl();
252 unregister_filesystem(&nfs_fs_type
);
259 * Unregister the NFS filesystems
261 void __exit
unregister_nfs_fs(void)
263 if (acl_shrinker
!= NULL
)
264 remove_shrinker(acl_shrinker
);
266 unregister_filesystem(&nfs4_fs_type
);
267 nfs_unregister_sysctl();
269 unregister_filesystem(&nfs_fs_type
);
273 * Deliver file system statistics to userspace
275 static int nfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
277 struct super_block
*sb
= dentry
->d_sb
;
278 struct nfs_server
*server
= NFS_SB(sb
);
279 unsigned char blockbits
;
280 unsigned long blockres
;
281 struct nfs_fh
*rootfh
= NFS_FH(sb
->s_root
->d_inode
);
282 struct nfs_fattr fattr
;
283 struct nfs_fsstat res
= {
290 error
= server
->rpc_ops
->statfs(server
, rootfh
, &res
);
291 buf
->f_type
= NFS_SUPER_MAGIC
;
296 * Current versions of glibc do not correctly handle the
297 * case where f_frsize != f_bsize. Eventually we want to
298 * report the value of wtmult in this field.
300 buf
->f_frsize
= sb
->s_blocksize
;
303 * On most *nix systems, f_blocks, f_bfree, and f_bavail
304 * are reported in units of f_frsize. Linux hasn't had
305 * an f_frsize field in its statfs struct until recently,
306 * thus historically Linux's sys_statfs reports these
307 * fields in units of f_bsize.
309 buf
->f_bsize
= sb
->s_blocksize
;
310 blockbits
= sb
->s_blocksize_bits
;
311 blockres
= (1 << blockbits
) - 1;
312 buf
->f_blocks
= (res
.tbytes
+ blockres
) >> blockbits
;
313 buf
->f_bfree
= (res
.fbytes
+ blockres
) >> blockbits
;
314 buf
->f_bavail
= (res
.abytes
+ blockres
) >> blockbits
;
316 buf
->f_files
= res
.tfiles
;
317 buf
->f_ffree
= res
.afiles
;
319 buf
->f_namelen
= server
->namelen
;
325 dprintk("%s: statfs error = %d\n", __FUNCTION__
, -error
);
326 buf
->f_bsize
= buf
->f_blocks
= buf
->f_bfree
= buf
->f_bavail
= -1;
331 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour
)
334 rpc_authflavor_t flavour
;
337 { RPC_AUTH_NULL
, "null" },
338 { RPC_AUTH_UNIX
, "sys" },
339 { RPC_AUTH_GSS_KRB5
, "krb5" },
340 { RPC_AUTH_GSS_KRB5I
, "krb5i" },
341 { RPC_AUTH_GSS_KRB5P
, "krb5p" },
342 { RPC_AUTH_GSS_LKEY
, "lkey" },
343 { RPC_AUTH_GSS_LKEYI
, "lkeyi" },
344 { RPC_AUTH_GSS_LKEYP
, "lkeyp" },
345 { RPC_AUTH_GSS_SPKM
, "spkm" },
346 { RPC_AUTH_GSS_SPKMI
, "spkmi" },
347 { RPC_AUTH_GSS_SPKMP
, "spkmp" },
352 for (i
=0; sec_flavours
[i
].flavour
!= -1; i
++) {
353 if (sec_flavours
[i
].flavour
== flavour
)
356 return sec_flavours
[i
].str
;
360 * Describe the mount options in force on this server representation
362 static void nfs_show_mount_options(struct seq_file
*m
, struct nfs_server
*nfss
, int showdefaults
)
364 static struct proc_nfs_info
{
369 { NFS_MOUNT_SOFT
, ",soft", ",hard" },
370 { NFS_MOUNT_INTR
, ",intr", "" },
371 { NFS_MOUNT_NOCTO
, ",nocto", "" },
372 { NFS_MOUNT_NOAC
, ",noac", "" },
373 { NFS_MOUNT_NONLM
, ",nolock", "" },
374 { NFS_MOUNT_NOACL
, ",noacl", "" },
377 struct proc_nfs_info
*nfs_infop
;
381 seq_printf(m
, ",vers=%d", nfss
->rpc_ops
->version
);
382 seq_printf(m
, ",rsize=%d", nfss
->rsize
);
383 seq_printf(m
, ",wsize=%d", nfss
->wsize
);
384 if (nfss
->acregmin
!= 3*HZ
|| showdefaults
)
385 seq_printf(m
, ",acregmin=%d", nfss
->acregmin
/HZ
);
386 if (nfss
->acregmax
!= 60*HZ
|| showdefaults
)
387 seq_printf(m
, ",acregmax=%d", nfss
->acregmax
/HZ
);
388 if (nfss
->acdirmin
!= 30*HZ
|| showdefaults
)
389 seq_printf(m
, ",acdirmin=%d", nfss
->acdirmin
/HZ
);
390 if (nfss
->acdirmax
!= 60*HZ
|| showdefaults
)
391 seq_printf(m
, ",acdirmax=%d", nfss
->acdirmax
/HZ
);
392 for (nfs_infop
= nfs_info
; nfs_infop
->flag
; nfs_infop
++) {
393 if (nfss
->flags
& nfs_infop
->flag
)
394 seq_puts(m
, nfs_infop
->str
);
396 seq_puts(m
, nfs_infop
->nostr
);
398 switch (nfss
->client
->cl_xprt
->prot
) {
406 snprintf(buf
, sizeof(buf
), "%u", nfss
->client
->cl_xprt
->prot
);
409 seq_printf(m
, ",proto=%s", proto
);
410 seq_printf(m
, ",timeo=%lu", 10U * nfss
->retrans_timeo
/ HZ
);
411 seq_printf(m
, ",retrans=%u", nfss
->retrans_count
);
412 seq_printf(m
, ",sec=%s", nfs_pseudoflavour_to_name(nfss
->client
->cl_auth
->au_flavor
));
416 * Describe the mount options on this VFS mountpoint
418 static int nfs_show_options(struct seq_file
*m
, struct vfsmount
*mnt
)
420 struct nfs_server
*nfss
= NFS_SB(mnt
->mnt_sb
);
422 nfs_show_mount_options(m
, nfss
, 0);
424 seq_puts(m
, ",addr=");
425 seq_escape(m
, nfss
->hostname
, " \t\n\\");
431 * Present statistical information for this VFS mountpoint
433 static int nfs_show_stats(struct seq_file
*m
, struct vfsmount
*mnt
)
436 struct nfs_server
*nfss
= NFS_SB(mnt
->mnt_sb
);
437 struct rpc_auth
*auth
= nfss
->client
->cl_auth
;
438 struct nfs_iostats totals
= { };
440 seq_printf(m
, "statvers=%s", NFS_IOSTAT_VERS
);
443 * Display all mount option settings
445 seq_printf(m
, "\n\topts:\t");
446 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_RDONLY
? "ro" : "rw");
447 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_SYNCHRONOUS
? ",sync" : "");
448 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_NOATIME
? ",noatime" : "");
449 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_NODIRATIME
? ",nodiratime" : "");
450 nfs_show_mount_options(m
, nfss
, 1);
452 seq_printf(m
, "\n\tage:\t%lu", (jiffies
- nfss
->mount_time
) / HZ
);
454 seq_printf(m
, "\n\tcaps:\t");
455 seq_printf(m
, "caps=0x%x", nfss
->caps
);
456 seq_printf(m
, ",wtmult=%d", nfss
->wtmult
);
457 seq_printf(m
, ",dtsize=%d", nfss
->dtsize
);
458 seq_printf(m
, ",bsize=%d", nfss
->bsize
);
459 seq_printf(m
, ",namelen=%d", nfss
->namelen
);
462 if (nfss
->rpc_ops
->version
== 4) {
463 seq_printf(m
, "\n\tnfsv4:\t");
464 seq_printf(m
, "bm0=0x%x", nfss
->attr_bitmask
[0]);
465 seq_printf(m
, ",bm1=0x%x", nfss
->attr_bitmask
[1]);
466 seq_printf(m
, ",acl=0x%x", nfss
->acl_bitmask
);
471 * Display security flavor in effect for this mount
473 seq_printf(m
, "\n\tsec:\tflavor=%d", auth
->au_ops
->au_flavor
);
475 seq_printf(m
, ",pseudoflavor=%d", auth
->au_flavor
);
478 * Display superblock I/O counters
480 for_each_possible_cpu(cpu
) {
481 struct nfs_iostats
*stats
;
484 stats
= per_cpu_ptr(nfss
->io_stats
, cpu
);
486 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
487 totals
.events
[i
] += stats
->events
[i
];
488 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
489 totals
.bytes
[i
] += stats
->bytes
[i
];
494 seq_printf(m
, "\n\tevents:\t");
495 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
496 seq_printf(m
, "%lu ", totals
.events
[i
]);
497 seq_printf(m
, "\n\tbytes:\t");
498 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
499 seq_printf(m
, "%Lu ", totals
.bytes
[i
]);
502 rpc_print_iostats(m
, nfss
->client
);
508 * Begin unmount by attempting to remove all automounted mountpoints we added
509 * in response to traversals
511 static void nfs_umount_begin(struct vfsmount
*vfsmnt
, int flags
)
513 struct nfs_server
*server
;
514 struct rpc_clnt
*rpc
;
516 shrink_submounts(vfsmnt
, &nfs_automount_list
);
517 if (!(flags
& MNT_FORCE
))
519 /* -EIO all pending I/O */
520 server
= NFS_SB(vfsmnt
->mnt_sb
);
521 rpc
= server
->client
;
523 rpc_killall_tasks(rpc
);
524 rpc
= server
->client_acl
;
526 rpc_killall_tasks(rpc
);
530 * Obtain the root inode of the file system.
532 static struct inode
*
533 nfs_get_root(struct super_block
*sb
, struct nfs_fh
*rootfh
, struct nfs_fsinfo
*fsinfo
)
535 struct nfs_server
*server
= NFS_SB(sb
);
538 error
= server
->rpc_ops
->getroot(server
, rootfh
, fsinfo
);
540 dprintk("nfs_get_root: getattr error = %d\n", -error
);
541 return ERR_PTR(error
);
544 server
->fsid
= fsinfo
->fattr
->fsid
;
545 return nfs_fhget(sb
, rootfh
, fsinfo
->fattr
);
549 * Do NFS version-independent mount processing, and sanity checking
552 nfs_sb_init(struct super_block
*sb
, rpc_authflavor_t authflavor
)
554 struct nfs_server
*server
;
555 struct inode
*root_inode
;
556 struct nfs_fattr fattr
;
557 struct nfs_fsinfo fsinfo
= {
560 struct nfs_pathconf pathinfo
= {
563 int no_root_error
= 0;
564 unsigned long max_rpc_payload
;
566 /* We probably want something more informative here */
567 snprintf(sb
->s_id
, sizeof(sb
->s_id
), "%x:%x", MAJOR(sb
->s_dev
), MINOR(sb
->s_dev
));
571 sb
->s_magic
= NFS_SUPER_MAGIC
;
573 server
->io_stats
= nfs_alloc_iostats();
574 if (server
->io_stats
== NULL
)
577 root_inode
= nfs_get_root(sb
, &server
->fh
, &fsinfo
);
578 /* Did getting the root inode fail? */
579 if (IS_ERR(root_inode
)) {
580 no_root_error
= PTR_ERR(root_inode
);
583 sb
->s_root
= d_alloc_root(root_inode
);
585 no_root_error
= -ENOMEM
;
588 sb
->s_root
->d_op
= server
->rpc_ops
->dentry_ops
;
590 /* mount time stamp, in seconds */
591 server
->mount_time
= jiffies
;
593 /* Get some general file system info */
594 if (server
->namelen
== 0 &&
595 server
->rpc_ops
->pathconf(server
, &server
->fh
, &pathinfo
) >= 0)
596 server
->namelen
= pathinfo
.max_namelen
;
597 /* Work out a lot of parameters */
598 if (server
->rsize
== 0)
599 server
->rsize
= nfs_block_size(fsinfo
.rtpref
, NULL
);
600 if (server
->wsize
== 0)
601 server
->wsize
= nfs_block_size(fsinfo
.wtpref
, NULL
);
603 if (fsinfo
.rtmax
>= 512 && server
->rsize
> fsinfo
.rtmax
)
604 server
->rsize
= nfs_block_size(fsinfo
.rtmax
, NULL
);
605 if (fsinfo
.wtmax
>= 512 && server
->wsize
> fsinfo
.wtmax
)
606 server
->wsize
= nfs_block_size(fsinfo
.wtmax
, NULL
);
608 max_rpc_payload
= nfs_block_size(rpc_max_payload(server
->client
), NULL
);
609 if (server
->rsize
> max_rpc_payload
)
610 server
->rsize
= max_rpc_payload
;
611 if (server
->rsize
> NFS_MAX_FILE_IO_SIZE
)
612 server
->rsize
= NFS_MAX_FILE_IO_SIZE
;
613 server
->rpages
= (server
->rsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
615 if (server
->wsize
> max_rpc_payload
)
616 server
->wsize
= max_rpc_payload
;
617 if (server
->wsize
> NFS_MAX_FILE_IO_SIZE
)
618 server
->wsize
= NFS_MAX_FILE_IO_SIZE
;
619 server
->wpages
= (server
->wsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
621 if (sb
->s_blocksize
== 0)
622 sb
->s_blocksize
= nfs_block_bits(server
->wsize
,
623 &sb
->s_blocksize_bits
);
624 server
->wtmult
= nfs_block_bits(fsinfo
.wtmult
, NULL
);
626 server
->dtsize
= nfs_block_size(fsinfo
.dtpref
, NULL
);
627 if (server
->dtsize
> PAGE_CACHE_SIZE
)
628 server
->dtsize
= PAGE_CACHE_SIZE
;
629 if (server
->dtsize
> server
->rsize
)
630 server
->dtsize
= server
->rsize
;
632 if (server
->flags
& NFS_MOUNT_NOAC
) {
633 server
->acregmin
= server
->acregmax
= 0;
634 server
->acdirmin
= server
->acdirmax
= 0;
635 sb
->s_flags
|= MS_SYNCHRONOUS
;
637 server
->backing_dev_info
.ra_pages
= server
->rpages
* NFS_MAX_READAHEAD
;
639 nfs_super_set_maxbytes(sb
, fsinfo
.maxfilesize
);
641 server
->client
->cl_intr
= (server
->flags
& NFS_MOUNT_INTR
) ? 1 : 0;
642 server
->client
->cl_softrtry
= (server
->flags
& NFS_MOUNT_SOFT
) ? 1 : 0;
644 /* We're airborne Set socket buffersize */
645 rpc_setbufsize(server
->client
, server
->wsize
+ 100, server
->rsize
+ 100);
647 /* Yargs. It didn't work out. */
649 dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error
);
650 if (!IS_ERR(root_inode
))
652 return no_root_error
;
656 * Initialise the timeout values for a connection
658 static void nfs_init_timeout_values(struct rpc_timeout
*to
, int proto
, unsigned int timeo
, unsigned int retrans
)
660 to
->to_initval
= timeo
* HZ
/ 10;
661 to
->to_retries
= retrans
;
668 to
->to_initval
= 60 * HZ
;
669 if (to
->to_initval
> NFS_MAX_TCP_TIMEOUT
)
670 to
->to_initval
= NFS_MAX_TCP_TIMEOUT
;
671 to
->to_increment
= to
->to_initval
;
672 to
->to_maxval
= to
->to_initval
+ (to
->to_increment
* to
->to_retries
);
673 to
->to_exponential
= 0;
678 to
->to_initval
= 11 * HZ
/ 10;
679 if (to
->to_initval
> NFS_MAX_UDP_TIMEOUT
)
680 to
->to_initval
= NFS_MAX_UDP_TIMEOUT
;
681 to
->to_maxval
= NFS_MAX_UDP_TIMEOUT
;
682 to
->to_exponential
= 1;
688 * Create an RPC client handle.
690 static struct rpc_clnt
*
691 nfs_create_client(struct nfs_server
*server
, const struct nfs_mount_data
*data
)
693 struct rpc_timeout timeparms
;
694 struct rpc_xprt
*xprt
= NULL
;
695 struct rpc_clnt
*clnt
= NULL
;
696 int proto
= (data
->flags
& NFS_MOUNT_TCP
) ? IPPROTO_TCP
: IPPROTO_UDP
;
698 nfs_init_timeout_values(&timeparms
, proto
, data
->timeo
, data
->retrans
);
700 server
->retrans_timeo
= timeparms
.to_initval
;
701 server
->retrans_count
= timeparms
.to_retries
;
703 /* create transport and client */
704 xprt
= xprt_create_proto(proto
, &server
->addr
, &timeparms
);
706 dprintk("%s: cannot create RPC transport. Error = %ld\n",
707 __FUNCTION__
, PTR_ERR(xprt
));
708 return (struct rpc_clnt
*)xprt
;
710 clnt
= rpc_create_client(xprt
, server
->hostname
, &nfs_program
,
711 server
->rpc_ops
->version
, data
->pseudoflavor
);
713 dprintk("%s: cannot create RPC client. Error = %ld\n",
714 __FUNCTION__
, PTR_ERR(xprt
));
719 clnt
->cl_softrtry
= 1;
728 * Clone a server record
730 static struct nfs_server
*nfs_clone_server(struct super_block
*sb
, struct nfs_clone_mount
*data
)
732 struct nfs_server
*server
= NFS_SB(sb
);
733 struct nfs_server
*parent
= NFS_SB(data
->sb
);
734 struct inode
*root_inode
;
735 struct nfs_fsinfo fsinfo
;
736 void *err
= ERR_PTR(-ENOMEM
);
738 sb
->s_op
= data
->sb
->s_op
;
739 sb
->s_blocksize
= data
->sb
->s_blocksize
;
740 sb
->s_blocksize_bits
= data
->sb
->s_blocksize_bits
;
741 sb
->s_maxbytes
= data
->sb
->s_maxbytes
;
743 server
->client_sys
= server
->client_acl
= ERR_PTR(-EINVAL
);
744 server
->io_stats
= nfs_alloc_iostats();
745 if (server
->io_stats
== NULL
)
748 server
->client
= rpc_clone_client(parent
->client
);
749 if (IS_ERR((err
= server
->client
)))
752 if (!IS_ERR(parent
->client_sys
)) {
753 server
->client_sys
= rpc_clone_client(parent
->client_sys
);
754 if (IS_ERR((err
= server
->client_sys
)))
757 if (!IS_ERR(parent
->client_acl
)) {
758 server
->client_acl
= rpc_clone_client(parent
->client_acl
);
759 if (IS_ERR((err
= server
->client_acl
)))
762 root_inode
= nfs_fhget(sb
, data
->fh
, data
->fattr
);
765 sb
->s_root
= d_alloc_root(root_inode
);
768 fsinfo
.fattr
= data
->fattr
;
769 if (NFS_PROTO(root_inode
)->fsinfo(server
, data
->fh
, &fsinfo
) == 0)
770 nfs_super_set_maxbytes(sb
, fsinfo
.maxfilesize
);
771 sb
->s_root
->d_op
= server
->rpc_ops
->dentry_ops
;
772 sb
->s_flags
|= MS_ACTIVE
;
781 * Copy an existing superblock and attach revised data
783 static int nfs_clone_generic_sb(struct nfs_clone_mount
*data
,
784 struct super_block
*(*fill_sb
)(struct nfs_server
*, struct nfs_clone_mount
*),
785 struct nfs_server
*(*fill_server
)(struct super_block
*, struct nfs_clone_mount
*),
786 struct vfsmount
*mnt
)
788 struct nfs_server
*server
;
789 struct nfs_server
*parent
= NFS_SB(data
->sb
);
790 struct super_block
*sb
= ERR_PTR(-EINVAL
);
795 server
= kmalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
798 memcpy(server
, parent
, sizeof(*server
));
799 hostname
= (data
->hostname
!= NULL
) ? data
->hostname
: parent
->hostname
;
800 len
= strlen(hostname
) + 1;
801 server
->hostname
= kmalloc(len
, GFP_KERNEL
);
802 if (server
->hostname
== NULL
)
804 memcpy(server
->hostname
, hostname
, len
);
809 sb
= fill_sb(server
, data
);
816 goto out_rpciod_down
;
818 server
= fill_server(sb
, data
);
819 if (IS_ERR(server
)) {
820 error
= PTR_ERR(server
);
823 return simple_set_mnt(mnt
, sb
);
825 up_write(&sb
->s_umount
);
826 deactivate_super(sb
);
830 kfree(server
->hostname
);
832 return simple_set_mnt(mnt
, sb
);
836 kfree(server
->hostname
);
844 * Set up an NFS2/3 superblock
846 * The way this works is that the mount process passes a structure
847 * in the data argument which contains the server's IP address
848 * and the root file handle obtained from the server's mount
849 * daemon. We stash these away in the private superblock fields.
852 nfs_fill_super(struct super_block
*sb
, struct nfs_mount_data
*data
, int silent
)
854 struct nfs_server
*server
;
855 rpc_authflavor_t authflavor
;
858 sb
->s_blocksize_bits
= 0;
861 sb
->s_blocksize
= nfs_block_size(data
->bsize
, &sb
->s_blocksize_bits
);
863 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
865 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
866 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
868 server
->acregmin
= data
->acregmin
*HZ
;
869 server
->acregmax
= data
->acregmax
*HZ
;
870 server
->acdirmin
= data
->acdirmin
*HZ
;
871 server
->acdirmax
= data
->acdirmax
*HZ
;
873 /* Start lockd here, before we might error out */
874 if (!(server
->flags
& NFS_MOUNT_NONLM
))
877 server
->namelen
= data
->namlen
;
878 server
->hostname
= kmalloc(strlen(data
->hostname
) + 1, GFP_KERNEL
);
879 if (!server
->hostname
)
881 strcpy(server
->hostname
, data
->hostname
);
883 /* Check NFS protocol revision and initialize RPC op vector
884 * and file handle pool. */
886 if (server
->flags
& NFS_MOUNT_VER3
) {
887 server
->rpc_ops
= &nfs_v3_clientops
;
888 server
->caps
|= NFS_CAP_READDIRPLUS
;
890 server
->rpc_ops
= &nfs_v2_clientops
;
893 server
->rpc_ops
= &nfs_v2_clientops
;
896 /* Fill in pseudoflavor for mount version < 5 */
897 if (!(data
->flags
& NFS_MOUNT_SECFLAVOUR
))
898 data
->pseudoflavor
= RPC_AUTH_UNIX
;
899 authflavor
= data
->pseudoflavor
; /* save for sb_init() */
900 /* XXX maybe we want to add a server->pseudoflavor field */
902 /* Create RPC client handles */
903 server
->client
= nfs_create_client(server
, data
);
904 if (IS_ERR(server
->client
))
905 return PTR_ERR(server
->client
);
906 /* RFC 2623, sec 2.3.2 */
907 if (authflavor
!= RPC_AUTH_UNIX
) {
908 struct rpc_auth
*auth
;
910 server
->client_sys
= rpc_clone_client(server
->client
);
911 if (IS_ERR(server
->client_sys
))
912 return PTR_ERR(server
->client_sys
);
913 auth
= rpcauth_create(RPC_AUTH_UNIX
, server
->client_sys
);
915 return PTR_ERR(auth
);
917 atomic_inc(&server
->client
->cl_count
);
918 server
->client_sys
= server
->client
;
920 if (server
->flags
& NFS_MOUNT_VER3
) {
921 #ifdef CONFIG_NFS_V3_ACL
922 if (!(server
->flags
& NFS_MOUNT_NOACL
)) {
923 server
->client_acl
= rpc_bind_new_program(server
->client
, &nfsacl_program
, 3);
924 /* No errors! Assume that Sun nfsacls are supported */
925 if (!IS_ERR(server
->client_acl
))
926 server
->caps
|= NFS_CAP_ACLS
;
929 server
->flags
&= ~NFS_MOUNT_NOACL
;
930 #endif /* CONFIG_NFS_V3_ACL */
932 * The VFS shouldn't apply the umask to mode bits. We will
933 * do so ourselves when necessary.
935 sb
->s_flags
|= MS_POSIXACL
;
936 if (server
->namelen
== 0 || server
->namelen
> NFS3_MAXNAMLEN
)
937 server
->namelen
= NFS3_MAXNAMLEN
;
940 if (server
->namelen
== 0 || server
->namelen
> NFS2_MAXNAMLEN
)
941 server
->namelen
= NFS2_MAXNAMLEN
;
944 sb
->s_op
= &nfs_sops
;
945 return nfs_sb_init(sb
, authflavor
);
948 static int nfs_set_super(struct super_block
*s
, void *data
)
951 return set_anon_super(s
, data
);
954 static int nfs_compare_super(struct super_block
*sb
, void *data
)
956 struct nfs_server
*server
= data
;
957 struct nfs_server
*old
= NFS_SB(sb
);
959 if (old
->addr
.sin_addr
.s_addr
!= server
->addr
.sin_addr
.s_addr
)
961 if (old
->addr
.sin_port
!= server
->addr
.sin_port
)
963 return !nfs_compare_fh(&old
->fh
, &server
->fh
);
966 static int nfs_get_sb(struct file_system_type
*fs_type
,
967 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
970 struct nfs_server
*server
= NULL
;
971 struct super_block
*s
;
973 struct nfs_mount_data
*data
= raw_data
;
977 dprintk("%s: missing data argument\n", __FUNCTION__
);
978 goto out_err_noserver
;
980 if (data
->version
<= 0 || data
->version
> NFS_MOUNT_VERSION
) {
981 dprintk("%s: bad mount version\n", __FUNCTION__
);
982 goto out_err_noserver
;
984 switch (data
->version
) {
990 if (data
->flags
& NFS_MOUNT_VER3
) {
991 dprintk("%s: mount structure version %d does not support NFSv3\n",
994 goto out_err_noserver
;
996 data
->root
.size
= NFS2_FHSIZE
;
997 memcpy(data
->root
.data
, data
->old_root
.data
, NFS2_FHSIZE
);
999 if (data
->flags
& NFS_MOUNT_SECFLAVOUR
) {
1000 dprintk("%s: mount structure version %d does not support strong security\n",
1003 goto out_err_noserver
;
1006 memset(data
->context
, 0, sizeof(data
->context
));
1008 #ifndef CONFIG_NFS_V3
1009 /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
1010 error
= -EPROTONOSUPPORT
;
1011 if (data
->flags
& NFS_MOUNT_VER3
) {
1012 dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__
);
1013 goto out_err_noserver
;
1015 #endif /* CONFIG_NFS_V3 */
1018 server
= kzalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1020 goto out_err_noserver
;
1021 /* Zero out the NFS state stuff */
1022 init_nfsv4_state(server
);
1023 server
->client
= server
->client_sys
= server
->client_acl
= ERR_PTR(-EINVAL
);
1026 if (data
->flags
& NFS_MOUNT_VER3
)
1027 root
->size
= data
->root
.size
;
1029 root
->size
= NFS2_FHSIZE
;
1031 if (root
->size
> sizeof(root
->data
)) {
1032 dprintk("%s: invalid root filehandle\n", __FUNCTION__
);
1035 memcpy(root
->data
, data
->root
.data
, root
->size
);
1037 /* We now require that the mount process passes the remote address */
1038 memcpy(&server
->addr
, &data
->addr
, sizeof(server
->addr
));
1039 if (server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1040 dprintk("%s: mount program didn't pass remote address!\n",
1045 /* Fire up rpciod if not yet running */
1046 error
= rpciod_up();
1048 dprintk("%s: couldn't start rpciod! Error = %d\n",
1049 __FUNCTION__
, error
);
1053 s
= sget(fs_type
, nfs_compare_super
, nfs_set_super
, server
);
1056 goto out_err_rpciod
;
1060 goto out_rpciod_down
;
1064 error
= nfs_fill_super(s
, data
, flags
& MS_SILENT
? 1 : 0);
1066 up_write(&s
->s_umount
);
1067 deactivate_super(s
);
1070 s
->s_flags
|= MS_ACTIVE
;
1071 return simple_set_mnt(mnt
, s
);
1076 return simple_set_mnt(mnt
, s
);
1086 static void nfs_kill_super(struct super_block
*s
)
1088 struct nfs_server
*server
= NFS_SB(s
);
1092 if (!IS_ERR(server
->client
))
1093 rpc_shutdown_client(server
->client
);
1094 if (!IS_ERR(server
->client_sys
))
1095 rpc_shutdown_client(server
->client_sys
);
1096 if (!IS_ERR(server
->client_acl
))
1097 rpc_shutdown_client(server
->client_acl
);
1099 if (!(server
->flags
& NFS_MOUNT_NONLM
))
1100 lockd_down(); /* release rpc.lockd */
1102 rpciod_down(); /* release rpciod */
1104 nfs_free_iostats(server
->io_stats
);
1105 kfree(server
->hostname
);
1107 nfs_release_automount_timer();
1110 static struct super_block
*nfs_clone_sb(struct nfs_server
*server
, struct nfs_clone_mount
*data
)
1112 struct super_block
*sb
;
1114 server
->fsid
= data
->fattr
->fsid
;
1115 nfs_copy_fh(&server
->fh
, data
->fh
);
1116 sb
= sget(&nfs_fs_type
, nfs_compare_super
, nfs_set_super
, server
);
1117 if (!IS_ERR(sb
) && sb
->s_root
== NULL
&& !(server
->flags
& NFS_MOUNT_NONLM
))
1122 static int nfs_clone_nfs_sb(struct file_system_type
*fs_type
,
1123 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1125 struct nfs_clone_mount
*data
= raw_data
;
1126 return nfs_clone_generic_sb(data
, nfs_clone_sb
, nfs_clone_server
, mnt
);
1129 #ifdef CONFIG_NFS_V4
1130 static struct rpc_clnt
*nfs4_create_client(struct nfs_server
*server
,
1131 struct rpc_timeout
*timeparms
, int proto
, rpc_authflavor_t flavor
)
1133 struct nfs4_client
*clp
;
1134 struct rpc_xprt
*xprt
= NULL
;
1135 struct rpc_clnt
*clnt
= NULL
;
1138 clp
= nfs4_get_client(&server
->addr
.sin_addr
);
1140 dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__
);
1141 return ERR_PTR(err
);
1144 /* Now create transport and client */
1145 down_write(&clp
->cl_sem
);
1146 if (IS_ERR(clp
->cl_rpcclient
)) {
1147 xprt
= xprt_create_proto(proto
, &server
->addr
, timeparms
);
1149 up_write(&clp
->cl_sem
);
1150 err
= PTR_ERR(xprt
);
1151 dprintk("%s: cannot create RPC transport. Error = %d\n",
1155 /* Bind to a reserved port! */
1157 clnt
= rpc_create_client(xprt
, server
->hostname
, &nfs_program
,
1158 server
->rpc_ops
->version
, flavor
);
1160 up_write(&clp
->cl_sem
);
1161 err
= PTR_ERR(clnt
);
1162 dprintk("%s: cannot create RPC client. Error = %d\n",
1167 clnt
->cl_softrtry
= 1;
1168 clp
->cl_rpcclient
= clnt
;
1169 memcpy(clp
->cl_ipaddr
, server
->ip_addr
, sizeof(clp
->cl_ipaddr
));
1172 list_add_tail(&server
->nfs4_siblings
, &clp
->cl_superblocks
);
1173 clnt
= rpc_clone_client(clp
->cl_rpcclient
);
1175 server
->nfs4_state
= clp
;
1176 up_write(&clp
->cl_sem
);
1180 dprintk("%s: cannot create RPC client. Error = %d\n",
1185 if (server
->nfs4_state
->cl_idmap
== NULL
) {
1186 dprintk("%s: failed to create idmapper.\n", __FUNCTION__
);
1187 return ERR_PTR(-ENOMEM
);
1190 if (clnt
->cl_auth
->au_flavor
!= flavor
) {
1191 struct rpc_auth
*auth
;
1193 auth
= rpcauth_create(flavor
, clnt
);
1195 dprintk("%s: couldn't create credcache!\n", __FUNCTION__
);
1196 return (struct rpc_clnt
*)auth
;
1203 nfs4_put_client(clp
);
1204 return ERR_PTR(err
);
1208 * Set up an NFS4 superblock
1210 static int nfs4_fill_super(struct super_block
*sb
, struct nfs4_mount_data
*data
, int silent
)
1212 struct nfs_server
*server
;
1213 struct rpc_timeout timeparms
;
1214 rpc_authflavor_t authflavour
;
1217 sb
->s_blocksize_bits
= 0;
1218 sb
->s_blocksize
= 0;
1219 server
= NFS_SB(sb
);
1220 if (data
->rsize
!= 0)
1221 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
1222 if (data
->wsize
!= 0)
1223 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
1224 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
1225 server
->caps
= NFS_CAP_ATOMIC_OPEN
;
1227 server
->acregmin
= data
->acregmin
*HZ
;
1228 server
->acregmax
= data
->acregmax
*HZ
;
1229 server
->acdirmin
= data
->acdirmin
*HZ
;
1230 server
->acdirmax
= data
->acdirmax
*HZ
;
1232 server
->rpc_ops
= &nfs_v4_clientops
;
1234 nfs_init_timeout_values(&timeparms
, data
->proto
, data
->timeo
, data
->retrans
);
1236 server
->retrans_timeo
= timeparms
.to_initval
;
1237 server
->retrans_count
= timeparms
.to_retries
;
1239 /* Now create transport and client */
1240 authflavour
= RPC_AUTH_UNIX
;
1241 if (data
->auth_flavourlen
!= 0) {
1242 if (data
->auth_flavourlen
!= 1) {
1243 dprintk("%s: Invalid number of RPC auth flavours %d.\n",
1244 __FUNCTION__
, data
->auth_flavourlen
);
1248 if (copy_from_user(&authflavour
, data
->auth_flavours
, sizeof(authflavour
))) {
1254 server
->client
= nfs4_create_client(server
, &timeparms
, data
->proto
, authflavour
);
1255 if (IS_ERR(server
->client
)) {
1256 err
= PTR_ERR(server
->client
);
1257 dprintk("%s: cannot create RPC client. Error = %d\n",
1262 sb
->s_time_gran
= 1;
1264 sb
->s_op
= &nfs4_sops
;
1265 err
= nfs_sb_init(sb
, authflavour
);
1271 static int nfs4_compare_super(struct super_block
*sb
, void *data
)
1273 struct nfs_server
*server
= data
;
1274 struct nfs_server
*old
= NFS_SB(sb
);
1276 if (strcmp(server
->hostname
, old
->hostname
) != 0)
1278 if (strcmp(server
->mnt_path
, old
->mnt_path
) != 0)
1284 nfs_copy_user_string(char *dst
, struct nfs_string
*src
, int maxlen
)
1289 return ERR_PTR(-EINVAL
);
1290 if (src
->len
< maxlen
)
1293 p
= dst
= kmalloc(maxlen
+ 1, GFP_KERNEL
);
1295 return ERR_PTR(-ENOMEM
);
1297 if (copy_from_user(dst
, src
->data
, maxlen
)) {
1299 return ERR_PTR(-EFAULT
);
1305 static int nfs4_get_sb(struct file_system_type
*fs_type
,
1306 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1309 struct nfs_server
*server
;
1310 struct super_block
*s
;
1311 struct nfs4_mount_data
*data
= raw_data
;
1315 dprintk("%s: missing data argument\n", __FUNCTION__
);
1318 if (data
->version
<= 0 || data
->version
> NFS4_MOUNT_VERSION
) {
1319 dprintk("%s: bad mount version\n", __FUNCTION__
);
1323 server
= kzalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1326 /* Zero out the NFS state stuff */
1327 init_nfsv4_state(server
);
1328 server
->client
= server
->client_sys
= server
->client_acl
= ERR_PTR(-EINVAL
);
1330 p
= nfs_copy_user_string(NULL
, &data
->hostname
, 256);
1333 server
->hostname
= p
;
1335 p
= nfs_copy_user_string(NULL
, &data
->mnt_path
, 1024);
1338 server
->mnt_path
= p
;
1340 p
= nfs_copy_user_string(server
->ip_addr
, &data
->client_addr
,
1341 sizeof(server
->ip_addr
) - 1);
1345 /* We now require that the mount process passes the remote address */
1346 if (data
->host_addrlen
!= sizeof(server
->addr
)) {
1350 if (copy_from_user(&server
->addr
, data
->host_addr
, sizeof(server
->addr
))) {
1354 if (server
->addr
.sin_family
!= AF_INET
||
1355 server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1356 dprintk("%s: mount program didn't pass remote IP address!\n",
1362 /* Fire up rpciod if not yet running */
1363 error
= rpciod_up();
1365 dprintk("%s: couldn't start rpciod! Error = %d\n",
1366 __FUNCTION__
, error
);
1370 s
= sget(fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1378 kfree(server
->mnt_path
);
1379 kfree(server
->hostname
);
1381 return simple_set_mnt(mnt
, s
);
1386 error
= nfs4_fill_super(s
, data
, flags
& MS_SILENT
? 1 : 0);
1388 up_write(&s
->s_umount
);
1389 deactivate_super(s
);
1392 s
->s_flags
|= MS_ACTIVE
;
1393 return simple_set_mnt(mnt
, s
);
1397 kfree(server
->mnt_path
);
1398 kfree(server
->hostname
);
1403 static void nfs4_kill_super(struct super_block
*sb
)
1405 struct nfs_server
*server
= NFS_SB(sb
);
1407 nfs_return_all_delegations(sb
);
1408 kill_anon_super(sb
);
1410 nfs4_renewd_prepare_shutdown(server
);
1412 if (server
->client
!= NULL
&& !IS_ERR(server
->client
))
1413 rpc_shutdown_client(server
->client
);
1415 destroy_nfsv4_state(server
);
1419 nfs_free_iostats(server
->io_stats
);
1420 kfree(server
->hostname
);
1422 nfs_release_automount_timer();
1426 * Constructs the SERVER-side path
1428 static inline char *nfs4_dup_path(const struct dentry
*dentry
)
1430 char *page
= (char *) __get_free_page(GFP_USER
);
1433 path
= nfs4_path(dentry
, page
, PAGE_SIZE
);
1434 if (!IS_ERR(path
)) {
1435 int len
= PAGE_SIZE
+ page
- path
;
1438 path
= kmalloc(len
, GFP_KERNEL
);
1440 memcpy(path
, tmp
, len
);
1442 path
= ERR_PTR(-ENOMEM
);
1444 free_page((unsigned long)page
);
1448 static struct super_block
*nfs4_clone_sb(struct nfs_server
*server
, struct nfs_clone_mount
*data
)
1450 const struct dentry
*dentry
= data
->dentry
;
1451 struct nfs4_client
*clp
= server
->nfs4_state
;
1452 struct super_block
*sb
;
1454 server
->fsid
= data
->fattr
->fsid
;
1455 nfs_copy_fh(&server
->fh
, data
->fh
);
1456 server
->mnt_path
= nfs4_dup_path(dentry
);
1457 if (IS_ERR(server
->mnt_path
)) {
1458 sb
= (struct super_block
*)server
->mnt_path
;
1461 sb
= sget(&nfs4_fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1462 if (IS_ERR(sb
) || sb
->s_root
)
1464 nfs4_server_capabilities(server
, &server
->fh
);
1466 down_write(&clp
->cl_sem
);
1467 atomic_inc(&clp
->cl_count
);
1468 list_add_tail(&server
->nfs4_siblings
, &clp
->cl_superblocks
);
1469 up_write(&clp
->cl_sem
);
1472 kfree(server
->mnt_path
);
1474 server
->mnt_path
= NULL
;
1478 static int nfs_clone_nfs4_sb(struct file_system_type
*fs_type
,
1479 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1481 struct nfs_clone_mount
*data
= raw_data
;
1482 return nfs_clone_generic_sb(data
, nfs4_clone_sb
, nfs_clone_server
, mnt
);
1485 static struct super_block
*nfs4_referral_sb(struct nfs_server
*server
, struct nfs_clone_mount
*data
)
1487 struct super_block
*sb
= ERR_PTR(-ENOMEM
);
1490 len
= strlen(data
->mnt_path
) + 1;
1491 server
->mnt_path
= kmalloc(len
, GFP_KERNEL
);
1492 if (server
->mnt_path
== NULL
)
1494 memcpy(server
->mnt_path
, data
->mnt_path
, len
);
1495 memcpy(&server
->addr
, data
->addr
, sizeof(struct sockaddr_in
));
1497 sb
= sget(&nfs4_fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1498 if (IS_ERR(sb
) || sb
->s_root
)
1502 kfree(server
->mnt_path
);
1504 server
->mnt_path
= NULL
;
1508 static struct nfs_server
*nfs4_referral_server(struct super_block
*sb
, struct nfs_clone_mount
*data
)
1510 struct nfs_server
*server
= NFS_SB(sb
);
1511 struct rpc_timeout timeparms
;
1512 int proto
, timeo
, retrans
;
1515 proto
= IPPROTO_TCP
;
1516 /* Since we are following a referral and there may be alternatives,
1517 set the timeouts and retries to low values */
1520 nfs_init_timeout_values(&timeparms
, proto
, timeo
, retrans
);
1522 server
->client
= nfs4_create_client(server
, &timeparms
, proto
, data
->authflavor
);
1523 if (IS_ERR((err
= server
->client
)))
1526 sb
->s_time_gran
= 1;
1527 sb
->s_op
= &nfs4_sops
;
1528 err
= ERR_PTR(nfs_sb_init(sb
, data
->authflavor
));
1532 return (struct nfs_server
*)err
;
1535 static int nfs_referral_nfs4_sb(struct file_system_type
*fs_type
,
1536 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1538 struct nfs_clone_mount
*data
= raw_data
;
1539 return nfs_clone_generic_sb(data
, nfs4_referral_sb
, nfs4_referral_server
, mnt
);