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)
63 static void nfs_umount_begin(struct vfsmount
*, int);
64 static int nfs_statfs(struct dentry
*, struct kstatfs
*);
65 static int nfs_show_options(struct seq_file
*, struct vfsmount
*);
66 static int nfs_show_stats(struct seq_file
*, struct vfsmount
*);
67 static int nfs_get_sb(struct file_system_type
*, int, const char *, void *, struct vfsmount
*);
68 static int nfs_clone_nfs_sb(struct file_system_type
*fs_type
,
69 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
70 static void nfs_kill_super(struct super_block
*);
72 static struct file_system_type nfs_fs_type
= {
76 .kill_sb
= nfs_kill_super
,
77 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
80 struct file_system_type clone_nfs_fs_type
= {
83 .get_sb
= nfs_clone_nfs_sb
,
84 .kill_sb
= nfs_kill_super
,
85 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
88 static struct super_operations nfs_sops
= {
89 .alloc_inode
= nfs_alloc_inode
,
90 .destroy_inode
= nfs_destroy_inode
,
91 .write_inode
= nfs_write_inode
,
93 .clear_inode
= nfs_clear_inode
,
94 .umount_begin
= nfs_umount_begin
,
95 .show_options
= nfs_show_options
,
96 .show_stats
= nfs_show_stats
,
100 static int nfs4_get_sb(struct file_system_type
*fs_type
,
101 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
102 static int nfs_clone_nfs4_sb(struct file_system_type
*fs_type
,
103 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
104 static int nfs_referral_nfs4_sb(struct file_system_type
*fs_type
,
105 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
);
106 static void nfs4_kill_super(struct super_block
*sb
);
108 static struct file_system_type nfs4_fs_type
= {
109 .owner
= THIS_MODULE
,
111 .get_sb
= nfs4_get_sb
,
112 .kill_sb
= nfs4_kill_super
,
113 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
116 struct file_system_type clone_nfs4_fs_type
= {
117 .owner
= THIS_MODULE
,
119 .get_sb
= nfs_clone_nfs4_sb
,
120 .kill_sb
= nfs4_kill_super
,
121 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
124 struct file_system_type nfs_referral_nfs4_fs_type
= {
125 .owner
= THIS_MODULE
,
127 .get_sb
= nfs_referral_nfs4_sb
,
128 .kill_sb
= nfs4_kill_super
,
129 .fs_flags
= FS_ODD_RENAME
|FS_REVAL_DOT
|FS_BINARY_MOUNTDATA
,
132 static struct super_operations nfs4_sops
= {
133 .alloc_inode
= nfs_alloc_inode
,
134 .destroy_inode
= nfs_destroy_inode
,
135 .write_inode
= nfs_write_inode
,
136 .statfs
= nfs_statfs
,
137 .clear_inode
= nfs4_clear_inode
,
138 .umount_begin
= nfs_umount_begin
,
139 .show_options
= nfs_show_options
,
140 .show_stats
= nfs_show_stats
,
144 static struct shrinker
*acl_shrinker
;
147 * Register the NFS filesystems
149 int __init
register_nfs_fs(void)
153 ret
= register_filesystem(&nfs_fs_type
);
158 ret
= nfs_register_sysctl();
161 ret
= register_filesystem(&nfs4_fs_type
);
165 acl_shrinker
= set_shrinker(DEFAULT_SEEKS
, nfs_access_cache_shrinker
);
170 nfs_unregister_sysctl();
172 unregister_filesystem(&nfs_fs_type
);
179 * Unregister the NFS filesystems
181 void __exit
unregister_nfs_fs(void)
183 if (acl_shrinker
!= NULL
)
184 remove_shrinker(acl_shrinker
);
186 unregister_filesystem(&nfs4_fs_type
);
187 nfs_unregister_sysctl();
189 unregister_filesystem(&nfs_fs_type
);
193 * Deliver file system statistics to userspace
195 static int nfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
197 struct nfs_server
*server
= NFS_SB(dentry
->d_sb
);
198 unsigned char blockbits
;
199 unsigned long blockres
;
200 struct nfs_fh
*fh
= NFS_FH(dentry
->d_inode
);
201 struct nfs_fattr fattr
;
202 struct nfs_fsstat res
= {
209 error
= server
->nfs_client
->rpc_ops
->statfs(server
, fh
, &res
);
210 buf
->f_type
= NFS_SUPER_MAGIC
;
215 * Current versions of glibc do not correctly handle the
216 * case where f_frsize != f_bsize. Eventually we want to
217 * report the value of wtmult in this field.
219 buf
->f_frsize
= dentry
->d_sb
->s_blocksize
;
222 * On most *nix systems, f_blocks, f_bfree, and f_bavail
223 * are reported in units of f_frsize. Linux hasn't had
224 * an f_frsize field in its statfs struct until recently,
225 * thus historically Linux's sys_statfs reports these
226 * fields in units of f_bsize.
228 buf
->f_bsize
= dentry
->d_sb
->s_blocksize
;
229 blockbits
= dentry
->d_sb
->s_blocksize_bits
;
230 blockres
= (1 << blockbits
) - 1;
231 buf
->f_blocks
= (res
.tbytes
+ blockres
) >> blockbits
;
232 buf
->f_bfree
= (res
.fbytes
+ blockres
) >> blockbits
;
233 buf
->f_bavail
= (res
.abytes
+ blockres
) >> blockbits
;
235 buf
->f_files
= res
.tfiles
;
236 buf
->f_ffree
= res
.afiles
;
238 buf
->f_namelen
= server
->namelen
;
244 dprintk("%s: statfs error = %d\n", __FUNCTION__
, -error
);
245 buf
->f_bsize
= buf
->f_blocks
= buf
->f_bfree
= buf
->f_bavail
= -1;
251 * Map the security flavour number to a name
253 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour
)
255 static const struct {
256 rpc_authflavor_t flavour
;
259 { RPC_AUTH_NULL
, "null" },
260 { RPC_AUTH_UNIX
, "sys" },
261 { RPC_AUTH_GSS_KRB5
, "krb5" },
262 { RPC_AUTH_GSS_KRB5I
, "krb5i" },
263 { RPC_AUTH_GSS_KRB5P
, "krb5p" },
264 { RPC_AUTH_GSS_LKEY
, "lkey" },
265 { RPC_AUTH_GSS_LKEYI
, "lkeyi" },
266 { RPC_AUTH_GSS_LKEYP
, "lkeyp" },
267 { RPC_AUTH_GSS_SPKM
, "spkm" },
268 { RPC_AUTH_GSS_SPKMI
, "spkmi" },
269 { RPC_AUTH_GSS_SPKMP
, "spkmp" },
274 for (i
=0; sec_flavours
[i
].flavour
!= -1; i
++) {
275 if (sec_flavours
[i
].flavour
== flavour
)
278 return sec_flavours
[i
].str
;
282 * Describe the mount options in force on this server representation
284 static void nfs_show_mount_options(struct seq_file
*m
, struct nfs_server
*nfss
, int showdefaults
)
286 static const struct proc_nfs_info
{
291 { NFS_MOUNT_SOFT
, ",soft", ",hard" },
292 { NFS_MOUNT_INTR
, ",intr", "" },
293 { NFS_MOUNT_NOCTO
, ",nocto", "" },
294 { NFS_MOUNT_NOAC
, ",noac", "" },
295 { NFS_MOUNT_NONLM
, ",nolock", "" },
296 { NFS_MOUNT_NOACL
, ",noacl", "" },
299 const struct proc_nfs_info
*nfs_infop
;
300 struct nfs_client
*clp
= nfss
->nfs_client
;
304 seq_printf(m
, ",vers=%d", clp
->rpc_ops
->version
);
305 seq_printf(m
, ",rsize=%d", nfss
->rsize
);
306 seq_printf(m
, ",wsize=%d", nfss
->wsize
);
307 if (nfss
->acregmin
!= 3*HZ
|| showdefaults
)
308 seq_printf(m
, ",acregmin=%d", nfss
->acregmin
/HZ
);
309 if (nfss
->acregmax
!= 60*HZ
|| showdefaults
)
310 seq_printf(m
, ",acregmax=%d", nfss
->acregmax
/HZ
);
311 if (nfss
->acdirmin
!= 30*HZ
|| showdefaults
)
312 seq_printf(m
, ",acdirmin=%d", nfss
->acdirmin
/HZ
);
313 if (nfss
->acdirmax
!= 60*HZ
|| showdefaults
)
314 seq_printf(m
, ",acdirmax=%d", nfss
->acdirmax
/HZ
);
315 for (nfs_infop
= nfs_info
; nfs_infop
->flag
; nfs_infop
++) {
316 if (nfss
->flags
& nfs_infop
->flag
)
317 seq_puts(m
, nfs_infop
->str
);
319 seq_puts(m
, nfs_infop
->nostr
);
321 switch (nfss
->client
->cl_xprt
->prot
) {
329 snprintf(buf
, sizeof(buf
), "%u", nfss
->client
->cl_xprt
->prot
);
332 seq_printf(m
, ",proto=%s", proto
);
333 seq_printf(m
, ",timeo=%lu", 10U * clp
->retrans_timeo
/ HZ
);
334 seq_printf(m
, ",retrans=%u", clp
->retrans_count
);
335 seq_printf(m
, ",sec=%s", nfs_pseudoflavour_to_name(nfss
->client
->cl_auth
->au_flavor
));
339 * Describe the mount options on this VFS mountpoint
341 static int nfs_show_options(struct seq_file
*m
, struct vfsmount
*mnt
)
343 struct nfs_server
*nfss
= NFS_SB(mnt
->mnt_sb
);
345 nfs_show_mount_options(m
, nfss
, 0);
347 seq_puts(m
, ",addr=");
348 seq_escape(m
, nfss
->hostname
, " \t\n\\");
354 * Present statistical information for this VFS mountpoint
356 static int nfs_show_stats(struct seq_file
*m
, struct vfsmount
*mnt
)
359 struct nfs_server
*nfss
= NFS_SB(mnt
->mnt_sb
);
360 struct rpc_auth
*auth
= nfss
->client
->cl_auth
;
361 struct nfs_iostats totals
= { };
363 seq_printf(m
, "statvers=%s", NFS_IOSTAT_VERS
);
366 * Display all mount option settings
368 seq_printf(m
, "\n\topts:\t");
369 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_RDONLY
? "ro" : "rw");
370 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_SYNCHRONOUS
? ",sync" : "");
371 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_NOATIME
? ",noatime" : "");
372 seq_puts(m
, mnt
->mnt_sb
->s_flags
& MS_NODIRATIME
? ",nodiratime" : "");
373 nfs_show_mount_options(m
, nfss
, 1);
375 seq_printf(m
, "\n\tage:\t%lu", (jiffies
- nfss
->mount_time
) / HZ
);
377 seq_printf(m
, "\n\tcaps:\t");
378 seq_printf(m
, "caps=0x%x", nfss
->caps
);
379 seq_printf(m
, ",wtmult=%d", nfss
->wtmult
);
380 seq_printf(m
, ",dtsize=%d", nfss
->dtsize
);
381 seq_printf(m
, ",bsize=%d", nfss
->bsize
);
382 seq_printf(m
, ",namelen=%d", nfss
->namelen
);
385 if (nfss
->nfs_client
->cl_nfsversion
== 4) {
386 seq_printf(m
, "\n\tnfsv4:\t");
387 seq_printf(m
, "bm0=0x%x", nfss
->attr_bitmask
[0]);
388 seq_printf(m
, ",bm1=0x%x", nfss
->attr_bitmask
[1]);
389 seq_printf(m
, ",acl=0x%x", nfss
->acl_bitmask
);
394 * Display security flavor in effect for this mount
396 seq_printf(m
, "\n\tsec:\tflavor=%d", auth
->au_ops
->au_flavor
);
398 seq_printf(m
, ",pseudoflavor=%d", auth
->au_flavor
);
401 * Display superblock I/O counters
403 for_each_possible_cpu(cpu
) {
404 struct nfs_iostats
*stats
;
407 stats
= per_cpu_ptr(nfss
->io_stats
, cpu
);
409 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
410 totals
.events
[i
] += stats
->events
[i
];
411 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
412 totals
.bytes
[i
] += stats
->bytes
[i
];
417 seq_printf(m
, "\n\tevents:\t");
418 for (i
= 0; i
< __NFSIOS_COUNTSMAX
; i
++)
419 seq_printf(m
, "%lu ", totals
.events
[i
]);
420 seq_printf(m
, "\n\tbytes:\t");
421 for (i
= 0; i
< __NFSIOS_BYTESMAX
; i
++)
422 seq_printf(m
, "%Lu ", totals
.bytes
[i
]);
425 rpc_print_iostats(m
, nfss
->client
);
431 * Begin unmount by attempting to remove all automounted mountpoints we added
432 * in response to traversals
434 static void nfs_umount_begin(struct vfsmount
*vfsmnt
, int flags
)
436 struct nfs_server
*server
;
437 struct rpc_clnt
*rpc
;
439 shrink_submounts(vfsmnt
, &nfs_automount_list
);
440 if (!(flags
& MNT_FORCE
))
442 /* -EIO all pending I/O */
443 server
= NFS_SB(vfsmnt
->mnt_sb
);
444 rpc
= server
->client
;
446 rpc_killall_tasks(rpc
);
447 rpc
= server
->client_acl
;
449 rpc_killall_tasks(rpc
);
453 * Obtain the root inode of the file system.
455 static struct inode
*
456 nfs_get_root(struct super_block
*sb
, struct nfs_fh
*rootfh
, struct nfs_fsinfo
*fsinfo
)
458 struct nfs_server
*server
= NFS_SB(sb
);
461 error
= server
->nfs_client
->rpc_ops
->getroot(server
, rootfh
, fsinfo
);
463 dprintk("nfs_get_root: getattr error = %d\n", -error
);
464 return ERR_PTR(error
);
467 server
->fsid
= fsinfo
->fattr
->fsid
;
468 return nfs_fhget(sb
, rootfh
, fsinfo
->fattr
);
472 * Do NFS version-independent mount processing, and sanity checking
475 nfs_sb_init(struct super_block
*sb
, rpc_authflavor_t authflavor
)
477 struct nfs_server
*server
;
478 struct inode
*root_inode
;
479 struct nfs_fattr fattr
;
480 struct nfs_fsinfo fsinfo
= {
483 struct nfs_pathconf pathinfo
= {
486 int no_root_error
= 0;
487 unsigned long max_rpc_payload
;
489 /* We probably want something more informative here */
490 snprintf(sb
->s_id
, sizeof(sb
->s_id
), "%x:%x", MAJOR(sb
->s_dev
), MINOR(sb
->s_dev
));
494 sb
->s_magic
= NFS_SUPER_MAGIC
;
496 server
->io_stats
= nfs_alloc_iostats();
497 if (server
->io_stats
== NULL
)
500 root_inode
= nfs_get_root(sb
, &server
->fh
, &fsinfo
);
501 /* Did getting the root inode fail? */
502 if (IS_ERR(root_inode
)) {
503 no_root_error
= PTR_ERR(root_inode
);
506 sb
->s_root
= d_alloc_root(root_inode
);
508 no_root_error
= -ENOMEM
;
511 sb
->s_root
->d_op
= server
->nfs_client
->rpc_ops
->dentry_ops
;
513 /* mount time stamp, in seconds */
514 server
->mount_time
= jiffies
;
516 /* Get some general file system info */
517 if (server
->namelen
== 0 &&
518 server
->nfs_client
->rpc_ops
->pathconf(server
, &server
->fh
, &pathinfo
) >= 0)
519 server
->namelen
= pathinfo
.max_namelen
;
520 /* Work out a lot of parameters */
521 if (server
->rsize
== 0)
522 server
->rsize
= nfs_block_size(fsinfo
.rtpref
, NULL
);
523 if (server
->wsize
== 0)
524 server
->wsize
= nfs_block_size(fsinfo
.wtpref
, NULL
);
526 if (fsinfo
.rtmax
>= 512 && server
->rsize
> fsinfo
.rtmax
)
527 server
->rsize
= nfs_block_size(fsinfo
.rtmax
, NULL
);
528 if (fsinfo
.wtmax
>= 512 && server
->wsize
> fsinfo
.wtmax
)
529 server
->wsize
= nfs_block_size(fsinfo
.wtmax
, NULL
);
531 max_rpc_payload
= nfs_block_size(rpc_max_payload(server
->client
), NULL
);
532 if (server
->rsize
> max_rpc_payload
)
533 server
->rsize
= max_rpc_payload
;
534 if (server
->rsize
> NFS_MAX_FILE_IO_SIZE
)
535 server
->rsize
= NFS_MAX_FILE_IO_SIZE
;
536 server
->rpages
= (server
->rsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
538 if (server
->wsize
> max_rpc_payload
)
539 server
->wsize
= max_rpc_payload
;
540 if (server
->wsize
> NFS_MAX_FILE_IO_SIZE
)
541 server
->wsize
= NFS_MAX_FILE_IO_SIZE
;
542 server
->wpages
= (server
->wsize
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
544 if (sb
->s_blocksize
== 0)
545 sb
->s_blocksize
= nfs_block_bits(server
->wsize
,
546 &sb
->s_blocksize_bits
);
547 server
->wtmult
= nfs_block_bits(fsinfo
.wtmult
, NULL
);
549 server
->dtsize
= nfs_block_size(fsinfo
.dtpref
, NULL
);
550 if (server
->dtsize
> PAGE_CACHE_SIZE
)
551 server
->dtsize
= PAGE_CACHE_SIZE
;
552 if (server
->dtsize
> server
->rsize
)
553 server
->dtsize
= server
->rsize
;
555 if (server
->flags
& NFS_MOUNT_NOAC
) {
556 server
->acregmin
= server
->acregmax
= 0;
557 server
->acdirmin
= server
->acdirmax
= 0;
558 sb
->s_flags
|= MS_SYNCHRONOUS
;
560 server
->backing_dev_info
.ra_pages
= server
->rpages
* NFS_MAX_READAHEAD
;
562 nfs_super_set_maxbytes(sb
, fsinfo
.maxfilesize
);
564 server
->client
->cl_intr
= (server
->flags
& NFS_MOUNT_INTR
) ? 1 : 0;
565 server
->client
->cl_softrtry
= (server
->flags
& NFS_MOUNT_SOFT
) ? 1 : 0;
567 /* We're airborne Set socket buffersize */
568 rpc_setbufsize(server
->client
, server
->wsize
+ 100, server
->rsize
+ 100);
570 /* Yargs. It didn't work out. */
572 dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error
);
573 if (!IS_ERR(root_inode
))
575 return no_root_error
;
579 * Create an RPC client handle.
581 static struct rpc_clnt
*
582 nfs_create_client(struct nfs_server
*server
, const struct nfs_mount_data
*data
)
584 struct nfs_client
*clp
;
585 struct rpc_clnt
*clnt
;
586 int proto
= (data
->flags
& NFS_MOUNT_TCP
) ? IPPROTO_TCP
: IPPROTO_UDP
;
591 if (server
->flags
& NFS_MOUNT_VER3
)
595 clp
= nfs_get_client(server
->hostname
, &server
->addr
, nfsversion
);
597 dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__
);
598 return ERR_PTR(PTR_ERR(clp
));
601 if (clp
->cl_cons_state
== NFS_CS_INITING
) {
602 /* Check NFS protocol revision and initialize RPC op
603 * vector and file handle pool. */
605 if (nfsversion
== 3) {
606 clp
->rpc_ops
= &nfs_v3_clientops
;
607 server
->caps
|= NFS_CAP_READDIRPLUS
;
609 clp
->rpc_ops
= &nfs_v2_clientops
;
612 clp
->rpc_ops
= &nfs_v2_clientops
;
615 /* create transport and client */
616 err
= nfs_create_rpc_client(clp
, proto
, data
->timeo
,
617 data
->retrans
, RPC_AUTH_UNIX
);
619 goto client_init_error
;
621 nfs_mark_client_ready(clp
, 0);
624 /* create an nfs_server-specific client */
625 clnt
= rpc_clone_client(clp
->cl_rpcclient
);
627 dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__
);
629 return ERR_PTR(PTR_ERR(clnt
));
632 if (data
->pseudoflavor
!= clp
->cl_rpcclient
->cl_auth
->au_flavor
) {
633 struct rpc_auth
*auth
;
635 auth
= rpcauth_create(data
->pseudoflavor
, server
->client
);
637 dprintk("%s: couldn't create credcache!\n", __FUNCTION__
);
638 return ERR_PTR(PTR_ERR(auth
));
642 server
->nfs_client
= clp
;
646 nfs_mark_client_ready(clp
, err
);
652 * Clone a server record
654 static struct nfs_server
*nfs_clone_server(struct super_block
*sb
, struct nfs_clone_mount
*data
)
656 struct nfs_server
*server
= NFS_SB(sb
);
657 struct nfs_server
*parent
= NFS_SB(data
->sb
);
658 struct inode
*root_inode
;
659 struct nfs_fsinfo fsinfo
;
660 void *err
= ERR_PTR(-ENOMEM
);
662 sb
->s_op
= data
->sb
->s_op
;
663 sb
->s_blocksize
= data
->sb
->s_blocksize
;
664 sb
->s_blocksize_bits
= data
->sb
->s_blocksize_bits
;
665 sb
->s_maxbytes
= data
->sb
->s_maxbytes
;
667 server
->client_acl
= ERR_PTR(-EINVAL
);
668 server
->io_stats
= nfs_alloc_iostats();
669 if (server
->io_stats
== NULL
)
672 server
->client
= rpc_clone_client(parent
->client
);
673 if (IS_ERR((err
= server
->client
)))
676 if (!IS_ERR(parent
->client_acl
)) {
677 server
->client_acl
= rpc_clone_client(parent
->client_acl
);
678 if (IS_ERR((err
= server
->client_acl
)))
681 root_inode
= nfs_fhget(sb
, data
->fh
, data
->fattr
);
684 sb
->s_root
= d_alloc_root(root_inode
);
687 fsinfo
.fattr
= data
->fattr
;
688 if (NFS_PROTO(root_inode
)->fsinfo(server
, data
->fh
, &fsinfo
) == 0)
689 nfs_super_set_maxbytes(sb
, fsinfo
.maxfilesize
);
690 sb
->s_root
->d_op
= server
->nfs_client
->rpc_ops
->dentry_ops
;
691 sb
->s_flags
|= MS_ACTIVE
;
700 * Copy an existing superblock and attach revised data
702 static int nfs_clone_generic_sb(struct nfs_clone_mount
*data
,
703 struct super_block
*(*fill_sb
)(struct nfs_server
*, struct nfs_clone_mount
*),
704 struct nfs_server
*(*fill_server
)(struct super_block
*, struct nfs_clone_mount
*),
705 struct vfsmount
*mnt
)
707 struct nfs_server
*server
;
708 struct nfs_server
*parent
= NFS_SB(data
->sb
);
709 struct super_block
*sb
= ERR_PTR(-EINVAL
);
714 server
= kmalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
717 memcpy(server
, parent
, sizeof(*server
));
718 atomic_inc(&server
->nfs_client
->cl_count
);
719 hostname
= (data
->hostname
!= NULL
) ? data
->hostname
: parent
->hostname
;
720 len
= strlen(hostname
) + 1;
721 server
->hostname
= kmalloc(len
, GFP_KERNEL
);
722 if (server
->hostname
== NULL
)
724 memcpy(server
->hostname
, hostname
, len
);
729 sb
= fill_sb(server
, data
);
736 goto out_rpciod_down
;
738 server
= fill_server(sb
, data
);
739 if (IS_ERR(server
)) {
740 error
= PTR_ERR(server
);
743 return simple_set_mnt(mnt
, sb
);
745 up_write(&sb
->s_umount
);
746 deactivate_super(sb
);
750 kfree(server
->hostname
);
751 nfs_put_client(server
->nfs_client
);
753 return simple_set_mnt(mnt
, sb
);
757 kfree(server
->hostname
);
759 nfs_put_client(server
->nfs_client
);
766 * Set up an NFS2/3 superblock
768 * The way this works is that the mount process passes a structure
769 * in the data argument which contains the server's IP address
770 * and the root file handle obtained from the server's mount
771 * daemon. We stash these away in the private superblock fields.
774 nfs_fill_super(struct super_block
*sb
, struct nfs_mount_data
*data
, int silent
)
776 struct nfs_server
*server
;
777 rpc_authflavor_t authflavor
;
780 sb
->s_blocksize_bits
= 0;
783 sb
->s_blocksize
= nfs_block_size(data
->bsize
, &sb
->s_blocksize_bits
);
785 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
787 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
788 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
790 server
->acregmin
= data
->acregmin
*HZ
;
791 server
->acregmax
= data
->acregmax
*HZ
;
792 server
->acdirmin
= data
->acdirmin
*HZ
;
793 server
->acdirmax
= data
->acdirmax
*HZ
;
795 /* Start lockd here, before we might error out */
796 if (!(server
->flags
& NFS_MOUNT_NONLM
))
799 server
->namelen
= data
->namlen
;
800 server
->hostname
= kmalloc(strlen(data
->hostname
) + 1, GFP_KERNEL
);
801 if (!server
->hostname
)
803 strcpy(server
->hostname
, data
->hostname
);
805 /* Fill in pseudoflavor for mount version < 5 */
806 if (!(data
->flags
& NFS_MOUNT_SECFLAVOUR
))
807 data
->pseudoflavor
= RPC_AUTH_UNIX
;
808 authflavor
= data
->pseudoflavor
; /* save for sb_init() */
809 /* XXX maybe we want to add a server->pseudoflavor field */
811 /* Create RPC client handles */
812 server
->client
= nfs_create_client(server
, data
);
813 if (IS_ERR(server
->client
))
814 return PTR_ERR(server
->client
);
816 /* RFC 2623, sec 2.3.2 */
817 if (server
->flags
& NFS_MOUNT_VER3
) {
818 #ifdef CONFIG_NFS_V3_ACL
819 if (!(server
->flags
& NFS_MOUNT_NOACL
)) {
820 server
->client_acl
= rpc_bind_new_program(server
->client
, &nfsacl_program
, 3);
821 /* No errors! Assume that Sun nfsacls are supported */
822 if (!IS_ERR(server
->client_acl
))
823 server
->caps
|= NFS_CAP_ACLS
;
826 server
->flags
&= ~NFS_MOUNT_NOACL
;
827 #endif /* CONFIG_NFS_V3_ACL */
829 * The VFS shouldn't apply the umask to mode bits. We will
830 * do so ourselves when necessary.
832 sb
->s_flags
|= MS_POSIXACL
;
833 if (server
->namelen
== 0 || server
->namelen
> NFS3_MAXNAMLEN
)
834 server
->namelen
= NFS3_MAXNAMLEN
;
837 if (server
->namelen
== 0 || server
->namelen
> NFS2_MAXNAMLEN
)
838 server
->namelen
= NFS2_MAXNAMLEN
;
841 sb
->s_op
= &nfs_sops
;
842 return nfs_sb_init(sb
, authflavor
);
845 static int nfs_set_super(struct super_block
*s
, void *data
)
848 return set_anon_super(s
, data
);
851 static int nfs_compare_super(struct super_block
*sb
, void *data
)
853 struct nfs_server
*server
= data
;
854 struct nfs_server
*old
= NFS_SB(sb
);
856 if (old
->addr
.sin_addr
.s_addr
!= server
->addr
.sin_addr
.s_addr
)
858 if (old
->addr
.sin_port
!= server
->addr
.sin_port
)
860 return !nfs_compare_fh(&old
->fh
, &server
->fh
);
863 static int nfs_get_sb(struct file_system_type
*fs_type
,
864 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
867 struct nfs_server
*server
= NULL
;
868 struct super_block
*s
;
870 struct nfs_mount_data
*data
= raw_data
;
874 dprintk("%s: missing data argument\n", __FUNCTION__
);
875 goto out_err_noserver
;
877 if (data
->version
<= 0 || data
->version
> NFS_MOUNT_VERSION
) {
878 dprintk("%s: bad mount version\n", __FUNCTION__
);
879 goto out_err_noserver
;
881 switch (data
->version
) {
887 if (data
->flags
& NFS_MOUNT_VER3
) {
888 dprintk("%s: mount structure version %d does not support NFSv3\n",
891 goto out_err_noserver
;
893 data
->root
.size
= NFS2_FHSIZE
;
894 memcpy(data
->root
.data
, data
->old_root
.data
, NFS2_FHSIZE
);
896 if (data
->flags
& NFS_MOUNT_SECFLAVOUR
) {
897 dprintk("%s: mount structure version %d does not support strong security\n",
900 goto out_err_noserver
;
903 memset(data
->context
, 0, sizeof(data
->context
));
905 #ifndef CONFIG_NFS_V3
906 /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
907 error
= -EPROTONOSUPPORT
;
908 if (data
->flags
& NFS_MOUNT_VER3
) {
909 dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__
);
910 goto out_err_noserver
;
912 #endif /* CONFIG_NFS_V3 */
915 server
= kzalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
917 goto out_err_noserver
;
918 /* Zero out the NFS state stuff */
919 init_nfsv4_state(server
);
920 server
->client
= server
->client_acl
= ERR_PTR(-EINVAL
);
923 if (data
->flags
& NFS_MOUNT_VER3
)
924 root
->size
= data
->root
.size
;
926 root
->size
= NFS2_FHSIZE
;
928 if (root
->size
> sizeof(root
->data
)) {
929 dprintk("%s: invalid root filehandle\n", __FUNCTION__
);
932 memcpy(root
->data
, data
->root
.data
, root
->size
);
934 /* We now require that the mount process passes the remote address */
935 memcpy(&server
->addr
, &data
->addr
, sizeof(server
->addr
));
936 if (server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
937 dprintk("%s: mount program didn't pass remote address!\n",
942 /* Fire up rpciod if not yet running */
945 dprintk("%s: couldn't start rpciod! Error = %d\n",
946 __FUNCTION__
, error
);
950 s
= sget(fs_type
, nfs_compare_super
, nfs_set_super
, server
);
957 goto out_rpciod_down
;
961 error
= nfs_fill_super(s
, data
, flags
& MS_SILENT
? 1 : 0);
963 up_write(&s
->s_umount
);
967 s
->s_flags
|= MS_ACTIVE
;
968 return simple_set_mnt(mnt
, s
);
973 return simple_set_mnt(mnt
, s
);
983 static void nfs_kill_super(struct super_block
*s
)
985 struct nfs_server
*server
= NFS_SB(s
);
989 if (!IS_ERR(server
->client
))
990 rpc_shutdown_client(server
->client
);
991 if (!IS_ERR(server
->client_acl
))
992 rpc_shutdown_client(server
->client_acl
);
994 if (!(server
->flags
& NFS_MOUNT_NONLM
))
995 lockd_down(); /* release rpc.lockd */
997 rpciod_down(); /* release rpciod */
999 nfs_free_iostats(server
->io_stats
);
1000 kfree(server
->hostname
);
1001 nfs_put_client(server
->nfs_client
);
1003 nfs_release_automount_timer();
1006 static struct super_block
*nfs_clone_sb(struct nfs_server
*server
, struct nfs_clone_mount
*data
)
1008 struct super_block
*sb
;
1010 server
->fsid
= data
->fattr
->fsid
;
1011 nfs_copy_fh(&server
->fh
, data
->fh
);
1012 sb
= sget(&nfs_fs_type
, nfs_compare_super
, nfs_set_super
, server
);
1013 if (!IS_ERR(sb
) && sb
->s_root
== NULL
&& !(server
->flags
& NFS_MOUNT_NONLM
))
1018 static int nfs_clone_nfs_sb(struct file_system_type
*fs_type
,
1019 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1021 struct nfs_clone_mount
*data
= raw_data
;
1022 return nfs_clone_generic_sb(data
, nfs_clone_sb
, nfs_clone_server
, mnt
);
1025 #ifdef CONFIG_NFS_V4
1026 static struct rpc_clnt
*nfs4_create_client(struct nfs_server
*server
,
1027 int timeo
, int retrans
, int proto
, rpc_authflavor_t flavor
)
1029 struct nfs_client
*clp
;
1030 struct rpc_clnt
*clnt
= NULL
;
1033 clp
= nfs_get_client(server
->hostname
, &server
->addr
, 4);
1035 dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__
);
1036 return ERR_PTR(err
);
1039 /* Now create transport and client */
1040 if (clp
->cl_cons_state
== NFS_CS_INITING
) {
1041 clp
->rpc_ops
= &nfs_v4_clientops
;
1043 err
= nfs_create_rpc_client(clp
, proto
, timeo
, retrans
, flavor
);
1045 goto client_init_error
;
1047 memcpy(clp
->cl_ipaddr
, server
->ip_addr
, sizeof(clp
->cl_ipaddr
));
1048 err
= nfs_idmap_new(clp
);
1050 dprintk("%s: failed to create idmapper.\n",
1052 goto client_init_error
;
1054 __set_bit(NFS_CS_IDMAP
, &clp
->cl_res_state
);
1055 nfs_mark_client_ready(clp
, 0);
1058 clnt
= rpc_clone_client(clp
->cl_rpcclient
);
1061 dprintk("%s: cannot create RPC client. Error = %d\n",
1066 if (clnt
->cl_auth
->au_flavor
!= flavor
) {
1067 struct rpc_auth
*auth
;
1069 auth
= rpcauth_create(flavor
, clnt
);
1071 dprintk("%s: couldn't create credcache!\n", __FUNCTION__
);
1072 return (struct rpc_clnt
*)auth
;
1076 server
->nfs_client
= clp
;
1077 down_write(&clp
->cl_sem
);
1078 list_add_tail(&server
->nfs4_siblings
, &clp
->cl_superblocks
);
1079 up_write(&clp
->cl_sem
);
1083 nfs_mark_client_ready(clp
, err
);
1084 nfs_put_client(clp
);
1085 return ERR_PTR(err
);
1089 * Set up an NFS4 superblock
1091 static int nfs4_fill_super(struct super_block
*sb
, struct nfs4_mount_data
*data
, int silent
)
1093 struct nfs_server
*server
;
1094 rpc_authflavor_t authflavour
;
1097 sb
->s_blocksize_bits
= 0;
1098 sb
->s_blocksize
= 0;
1099 server
= NFS_SB(sb
);
1100 if (data
->rsize
!= 0)
1101 server
->rsize
= nfs_block_size(data
->rsize
, NULL
);
1102 if (data
->wsize
!= 0)
1103 server
->wsize
= nfs_block_size(data
->wsize
, NULL
);
1104 server
->flags
= data
->flags
& NFS_MOUNT_FLAGMASK
;
1105 server
->caps
= NFS_CAP_ATOMIC_OPEN
;
1107 server
->acregmin
= data
->acregmin
*HZ
;
1108 server
->acregmax
= data
->acregmax
*HZ
;
1109 server
->acdirmin
= data
->acdirmin
*HZ
;
1110 server
->acdirmax
= data
->acdirmax
*HZ
;
1112 /* Now create transport and client */
1113 authflavour
= RPC_AUTH_UNIX
;
1114 if (data
->auth_flavourlen
!= 0) {
1115 if (data
->auth_flavourlen
!= 1) {
1116 dprintk("%s: Invalid number of RPC auth flavours %d.\n",
1117 __FUNCTION__
, data
->auth_flavourlen
);
1121 if (copy_from_user(&authflavour
, data
->auth_flavours
, sizeof(authflavour
))) {
1127 server
->client
= nfs4_create_client(server
, data
->timeo
, data
->retrans
,
1128 data
->proto
, authflavour
);
1129 if (IS_ERR(server
->client
)) {
1130 err
= PTR_ERR(server
->client
);
1131 dprintk("%s: cannot create RPC client. Error = %d\n",
1136 sb
->s_time_gran
= 1;
1138 sb
->s_op
= &nfs4_sops
;
1139 err
= nfs_sb_init(sb
, authflavour
);
1145 static int nfs4_compare_super(struct super_block
*sb
, void *data
)
1147 struct nfs_server
*server
= data
;
1148 struct nfs_server
*old
= NFS_SB(sb
);
1150 if (strcmp(server
->hostname
, old
->hostname
) != 0)
1152 if (strcmp(server
->mnt_path
, old
->mnt_path
) != 0)
1158 nfs_copy_user_string(char *dst
, struct nfs_string
*src
, int maxlen
)
1163 return ERR_PTR(-EINVAL
);
1164 if (src
->len
< maxlen
)
1167 p
= dst
= kmalloc(maxlen
+ 1, GFP_KERNEL
);
1169 return ERR_PTR(-ENOMEM
);
1171 if (copy_from_user(dst
, src
->data
, maxlen
)) {
1173 return ERR_PTR(-EFAULT
);
1179 static int nfs4_get_sb(struct file_system_type
*fs_type
,
1180 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1183 struct nfs_server
*server
;
1184 struct super_block
*s
;
1185 struct nfs4_mount_data
*data
= raw_data
;
1189 dprintk("%s: missing data argument\n", __FUNCTION__
);
1192 if (data
->version
<= 0 || data
->version
> NFS4_MOUNT_VERSION
) {
1193 dprintk("%s: bad mount version\n", __FUNCTION__
);
1197 server
= kzalloc(sizeof(struct nfs_server
), GFP_KERNEL
);
1200 /* Zero out the NFS state stuff */
1201 init_nfsv4_state(server
);
1202 server
->client
= server
->client_acl
= ERR_PTR(-EINVAL
);
1204 p
= nfs_copy_user_string(NULL
, &data
->hostname
, 256);
1207 server
->hostname
= p
;
1209 p
= nfs_copy_user_string(NULL
, &data
->mnt_path
, 1024);
1212 server
->mnt_path
= p
;
1214 p
= nfs_copy_user_string(server
->ip_addr
, &data
->client_addr
,
1215 sizeof(server
->ip_addr
) - 1);
1219 /* We now require that the mount process passes the remote address */
1220 if (data
->host_addrlen
!= sizeof(server
->addr
)) {
1224 if (copy_from_user(&server
->addr
, data
->host_addr
, sizeof(server
->addr
))) {
1228 if (server
->addr
.sin_family
!= AF_INET
||
1229 server
->addr
.sin_addr
.s_addr
== INADDR_ANY
) {
1230 dprintk("%s: mount program didn't pass remote IP address!\n",
1236 s
= sget(fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1243 kfree(server
->mnt_path
);
1244 kfree(server
->hostname
);
1246 return simple_set_mnt(mnt
, s
);
1251 error
= nfs4_fill_super(s
, data
, flags
& MS_SILENT
? 1 : 0);
1253 up_write(&s
->s_umount
);
1254 deactivate_super(s
);
1257 s
->s_flags
|= MS_ACTIVE
;
1258 return simple_set_mnt(mnt
, s
);
1262 kfree(server
->mnt_path
);
1263 kfree(server
->hostname
);
1268 static void nfs4_kill_super(struct super_block
*sb
)
1270 struct nfs_server
*server
= NFS_SB(sb
);
1272 nfs_return_all_delegations(sb
);
1273 kill_anon_super(sb
);
1275 nfs4_renewd_prepare_shutdown(server
);
1277 if (server
->client
!= NULL
&& !IS_ERR(server
->client
))
1278 rpc_shutdown_client(server
->client
);
1280 destroy_nfsv4_state(server
);
1282 nfs_free_iostats(server
->io_stats
);
1283 kfree(server
->hostname
);
1285 nfs_release_automount_timer();
1289 * Constructs the SERVER-side path
1291 static inline char *nfs4_dup_path(const struct dentry
*dentry
)
1293 char *page
= (char *) __get_free_page(GFP_USER
);
1296 path
= nfs4_path(dentry
, page
, PAGE_SIZE
);
1297 if (!IS_ERR(path
)) {
1298 int len
= PAGE_SIZE
+ page
- path
;
1301 path
= kmalloc(len
, GFP_KERNEL
);
1303 memcpy(path
, tmp
, len
);
1305 path
= ERR_PTR(-ENOMEM
);
1307 free_page((unsigned long)page
);
1311 static struct super_block
*nfs4_clone_sb(struct nfs_server
*server
, struct nfs_clone_mount
*data
)
1313 const struct dentry
*dentry
= data
->dentry
;
1314 struct nfs_client
*clp
= server
->nfs_client
;
1315 struct super_block
*sb
;
1317 server
->fsid
= data
->fattr
->fsid
;
1318 nfs_copy_fh(&server
->fh
, data
->fh
);
1319 server
->mnt_path
= nfs4_dup_path(dentry
);
1320 if (IS_ERR(server
->mnt_path
)) {
1321 sb
= (struct super_block
*)server
->mnt_path
;
1324 sb
= sget(&nfs4_fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1325 if (IS_ERR(sb
) || sb
->s_root
)
1327 nfs4_server_capabilities(server
, &server
->fh
);
1329 down_write(&clp
->cl_sem
);
1330 list_add_tail(&server
->nfs4_siblings
, &clp
->cl_superblocks
);
1331 up_write(&clp
->cl_sem
);
1334 kfree(server
->mnt_path
);
1336 server
->mnt_path
= NULL
;
1340 static int nfs_clone_nfs4_sb(struct file_system_type
*fs_type
,
1341 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1343 struct nfs_clone_mount
*data
= raw_data
;
1344 return nfs_clone_generic_sb(data
, nfs4_clone_sb
, nfs_clone_server
, mnt
);
1347 static struct super_block
*nfs4_referral_sb(struct nfs_server
*server
, struct nfs_clone_mount
*data
)
1349 struct super_block
*sb
= ERR_PTR(-ENOMEM
);
1352 len
= strlen(data
->mnt_path
) + 1;
1353 server
->mnt_path
= kmalloc(len
, GFP_KERNEL
);
1354 if (server
->mnt_path
== NULL
)
1356 memcpy(server
->mnt_path
, data
->mnt_path
, len
);
1357 memcpy(&server
->addr
, data
->addr
, sizeof(struct sockaddr_in
));
1359 sb
= sget(&nfs4_fs_type
, nfs4_compare_super
, nfs_set_super
, server
);
1360 if (IS_ERR(sb
) || sb
->s_root
)
1364 kfree(server
->mnt_path
);
1366 server
->mnt_path
= NULL
;
1370 static struct nfs_server
*nfs4_referral_server(struct super_block
*sb
, struct nfs_clone_mount
*data
)
1372 struct nfs_server
*server
= NFS_SB(sb
);
1373 int proto
, timeo
, retrans
;
1376 proto
= IPPROTO_TCP
;
1377 /* Since we are following a referral and there may be alternatives,
1378 set the timeouts and retries to low values */
1382 nfs_put_client(server
->nfs_client
);
1383 server
->nfs_client
= NULL
;
1384 server
->client
= nfs4_create_client(server
, timeo
, retrans
, proto
,
1386 if (IS_ERR((err
= server
->client
)))
1389 sb
->s_time_gran
= 1;
1390 sb
->s_op
= &nfs4_sops
;
1391 err
= ERR_PTR(nfs_sb_init(sb
, data
->authflavor
));
1395 return (struct nfs_server
*)err
;
1398 static int nfs_referral_nfs4_sb(struct file_system_type
*fs_type
,
1399 int flags
, const char *dev_name
, void *raw_data
, struct vfsmount
*mnt
)
1401 struct nfs_clone_mount
*data
= raw_data
;
1402 return nfs_clone_generic_sb(data
, nfs4_referral_sb
, nfs4_referral_server
, mnt
);