projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFS: Ensure that NFS version 4 mounts use NFS_PORT if nfsport wasn't set
[deliverable/linux.git] / fs / nfs / super.c
CommitLineData
f7b422b1
DH		 1/*
2 * linux/fs/nfs/super.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs superblock handling functions
7 *
8 * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
9 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
10 *
11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12 * J.S.Peatfield@damtp.cam.ac.uk
13 *
14 * Split from inode.c by David Howells <dhowells@redhat.com>
15 *
54ceac45
DH		 16 * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
17 * particular server are held in the same superblock
18 * - NFS superblocks can have several effective roots to the dentry tree
19 * - directory type roots are spliced into the tree when a path from one root reaches the root
20 * of another (see nfs_lookup())
f7b422b1
DH		 21 */
22
f7b422b1
DH		 23#include <linux/module.h>
24#include <linux/init.h>
25
26#include <linux/time.h>
27#include <linux/kernel.h>
28#include <linux/mm.h>
29#include <linux/string.h>
30#include <linux/stat.h>
31#include <linux/errno.h>
32#include <linux/unistd.h>
33#include <linux/sunrpc/clnt.h>
34#include <linux/sunrpc/stats.h>
35#include <linux/sunrpc/metrics.h>
0896a725 36#include <linux/sunrpc/xprtsock.h>
2cf7ff7a 37#include <linux/sunrpc/xprtrdma.h>
f7b422b1
DH		 38#include <linux/nfs_fs.h>
39#include <linux/nfs_mount.h>
40#include <linux/nfs4_mount.h>
41#include <linux/lockd/bind.h>
42#include <linux/smp_lock.h>
43#include <linux/seq_file.h>
44#include <linux/mount.h>
45#include <linux/nfs_idmap.h>
46#include <linux/vfs.h>
47#include <linux/inet.h>
48#include <linux/nfs_xdr.h>
b5d5dfbd 49#include <linux/magic.h>
bf0fd768 50#include <linux/parser.h>
f7b422b1
DH		 51
52#include <asm/system.h>
53#include <asm/uaccess.h>
54
55#include "nfs4_fs.h"
56#include "callback.h"
57#include "delegation.h"
58#include "iostat.h"
59#include "internal.h"
60
61#define NFSDBG_FACILITY NFSDBG_VFS
62
bf0fd768
CL		 63enum {
64 /* Mount options that take no arguments */
65 Opt_soft, Opt_hard,
66 Opt_intr, Opt_nointr,
67 Opt_posix, Opt_noposix,
68 Opt_cto, Opt_nocto,
69 Opt_ac, Opt_noac,
70 Opt_lock, Opt_nolock,
71 Opt_v2, Opt_v3,
2cf7ff7a 72 Opt_udp, Opt_tcp, Opt_rdma,
bf0fd768
CL		 73 Opt_acl, Opt_noacl,
74 Opt_rdirplus, Opt_nordirplus,
75180df2 75 Opt_sharecache, Opt_nosharecache,
bf0fd768
CL		 76
77 /* Mount options that take integer arguments */
78 Opt_port,
79 Opt_rsize, Opt_wsize, Opt_bsize,
80 Opt_timeo, Opt_retrans,
81 Opt_acregmin, Opt_acregmax,
82 Opt_acdirmin, Opt_acdirmax,
83 Opt_actimeo,
84 Opt_namelen,
85 Opt_mountport,
86 Opt_mountprog, Opt_mountvers,
87 Opt_nfsprog, Opt_nfsvers,
88
89 /* Mount options that take string arguments */
90 Opt_sec, Opt_proto, Opt_mountproto,
0ac83779 91 Opt_addr, Opt_mountaddr, Opt_clientaddr,
bf0fd768
CL		 92
93 /* Mount options that are ignored */
94 Opt_userspace, Opt_deprecated,
95
96 Opt_err
97};
98
99static match_table_t nfs_mount_option_tokens = {
100 { Opt_userspace, "bg" },
101 { Opt_userspace, "fg" },
102 { Opt_soft, "soft" },
103 { Opt_hard, "hard" },
104 { Opt_intr, "intr" },
105 { Opt_nointr, "nointr" },
106 { Opt_posix, "posix" },
107 { Opt_noposix, "noposix" },
108 { Opt_cto, "cto" },
109 { Opt_nocto, "nocto" },
110 { Opt_ac, "ac" },
111 { Opt_noac, "noac" },
112 { Opt_lock, "lock" },
113 { Opt_nolock, "nolock" },
114 { Opt_v2, "v2" },
115 { Opt_v3, "v3" },
116 { Opt_udp, "udp" },
117 { Opt_tcp, "tcp" },
2cf7ff7a 118 { Opt_rdma, "rdma" },
bf0fd768
CL		 119 { Opt_acl, "acl" },
120 { Opt_noacl, "noacl" },
121 { Opt_rdirplus, "rdirplus" },
122 { Opt_nordirplus, "nordirplus" },
75180df2
TM		 123 { Opt_sharecache, "sharecache" },
124 { Opt_nosharecache, "nosharecache" },
bf0fd768
CL		 125
126 { Opt_port, "port=%u" },
127 { Opt_rsize, "rsize=%u" },
128 { Opt_wsize, "wsize=%u" },
129 { Opt_bsize, "bsize=%u" },
130 { Opt_timeo, "timeo=%u" },
131 { Opt_retrans, "retrans=%u" },
132 { Opt_acregmin, "acregmin=%u" },
133 { Opt_acregmax, "acregmax=%u" },
134 { Opt_acdirmin, "acdirmin=%u" },
135 { Opt_acdirmax, "acdirmax=%u" },
136 { Opt_actimeo, "actimeo=%u" },
137 { Opt_userspace, "retry=%u" },
138 { Opt_namelen, "namlen=%u" },
139 { Opt_mountport, "mountport=%u" },
140 { Opt_mountprog, "mountprog=%u" },
141 { Opt_mountvers, "mountvers=%u" },
142 { Opt_nfsprog, "nfsprog=%u" },
143 { Opt_nfsvers, "nfsvers=%u" },
144 { Opt_nfsvers, "vers=%u" },
145
146 { Opt_sec, "sec=%s" },
147 { Opt_proto, "proto=%s" },
148 { Opt_mountproto, "mountproto=%s" },
149 { Opt_addr, "addr=%s" },
150 { Opt_clientaddr, "clientaddr=%s" },
0ac83779
CL		 151 { Opt_userspace, "mounthost=%s" },
152 { Opt_mountaddr, "mountaddr=%s" },
bf0fd768
CL		 153
154 { Opt_err, NULL }
155};
156
157enum {
2cf7ff7a 158 Opt_xprt_udp, Opt_xprt_tcp, Opt_xprt_rdma,
bf0fd768
CL		 159
160 Opt_xprt_err
161};
162
163static match_table_t nfs_xprt_protocol_tokens = {
164 { Opt_xprt_udp, "udp" },
165 { Opt_xprt_tcp, "tcp" },
2cf7ff7a 166 { Opt_xprt_rdma, "rdma" },
bf0fd768
CL		 167
168 { Opt_xprt_err, NULL }
169};
170
171enum {
172 Opt_sec_none, Opt_sec_sys,
173 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
174 Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
175 Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
176
177 Opt_sec_err
178};
179
180static match_table_t nfs_secflavor_tokens = {
181 { Opt_sec_none, "none" },
182 { Opt_sec_none, "null" },
183 { Opt_sec_sys, "sys" },
184
185 { Opt_sec_krb5, "krb5" },
186 { Opt_sec_krb5i, "krb5i" },
187 { Opt_sec_krb5p, "krb5p" },
188
189 { Opt_sec_lkey, "lkey" },
190 { Opt_sec_lkeyi, "lkeyi" },
191 { Opt_sec_lkeyp, "lkeyp" },
192
193 { Opt_sec_err, NULL }
194};
195
196
f7b422b1 197static void nfs_umount_begin(struct vfsmount *, int);
816724e6 198static int nfs_statfs(struct dentry *, struct kstatfs *);
f7b422b1
DH		 199static int nfs_show_options(struct seq_file *, struct vfsmount *);
200static int nfs_show_stats(struct seq_file *, struct vfsmount *);
816724e6 201static int nfs_get_sb(struct file_system_type *, int, const char *, void *, struct vfsmount *);
54ceac45 202static int nfs_xdev_get_sb(struct file_system_type *fs_type,
816724e6 203 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
f7b422b1 204static void nfs_kill_super(struct super_block *);
ef818a28 205static void nfs_put_super(struct super_block *);
f7b422b1
DH		 206
207static struct file_system_type nfs_fs_type = {
208 .owner = THIS_MODULE,
209 .name = "nfs",
210 .get_sb = nfs_get_sb,
211 .kill_sb = nfs_kill_super,
349457cc 212 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
f7b422b1
DH		 213};
214
54ceac45 215struct file_system_type nfs_xdev_fs_type = {
f7b422b1
DH		 216 .owner = THIS_MODULE,
217 .name = "nfs",
54ceac45 218 .get_sb = nfs_xdev_get_sb,
f7b422b1 219 .kill_sb = nfs_kill_super,
349457cc 220 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
f7b422b1
DH		 221};
222
ee9b6d61 223static const struct super_operations nfs_sops = {
f7b422b1
DH		 224 .alloc_inode = nfs_alloc_inode,
225 .destroy_inode = nfs_destroy_inode,
226 .write_inode = nfs_write_inode,
ef818a28 227 .put_super = nfs_put_super,
f7b422b1
DH		 228 .statfs = nfs_statfs,
229 .clear_inode = nfs_clear_inode,
230 .umount_begin = nfs_umount_begin,
231 .show_options = nfs_show_options,
232 .show_stats = nfs_show_stats,
233};
234
235#ifdef CONFIG_NFS_V4
816724e6
TM		 236static int nfs4_get_sb(struct file_system_type *fs_type,
237 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
54ceac45
DH		 238static int nfs4_xdev_get_sb(struct file_system_type *fs_type,
239 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
240static int nfs4_referral_get_sb(struct file_system_type *fs_type,
241 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
f7b422b1
DH		 242static void nfs4_kill_super(struct super_block *sb);
243
244static struct file_system_type nfs4_fs_type = {
245 .owner = THIS_MODULE,
246 .name = "nfs4",
247 .get_sb = nfs4_get_sb,
248 .kill_sb = nfs4_kill_super,
349457cc 249 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
f7b422b1
DH		 250};
251
54ceac45 252struct file_system_type nfs4_xdev_fs_type = {
f7b422b1
DH		 253 .owner = THIS_MODULE,
254 .name = "nfs4",
54ceac45 255 .get_sb = nfs4_xdev_get_sb,
f7b422b1 256 .kill_sb = nfs4_kill_super,
349457cc 257 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
f7b422b1
DH		 258};
259
54ceac45 260struct file_system_type nfs4_referral_fs_type = {
f7b422b1
DH		 261 .owner = THIS_MODULE,
262 .name = "nfs4",
54ceac45 263 .get_sb = nfs4_referral_get_sb,
f7b422b1 264 .kill_sb = nfs4_kill_super,
349457cc 265 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
f7b422b1
DH		 266};
267
ee9b6d61 268static const struct super_operations nfs4_sops = {
f7b422b1
DH		 269 .alloc_inode = nfs_alloc_inode,
270 .destroy_inode = nfs_destroy_inode,
271 .write_inode = nfs_write_inode,
272 .statfs = nfs_statfs,
273 .clear_inode = nfs4_clear_inode,
274 .umount_begin = nfs_umount_begin,
275 .show_options = nfs_show_options,
276 .show_stats = nfs_show_stats,
277};
278#endif
279
8e1f936b
RR		 280static struct shrinker acl_shrinker = {
281 .shrink = nfs_access_cache_shrinker,
282 .seeks = DEFAULT_SEEKS,
283};
979df72e 284
f7b422b1
DH		 285/*
286 * Register the NFS filesystems
287 */
288int __init register_nfs_fs(void)
289{
290 int ret;
291
292 ret = register_filesystem(&nfs_fs_type);
293 if (ret < 0)
294 goto error_0;
295
f7b422b1
DH		 296 ret = nfs_register_sysctl();
297 if (ret < 0)
298 goto error_1;
89a09141 299#ifdef CONFIG_NFS_V4
f7b422b1
DH		 300 ret = register_filesystem(&nfs4_fs_type);
301 if (ret < 0)
302 goto error_2;
303#endif
8e1f936b 304 register_shrinker(&acl_shrinker);
f7b422b1
DH		 305 return 0;
306
307#ifdef CONFIG_NFS_V4
308error_2:
309 nfs_unregister_sysctl();
89a09141 310#endif
f7b422b1
DH		 311error_1:
312 unregister_filesystem(&nfs_fs_type);
f7b422b1
DH		 313error_0:
314 return ret;
315}
316
317/*
318 * Unregister the NFS filesystems
319 */
320void __exit unregister_nfs_fs(void)
321{
8e1f936b 322 unregister_shrinker(&acl_shrinker);
f7b422b1
DH		 323#ifdef CONFIG_NFS_V4
324 unregister_filesystem(&nfs4_fs_type);
f7b422b1 325#endif
49af7ee1 326 nfs_unregister_sysctl();
f7b422b1
DH		 327 unregister_filesystem(&nfs_fs_type);
328}
329
ef818a28
SD		 330void nfs_sb_active(struct nfs_server *server)
331{
332 atomic_inc(&server->active);
333}
334
335void nfs_sb_deactive(struct nfs_server *server)
336{
337 if (atomic_dec_and_test(&server->active))
338 wake_up(&server->active_wq);
339}
340
341static void nfs_put_super(struct super_block *sb)
342{
343 struct nfs_server *server = NFS_SB(sb);
344 /*
345 * Make sure there are no outstanding ops to this server.
346 * If so, wait for them to finish before allowing the
347 * unmount to continue.
348 */
349 wait_event(server->active_wq, atomic_read(&server->active) == 0);
350}
351
f7b422b1
DH		 352/*
353 * Deliver file system statistics to userspace
354 */
816724e6 355static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
f7b422b1 356{
0c7d90cf 357 struct nfs_server *server = NFS_SB(dentry->d_sb);
f7b422b1
DH		 358 unsigned char blockbits;
359 unsigned long blockres;
0c7d90cf 360 struct nfs_fh *fh = NFS_FH(dentry->d_inode);
f7b422b1
DH		 361 struct nfs_fattr fattr;
362 struct nfs_fsstat res = {
363 .fattr = &fattr,
364 };
365 int error;
366
367 lock_kernel();
368
8fa5c000 369 error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
f7b422b1
DH		 370 if (error < 0)
371 goto out_err;
1a0ba9ae 372 buf->f_type = NFS_SUPER_MAGIC;
f7b422b1
DH		 373
374 /*
375 * Current versions of glibc do not correctly handle the
376 * case where f_frsize != f_bsize. Eventually we want to
377 * report the value of wtmult in this field.
378 */
0c7d90cf 379 buf->f_frsize = dentry->d_sb->s_blocksize;
f7b422b1
DH		 380
381 /*
382 * On most *nix systems, f_blocks, f_bfree, and f_bavail
383 * are reported in units of f_frsize. Linux hasn't had
384 * an f_frsize field in its statfs struct until recently,
385 * thus historically Linux's sys_statfs reports these
386 * fields in units of f_bsize.
387 */
0c7d90cf
DH		 388 buf->f_bsize = dentry->d_sb->s_blocksize;
389 blockbits = dentry->d_sb->s_blocksize_bits;
f7b422b1
DH		 390 blockres = (1 << blockbits) - 1;
391 buf->f_blocks = (res.tbytes + blockres) >> blockbits;
392 buf->f_bfree = (res.fbytes + blockres) >> blockbits;
393 buf->f_bavail = (res.abytes + blockres) >> blockbits;
394
395 buf->f_files = res.tfiles;
396 buf->f_ffree = res.afiles;
397
398 buf->f_namelen = server->namelen;
1a0ba9ae 399
f7b422b1
DH		 400 unlock_kernel();
401 return 0;
402
403 out_err:
404 dprintk("%s: statfs error = %d\n", __FUNCTION__, -error);
1a0ba9ae
AA		 405 unlock_kernel();
406 return error;
f7b422b1
DH		 407}
408
7d4e2747
DH		 409/*
410 * Map the security flavour number to a name
411 */
81039f1f
TM		 412static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
413{
7d4e2747 414 static const struct {
81039f1f
TM		 415 rpc_authflavor_t flavour;
416 const char *str;
417 } sec_flavours[] = {
418 { RPC_AUTH_NULL, "null" },
419 { RPC_AUTH_UNIX, "sys" },
420 { RPC_AUTH_GSS_KRB5, "krb5" },
421 { RPC_AUTH_GSS_KRB5I, "krb5i" },
422 { RPC_AUTH_GSS_KRB5P, "krb5p" },
423 { RPC_AUTH_GSS_LKEY, "lkey" },
424 { RPC_AUTH_GSS_LKEYI, "lkeyi" },
425 { RPC_AUTH_GSS_LKEYP, "lkeyp" },
426 { RPC_AUTH_GSS_SPKM, "spkm" },
427 { RPC_AUTH_GSS_SPKMI, "spkmi" },
428 { RPC_AUTH_GSS_SPKMP, "spkmp" },
4d81cd16 429 { UINT_MAX, "unknown" }
81039f1f
TM		 430 };
431 int i;
432
4d81cd16 433 for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
81039f1f
TM		 434 if (sec_flavours[i].flavour == flavour)
435 break;
436 }
437 return sec_flavours[i].str;
438}
439
f7b422b1
DH		 440/*
441 * Describe the mount options in force on this server representation
442 */
443static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss, int showdefaults)
444{
509de811 445 static const struct proc_nfs_info {
f7b422b1 446 int flag;
509de811
DH		 447 const char *str;
448 const char *nostr;
f7b422b1
DH		 449 } nfs_info[] = {
450 { NFS_MOUNT_SOFT, ",soft", ",hard" },
bcf35617 451 { NFS_MOUNT_INTR, ",intr", ",nointr" },
f7b422b1
DH		 452 { NFS_MOUNT_NOCTO, ",nocto", "" },
453 { NFS_MOUNT_NOAC, ",noac", "" },
454 { NFS_MOUNT_NONLM, ",nolock", "" },
455 { NFS_MOUNT_NOACL, ",noacl", "" },
74dd34e6 456 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
75180df2 457 { NFS_MOUNT_UNSHARED, ",nosharecache", ""},
f7b422b1
DH		 458 { 0, NULL, NULL }
459 };
509de811 460 const struct proc_nfs_info *nfs_infop;
8fa5c000 461 struct nfs_client *clp = nfss->nfs_client;
f7b422b1 462
8fa5c000 463 seq_printf(m, ",vers=%d", clp->rpc_ops->version);
f7b422b1
DH		 464 seq_printf(m, ",rsize=%d", nfss->rsize);
465 seq_printf(m, ",wsize=%d", nfss->wsize);
466 if (nfss->acregmin != 3*HZ || showdefaults)
467 seq_printf(m, ",acregmin=%d", nfss->acregmin/HZ);
468 if (nfss->acregmax != 60*HZ || showdefaults)
469 seq_printf(m, ",acregmax=%d", nfss->acregmax/HZ);
470 if (nfss->acdirmin != 30*HZ || showdefaults)
471 seq_printf(m, ",acdirmin=%d", nfss->acdirmin/HZ);
472 if (nfss->acdirmax != 60*HZ || showdefaults)
473 seq_printf(m, ",acdirmax=%d", nfss->acdirmax/HZ);
474 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
475 if (nfss->flags & nfs_infop->flag)
476 seq_puts(m, nfs_infop->str);
477 else
478 seq_puts(m, nfs_infop->nostr);
479 }
56928edd
TT		 480 seq_printf(m, ",proto=%s",
481 rpc_peeraddr2str(nfss->client, RPC_DISPLAY_PROTO));
5006a76c
DH		 482 seq_printf(m, ",timeo=%lu", 10U * clp->retrans_timeo / HZ);
483 seq_printf(m, ",retrans=%u", clp->retrans_count);
81039f1f 484 seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
f7b422b1
DH		 485}
486
487/*
488 * Describe the mount options on this VFS mountpoint
489 */
490static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
491{
492 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
493
494 nfs_show_mount_options(m, nfss, 0);
495
ddc01c08
JL		 496 seq_printf(m, ",addr="NIPQUAD_FMT,
497 NIPQUAD(nfss->nfs_client->cl_addr.sin_addr));
f7b422b1
DH		 498
499 return 0;
500}
501
502/*
503 * Present statistical information for this VFS mountpoint
504 */
505static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
506{
507 int i, cpu;
508 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
509 struct rpc_auth *auth = nfss->client->cl_auth;
510 struct nfs_iostats totals = { };
511
512 seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
513
514 /*
515 * Display all mount option settings
516 */
517 seq_printf(m, "\n\topts:\t");
518 seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
519 seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
520 seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
521 seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
522 nfs_show_mount_options(m, nfss, 1);
523
524 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
525
526 seq_printf(m, "\n\tcaps:\t");
527 seq_printf(m, "caps=0x%x", nfss->caps);
528 seq_printf(m, ",wtmult=%d", nfss->wtmult);
529 seq_printf(m, ",dtsize=%d", nfss->dtsize);
530 seq_printf(m, ",bsize=%d", nfss->bsize);
531 seq_printf(m, ",namelen=%d", nfss->namelen);
532
533#ifdef CONFIG_NFS_V4
8fa5c000 534 if (nfss->nfs_client->cl_nfsversion == 4) {
f7b422b1
DH		 535 seq_printf(m, "\n\tnfsv4:\t");
536 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
537 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
538 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
539 }
540#endif
541
542 /*
543 * Display security flavor in effect for this mount
544 */
545 seq_printf(m, "\n\tsec:\tflavor=%d", auth->au_ops->au_flavor);
546 if (auth->au_flavor)
547 seq_printf(m, ",pseudoflavor=%d", auth->au_flavor);
548
549 /*
550 * Display superblock I/O counters
551 */
552 for_each_possible_cpu(cpu) {
553 struct nfs_iostats *stats;
554
555 preempt_disable();
556 stats = per_cpu_ptr(nfss->io_stats, cpu);
557
558 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
559 totals.events[i] += stats->events[i];
560 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
561 totals.bytes[i] += stats->bytes[i];
562
563 preempt_enable();
564 }
565
566 seq_printf(m, "\n\tevents:\t");
567 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
568 seq_printf(m, "%lu ", totals.events[i]);
569 seq_printf(m, "\n\tbytes:\t");
570 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
571 seq_printf(m, "%Lu ", totals.bytes[i]);
572 seq_printf(m, "\n");
573
574 rpc_print_iostats(m, nfss->client);
575
576 return 0;
577}
578
579/*
580 * Begin unmount by attempting to remove all automounted mountpoints we added
54ceac45 581 * in response to xdev traversals and referrals
f7b422b1
DH		 582 */
583static void nfs_umount_begin(struct vfsmount *vfsmnt, int flags)
584{
fc6ae3cf
TM		 585 struct nfs_server *server = NFS_SB(vfsmnt->mnt_sb);
586 struct rpc_clnt *rpc;
587
f7b422b1 588 shrink_submounts(vfsmnt, &nfs_automount_list);
fc6ae3cf
TM		 589
590 if (!(flags & MNT_FORCE))
591 return;
592 /* -EIO all pending I/O */
593 rpc = server->client_acl;
594 if (!IS_ERR(rpc))
595 rpc_killall_tasks(rpc);
596 rpc = server->client;
597 if (!IS_ERR(rpc))
598 rpc_killall_tasks(rpc);
f7b422b1
DH		 599}
600
fc50d58f
CL		 601/*
602 * Sanity-check a server address provided by the mount command
603 */
604static int nfs_verify_server_address(struct sockaddr *addr)
605{
606 switch (addr->sa_family) {
607 case AF_INET: {
608 struct sockaddr_in *sa = (struct sockaddr_in *) addr;
609 if (sa->sin_addr.s_addr != INADDR_ANY)
610 return 1;
611 break;
612 }
613 }
614
615 return 0;
616}
617
bf0fd768
CL		 618/*
619 * Error-check and convert a string of mount options from user space into
620 * a data structure
621 */
622static int nfs_parse_mount_options(char *raw,
623 struct nfs_parsed_mount_data *mnt)
624{
625 char *p, *string;
626
627 if (!raw) {
628 dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
629 return 1;
630 }
631 dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
632
633 while ((p = strsep(&raw, ",")) != NULL) {
634 substring_t args[MAX_OPT_ARGS];
635 int option, token;
636
637 if (!*p)
638 continue;
639
640 dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
641
642 token = match_token(p, nfs_mount_option_tokens, args);
643 switch (token) {
644 case Opt_soft:
645 mnt->flags |= NFS_MOUNT_SOFT;
646 break;
647 case Opt_hard:
648 mnt->flags &= ~NFS_MOUNT_SOFT;
649 break;
650 case Opt_intr:
651 mnt->flags |= NFS_MOUNT_INTR;
652 break;
653 case Opt_nointr:
654 mnt->flags &= ~NFS_MOUNT_INTR;
655 break;
656 case Opt_posix:
657 mnt->flags |= NFS_MOUNT_POSIX;
658 break;
659 case Opt_noposix:
660 mnt->flags &= ~NFS_MOUNT_POSIX;
661 break;
662 case Opt_cto:
663 mnt->flags &= ~NFS_MOUNT_NOCTO;
664 break;
665 case Opt_nocto:
666 mnt->flags |= NFS_MOUNT_NOCTO;
667 break;
668 case Opt_ac:
669 mnt->flags &= ~NFS_MOUNT_NOAC;
670 break;
671 case Opt_noac:
672 mnt->flags |= NFS_MOUNT_NOAC;
673 break;
674 case Opt_lock:
675 mnt->flags &= ~NFS_MOUNT_NONLM;
676 break;
677 case Opt_nolock:
678 mnt->flags |= NFS_MOUNT_NONLM;
679 break;
680 case Opt_v2:
681 mnt->flags &= ~NFS_MOUNT_VER3;
682 break;
683 case Opt_v3:
684 mnt->flags |= NFS_MOUNT_VER3;
685 break;
686 case Opt_udp:
687 mnt->flags &= ~NFS_MOUNT_TCP;
0896a725 688 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
bf0fd768
CL		 689 mnt->timeo = 7;
690 mnt->retrans = 5;
691 break;
692 case Opt_tcp:
693 mnt->flags |= NFS_MOUNT_TCP;
0896a725 694 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
bf0fd768
CL		 695 mnt->timeo = 600;
696 mnt->retrans = 2;
697 break;
2cf7ff7a
TT		 698 case Opt_rdma:
699 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
700 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
701 mnt->timeo = 600;
702 mnt->retrans = 2;
703 break;
bf0fd768
CL		 704 case Opt_acl:
705 mnt->flags &= ~NFS_MOUNT_NOACL;
706 break;
707 case Opt_noacl:
708 mnt->flags |= NFS_MOUNT_NOACL;
709 break;
710 case Opt_rdirplus:
711 mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
712 break;
713 case Opt_nordirplus:
714 mnt->flags |= NFS_MOUNT_NORDIRPLUS;
715 break;
75180df2
TM		 716 case Opt_sharecache:
717 mnt->flags &= ~NFS_MOUNT_UNSHARED;
718 break;
719 case Opt_nosharecache:
720 mnt->flags |= NFS_MOUNT_UNSHARED;
721 break;
bf0fd768
CL		 722
723 case Opt_port:
724 if (match_int(args, &option))
725 return 0;
726 if (option < 0 || option > 65535)
727 return 0;
41089644 728 mnt->nfs_server.address.sin_port = htons(option);
bf0fd768
CL		 729 break;
730 case Opt_rsize:
731 if (match_int(args, &mnt->rsize))
732 return 0;
733 break;
734 case Opt_wsize:
735 if (match_int(args, &mnt->wsize))
736 return 0;
737 break;
738 case Opt_bsize:
739 if (match_int(args, &option))
740 return 0;
741 if (option < 0)
742 return 0;
743 mnt->bsize = option;
744 break;
745 case Opt_timeo:
746 if (match_int(args, &mnt->timeo))
747 return 0;
748 break;
749 case Opt_retrans:
750 if (match_int(args, &mnt->retrans))
751 return 0;
752 break;
753 case Opt_acregmin:
754 if (match_int(args, &mnt->acregmin))
755 return 0;
756 break;
757 case Opt_acregmax:
758 if (match_int(args, &mnt->acregmax))
759 return 0;
760 break;
761 case Opt_acdirmin:
762 if (match_int(args, &mnt->acdirmin))
763 return 0;
764 break;
765 case Opt_acdirmax:
766 if (match_int(args, &mnt->acdirmax))
767 return 0;
768 break;
769 case Opt_actimeo:
770 if (match_int(args, &option))
771 return 0;
772 if (option < 0)
773 return 0;
774 mnt->acregmin =
775 mnt->acregmax =
776 mnt->acdirmin =
777 mnt->acdirmax = option;
778 break;
779 case Opt_namelen:
780 if (match_int(args, &mnt->namlen))
781 return 0;
782 break;
783 case Opt_mountport:
784 if (match_int(args, &option))
785 return 0;
786 if (option < 0 || option > 65535)
787 return 0;
788 mnt->mount_server.port = option;
789 break;
790 case Opt_mountprog:
791 if (match_int(args, &option))
792 return 0;
793 if (option < 0)
794 return 0;
795 mnt->mount_server.program = option;
796 break;
797 case Opt_mountvers:
798 if (match_int(args, &option))
799 return 0;
800 if (option < 0)
801 return 0;
802 mnt->mount_server.version = option;
803 break;
804 case Opt_nfsprog:
805 if (match_int(args, &option))
806 return 0;
807 if (option < 0)
808 return 0;
809 mnt->nfs_server.program = option;
810 break;
811 case Opt_nfsvers:
812 if (match_int(args, &option))
813 return 0;
814 switch (option) {
815 case 2:
816 mnt->flags &= ~NFS_MOUNT_VER3;
817 break;
818 case 3:
819 mnt->flags |= NFS_MOUNT_VER3;
820 break;
821 default:
822 goto out_unrec_vers;
823 }
824 break;
825
826 case Opt_sec:
827 string = match_strdup(args);
828 if (string == NULL)
829 goto out_nomem;
830 token = match_token(string, nfs_secflavor_tokens, args);
831 kfree(string);
832
833 /*
834 * The flags setting is for v2/v3. The flavor_len
835 * setting is for v4. v2/v3 also need to know the
836 * difference between NULL and UNIX.
837 */
838 switch (token) {
839 case Opt_sec_none:
840 mnt->flags &= ~NFS_MOUNT_SECFLAVOUR;
841 mnt->auth_flavor_len = 0;
842 mnt->auth_flavors[0] = RPC_AUTH_NULL;
843 break;
844 case Opt_sec_sys:
845 mnt->flags &= ~NFS_MOUNT_SECFLAVOUR;
846 mnt->auth_flavor_len = 0;
847 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
848 break;
849 case Opt_sec_krb5:
850 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
851 mnt->auth_flavor_len = 1;
852 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
853 break;
854 case Opt_sec_krb5i:
855 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
856 mnt->auth_flavor_len = 1;
857 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
858 break;
859 case Opt_sec_krb5p:
860 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
861 mnt->auth_flavor_len = 1;
862 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
863 break;
864 case Opt_sec_lkey:
865 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
866 mnt->auth_flavor_len = 1;
867 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
868 break;
869 case Opt_sec_lkeyi:
870 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
871 mnt->auth_flavor_len = 1;
872 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
873 break;
874 case Opt_sec_lkeyp:
875 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
876 mnt->auth_flavor_len = 1;
877 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
878 break;
879 case Opt_sec_spkm:
880 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
881 mnt->auth_flavor_len = 1;
882 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
883 break;
884 case Opt_sec_spkmi:
885 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
886 mnt->auth_flavor_len = 1;
887 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
888 break;
889 case Opt_sec_spkmp:
890 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
891 mnt->auth_flavor_len = 1;
892 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
893 break;
894 default:
895 goto out_unrec_sec;
896 }
897 break;
898 case Opt_proto:
899 string = match_strdup(args);
900 if (string == NULL)
901 goto out_nomem;
902 token = match_token(string,
903 nfs_xprt_protocol_tokens, args);
904 kfree(string);
905
906 switch (token) {
fdb66ff4 907 case Opt_xprt_udp:
bf0fd768 908 mnt->flags &= ~NFS_MOUNT_TCP;
0896a725 909 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
bf0fd768
CL		 910 mnt->timeo = 7;
911 mnt->retrans = 5;
912 break;
fdb66ff4 913 case Opt_xprt_tcp:
bf0fd768 914 mnt->flags |= NFS_MOUNT_TCP;
0896a725 915 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
bf0fd768
CL		 916 mnt->timeo = 600;
917 mnt->retrans = 2;
918 break;
2cf7ff7a
TT		 919 case Opt_xprt_rdma:
920 /* vector side protocols to TCP */
921 mnt->flags |= NFS_MOUNT_TCP;
922 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
923 mnt->timeo = 600;
924 mnt->retrans = 2;
925 break;
bf0fd768
CL		 926 default:
927 goto out_unrec_xprt;
928 }
929 break;
930 case Opt_mountproto:
931 string = match_strdup(args);
932 if (string == NULL)
933 goto out_nomem;
934 token = match_token(string,
935 nfs_xprt_protocol_tokens, args);
936 kfree(string);
937
938 switch (token) {
fdb66ff4 939 case Opt_xprt_udp:
0896a725 940 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
bf0fd768 941 break;
fdb66ff4 942 case Opt_xprt_tcp:
0896a725 943 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
bf0fd768 944 break;
2cf7ff7a 945 case Opt_xprt_rdma: /* not used for side protocols */
bf0fd768
CL		 946 default:
947 goto out_unrec_xprt;
948 }
949 break;
950 case Opt_addr:
951 string = match_strdup(args);
952 if (string == NULL)
953 goto out_nomem;
954 mnt->nfs_server.address.sin_family = AF_INET;
955 mnt->nfs_server.address.sin_addr.s_addr =
956 in_aton(string);
957 kfree(string);
958 break;
959 case Opt_clientaddr:
960 string = match_strdup(args);
961 if (string == NULL)
962 goto out_nomem;
963 mnt->client_address = string;
964 break;
0ac83779 965 case Opt_mountaddr:
bf0fd768
CL		 966 string = match_strdup(args);
967 if (string == NULL)
968 goto out_nomem;
969 mnt->mount_server.address.sin_family = AF_INET;
970 mnt->mount_server.address.sin_addr.s_addr =
971 in_aton(string);
972 kfree(string);
973 break;
974
975 case Opt_userspace:
976 case Opt_deprecated:
977 break;
978
979 default:
980 goto out_unknown;
981 }
982 }
983
984 return 1;
985
986out_nomem:
987 printk(KERN_INFO "NFS: not enough memory to parse option\n");
988 return 0;
989
990out_unrec_vers:
991 printk(KERN_INFO "NFS: unrecognized NFS version number\n");
992 return 0;
993
994out_unrec_xprt:
995 printk(KERN_INFO "NFS: unrecognized transport protocol\n");
996 return 0;
997
998out_unrec_sec:
999 printk(KERN_INFO "NFS: unrecognized security flavor\n");
1000 return 0;
1001
1002out_unknown:
1003 printk(KERN_INFO "NFS: unknown mount option: %s\n", p);
1004 return 0;
1005}
1006
0076d7b7
CL		 1007/*
1008 * Use the remote server's MOUNT service to request the NFS file handle
1009 * corresponding to the provided path.
1010 */
1011static int nfs_try_mount(struct nfs_parsed_mount_data *args,
1012 struct nfs_fh *root_fh)
1013{
1014 struct sockaddr_in sin;
1015 int status;
1016
1017 if (args->mount_server.version == 0) {
1018 if (args->flags & NFS_MOUNT_VER3)
1019 args->mount_server.version = NFS_MNT3_VERSION;
1020 else
1021 args->mount_server.version = NFS_MNT_VERSION;
1022 }
1023
1024 /*
1025 * Construct the mount server's address.
1026 */
1027 if (args->mount_server.address.sin_addr.s_addr != INADDR_ANY)
1028 sin = args->mount_server.address;
1029 else
1030 sin = args->nfs_server.address;
aad70007
JL		 1031 /*
1032 * autobind will be used if mount_server.port == 0
1033 */
1034 sin.sin_port = htons(args->mount_server.port);
0076d7b7
CL		 1035
1036 /*
1037 * Now ask the mount server to map our export path
1038 * to a file handle.
1039 */
1040 status = nfs_mount((struct sockaddr *) &sin,
1041 sizeof(sin),
1042 args->nfs_server.hostname,
1043 args->nfs_server.export_path,
1044 args->mount_server.version,
1045 args->mount_server.protocol,
1046 root_fh);
efd8340b
CL		 1047 if (status == 0)
1048 return 0;
0076d7b7 1049
efd8340b
CL		 1050 dfprintk(MOUNT, "NFS: unable to mount server " NIPQUAD_FMT
1051 ", error %d\n", NIPQUAD(sin.sin_addr.s_addr), status);
0076d7b7
CL		 1052 return status;
1053}
1054
f7b422b1 1055/*
54ceac45
DH		 1056 * Validate the NFS2/NFS3 mount data
1057 * - fills in the mount root filehandle
136d558c
CL		 1058 *
1059 * For option strings, user space handles the following behaviors:
1060 *
1061 * + DNS: mapping server host name to IP address ("addr=" option)
1062 *
1063 * + failure mode: how to behave if a mount request can't be handled
1064 * immediately ("fg/bg" option)
1065 *
1066 * + retry: how often to retry a mount request ("retry=" option)
1067 *
1068 * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
1069 * mountproto=tcp after mountproto=udp, and so on
1070 *
1071 * XXX: as far as I can tell, changing the NFS program number is not
1072 * supported in the NFS client.
f7b422b1 1073 */
2283f8d6
TT		 1074static int nfs_validate_mount_data(void *options,
1075 struct nfs_parsed_mount_data *args,
136d558c
CL		 1076 struct nfs_fh *mntfh,
1077 const char *dev_name)
f7b422b1 1078{
2283f8d6 1079 struct nfs_mount_data *data = (struct nfs_mount_data *)options;
136d558c 1080
f16c9603
RK		 1081 memset(args, 0, sizeof(*args));
1082
5df36e78
CL		 1083 if (data == NULL)
1084 goto out_no_data;
f7b422b1 1085
2283f8d6
TT		 1086 args->flags = (NFS_MOUNT_VER3 | NFS_MOUNT_TCP);
1087 args->rsize = NFS_MAX_FILE_IO_SIZE;
1088 args->wsize = NFS_MAX_FILE_IO_SIZE;
1089 args->timeo = 600;
1090 args->retrans = 2;
1091 args->acregmin = 3;
1092 args->acregmax = 60;
1093 args->acdirmin = 30;
1094 args->acdirmax = 60;
0896a725 1095 args->mount_server.protocol = XPRT_TRANSPORT_UDP;
2283f8d6 1096 args->mount_server.program = NFS_MNT_PROGRAM;
0896a725 1097 args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
2283f8d6
TT		 1098 args->nfs_server.program = NFS_PROGRAM;
1099
54ceac45 1100 switch (data->version) {
5df36e78
CL		 1101 case 1:
1102 data->namlen = 0;
1103 case 2:
1104 data->bsize = 0;
1105 case 3:
1106 if (data->flags & NFS_MOUNT_VER3)
1107 goto out_no_v3;
1108 data->root.size = NFS2_FHSIZE;
1109 memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
1110 case 4:
1111 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1112 goto out_no_sec;
1113 case 5:
1114 memset(data->context, 0, sizeof(data->context));
1115 case 6:
1116 if (data->flags & NFS_MOUNT_VER3)
1117 mntfh->size = data->root.size;
1118 else
1119 mntfh->size = NFS2_FHSIZE;
1120
1121 if (mntfh->size > sizeof(mntfh->data))
1122 goto out_invalid_fh;
1123
1124 memcpy(mntfh->data, data->root.data, mntfh->size);
1125 if (mntfh->size < sizeof(mntfh->data))
1126 memset(mntfh->data + mntfh->size, 0,
1127 sizeof(mntfh->data) - mntfh->size);
6e88e061
CL		 1128
1129 if (!nfs_verify_server_address((struct sockaddr *) &data->addr))
1130 goto out_no_address;
1131
2283f8d6
TT		 1132 /*
1133 * Translate to nfs_parsed_mount_data, which nfs_fill_super
1134 * can deal with.
1135 */
1136 args->flags = data->flags;
1137 args->rsize = data->rsize;
1138 args->wsize = data->wsize;
1139 args->flags = data->flags;
1140 args->timeo = data->timeo;
1141 args->retrans = data->retrans;
1142 args->acregmin = data->acregmin;
1143 args->acregmax = data->acregmax;
1144 args->acdirmin = data->acdirmin;
1145 args->acdirmax = data->acdirmax;
1146 args->nfs_server.address = data->addr;
1147 if (!(data->flags & NFS_MOUNT_TCP))
0896a725 1148 args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
2283f8d6
TT		 1149 /* N.B. caller will free nfs_server.hostname in all cases */
1150 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
1151 args->namlen = data->namlen;
1152 args->bsize = data->bsize;
1153 args->auth_flavors[0] = data->pseudoflavor;
5df36e78 1154 break;
136d558c
CL		 1155 default: {
1156 unsigned int len;
1157 char *c;
1158 int status;
136d558c 1159
2283f8d6
TT		 1160 if (nfs_parse_mount_options((char *)options, args) == 0)
1161 return -EINVAL;
136d558c 1162
6e88e061
CL		 1163 if (!nfs_verify_server_address((struct sockaddr *)
1164 &args->nfs_server.address))
1165 goto out_no_address;
1166
136d558c
CL		 1167 c = strchr(dev_name, ':');
1168 if (c == NULL)
1169 return -EINVAL;
350c73af 1170 len = c - dev_name;
2283f8d6
TT		 1171 /* N.B. caller will free nfs_server.hostname in all cases */
1172 args->nfs_server.hostname = kstrndup(dev_name, len, GFP_KERNEL);
136d558c
CL		 1173
1174 c++;
1175 if (strlen(c) > NFS_MAXPATHLEN)
7d1cca72 1176 return -ENAMETOOLONG;
2283f8d6 1177 args->nfs_server.export_path = c;
136d558c 1178
2283f8d6 1179 status = nfs_try_mount(args, mntfh);
136d558c 1180 if (status)
fdc6e2c8 1181 return status;
136d558c 1182
136d558c
CL		 1183 break;
1184 }
f7b422b1 1185 }
54ceac45 1186
2283f8d6
TT		 1187 if (!(args->flags & NFS_MOUNT_SECFLAVOUR))
1188 args->auth_flavors[0] = RPC_AUTH_UNIX;
36b15c54 1189
54ceac45 1190#ifndef CONFIG_NFS_V3
2283f8d6 1191 if (args->flags & NFS_MOUNT_VER3)
5df36e78
CL		 1192 goto out_v3_not_compiled;
1193#endif /* !CONFIG_NFS_V3 */
f7b422b1 1194
5df36e78 1195 return 0;
f7b422b1 1196
5df36e78
CL		 1197out_no_data:
1198 dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
1199 return -EINVAL;
54ceac45 1200
5df36e78
CL		 1201out_no_v3:
1202 dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
1203 data->version);
1204 return -EINVAL;
f7b422b1 1205
5df36e78
CL		 1206out_no_sec:
1207 dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
1208 return -EINVAL;
1209
5df36e78
CL		 1210#ifndef CONFIG_NFS_V3
1211out_v3_not_compiled:
1212 dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
1213 return -EPROTONOSUPPORT;
1214#endif /* !CONFIG_NFS_V3 */
1215
1216out_no_address:
1217 dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
1218 return -EINVAL;
1219
1220out_invalid_fh:
1221 dfprintk(MOUNT, "NFS: invalid root filehandle\n");
1222 return -EINVAL;
f7b422b1
DH		 1223}
1224
f7b422b1 1225/*
54ceac45 1226 * Initialise the common bits of the superblock
f7b422b1 1227 */
54ceac45 1228static inline void nfs_initialise_sb(struct super_block *sb)
f7b422b1 1229{
54ceac45 1230 struct nfs_server *server = NFS_SB(sb);
5006a76c 1231
54ceac45 1232 sb->s_magic = NFS_SUPER_MAGIC;
f7b422b1 1233
54ceac45
DH		 1234 /* We probably want something more informative here */
1235 snprintf(sb->s_id, sizeof(sb->s_id),
1236 "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
5006a76c 1237
54ceac45
DH		 1238 if (sb->s_blocksize == 0)
1239 sb->s_blocksize = nfs_block_bits(server->wsize,
1240 &sb->s_blocksize_bits);
f7b422b1 1241
54ceac45
DH		 1242 if (server->flags & NFS_MOUNT_NOAC)
1243 sb->s_flags |= MS_SYNCHRONOUS;
f7b422b1 1244
54ceac45 1245 nfs_super_set_maxbytes(sb, server->maxfilesize);
f7b422b1
DH		 1246}
1247
1248/*
54ceac45 1249 * Finish setting up an NFS2/3 superblock
f7b422b1 1250 */
2283f8d6
TT		 1251static void nfs_fill_super(struct super_block *sb,
1252 struct nfs_parsed_mount_data *data)
f7b422b1
DH		 1253{
1254 struct nfs_server *server = NFS_SB(sb);
5006a76c 1255
54ceac45
DH		 1256 sb->s_blocksize_bits = 0;
1257 sb->s_blocksize = 0;
1258 if (data->bsize)
1259 sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
f7b422b1 1260
54ceac45
DH		 1261 if (server->flags & NFS_MOUNT_VER3) {
1262 /* The VFS shouldn't apply the umask to mode bits. We will do
1263 * so ourselves when necessary.
1264 */
1265 sb->s_flags |= MS_POSIXACL;
1266 sb->s_time_gran = 1;
816724e6 1267 }
54ceac45
DH		 1268
1269 sb->s_op = &nfs_sops;
1270 nfs_initialise_sb(sb);
f7b422b1
DH		 1271}
1272
1273/*
54ceac45 1274 * Finish setting up a cloned NFS2/3 superblock
f7b422b1 1275 */
54ceac45
DH		 1276static void nfs_clone_super(struct super_block *sb,
1277 const struct super_block *old_sb)
f7b422b1 1278{
54ceac45
DH		 1279 struct nfs_server *server = NFS_SB(sb);
1280
1281 sb->s_blocksize_bits = old_sb->s_blocksize_bits;
1282 sb->s_blocksize = old_sb->s_blocksize;
1283 sb->s_maxbytes = old_sb->s_maxbytes;
f7b422b1 1284
f7b422b1 1285 if (server->flags & NFS_MOUNT_VER3) {
54ceac45
DH		 1286 /* The VFS shouldn't apply the umask to mode bits. We will do
1287 * so ourselves when necessary.
f7b422b1
DH		 1288 */
1289 sb->s_flags |= MS_POSIXACL;
f7b422b1 1290 sb->s_time_gran = 1;
f7b422b1
DH		 1291 }
1292
54ceac45
DH		 1293 sb->s_op = old_sb->s_op;
1294 nfs_initialise_sb(sb);
f7b422b1
DH		 1295}
1296
275a5d24
TM		 1297#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
1298
1299static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
1300{
1301 const struct nfs_server *a = s->s_fs_info;
1302 const struct rpc_clnt *clnt_a = a->client;
1303 const struct rpc_clnt *clnt_b = b->client;
1304
1305 if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
1306 goto Ebusy;
1307 if (a->nfs_client != b->nfs_client)
1308 goto Ebusy;
1309 if (a->flags != b->flags)
1310 goto Ebusy;
1311 if (a->wsize != b->wsize)
1312 goto Ebusy;
1313 if (a->rsize != b->rsize)
1314 goto Ebusy;
1315 if (a->acregmin != b->acregmin)
1316 goto Ebusy;
1317 if (a->acregmax != b->acregmax)
1318 goto Ebusy;
1319 if (a->acdirmin != b->acdirmin)
1320 goto Ebusy;
1321 if (a->acdirmax != b->acdirmax)
1322 goto Ebusy;
1323 if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
1324 goto Ebusy;
e89a5a43 1325 return 1;
275a5d24 1326Ebusy:
e89a5a43
TM		 1327 return 0;
1328}
1329
1330struct nfs_sb_mountdata {
1331 struct nfs_server *server;
1332 int mntflags;
1333};
1334
1335static int nfs_set_super(struct super_block *s, void *data)
1336{
1337 struct nfs_sb_mountdata *sb_mntdata = data;
1338 struct nfs_server *server = sb_mntdata->server;
1339 int ret;
1340
1341 s->s_flags = sb_mntdata->mntflags;
1342 s->s_fs_info = server;
1343 ret = set_anon_super(s, server);
1344 if (ret == 0)
1345 server->s_dev = s->s_dev;
1346 return ret;
1347}
1348
1349static int nfs_compare_super(struct super_block *sb, void *data)
1350{
1351 struct nfs_sb_mountdata *sb_mntdata = data;
1352 struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
1353 int mntflags = sb_mntdata->mntflags;
1354
1355 if (memcmp(&old->nfs_client->cl_addr,
1356 &server->nfs_client->cl_addr,
1357 sizeof(old->nfs_client->cl_addr)) != 0)
1358 return 0;
1359 /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
1360 if (old->flags & NFS_MOUNT_UNSHARED)
1361 return 0;
1362 if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
1363 return 0;
1364 return nfs_compare_mount_options(sb, server, mntflags);
275a5d24
TM		 1365}
1366
816724e6
TM		 1367static int nfs_get_sb(struct file_system_type *fs_type,
1368 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
f7b422b1 1369{
f7b422b1
DH		 1370 struct nfs_server *server = NULL;
1371 struct super_block *s;
54ceac45 1372 struct nfs_fh mntfh;
2283f8d6 1373 struct nfs_parsed_mount_data data;
54ceac45 1374 struct dentry *mntroot;
75180df2 1375 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
e89a5a43
TM		 1376 struct nfs_sb_mountdata sb_mntdata = {
1377 .mntflags = flags,
1378 };
54ceac45 1379 int error;
f7b422b1 1380
54ceac45 1381 /* Validate the mount data */
2283f8d6 1382 error = nfs_validate_mount_data(raw_data, &data, &mntfh, dev_name);
54ceac45 1383 if (error < 0)
0655960f 1384 goto out;
f7b422b1 1385
54ceac45 1386 /* Get a volume representation */
2283f8d6 1387 server = nfs_create_server(&data, &mntfh);
54ceac45
DH		 1388 if (IS_ERR(server)) {
1389 error = PTR_ERR(server);
0655960f 1390 goto out;
f7b422b1 1391 }
e89a5a43 1392 sb_mntdata.server = server;
f7b422b1 1393
75180df2
TM		 1394 if (server->flags & NFS_MOUNT_UNSHARED)
1395 compare_super = NULL;
1396
54ceac45 1397 /* Get a superblock - note that we may end up sharing one that already exists */
e89a5a43 1398 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
816724e6
TM		 1399 if (IS_ERR(s)) {
1400 error = PTR_ERR(s);
54ceac45 1401 goto out_err_nosb;
816724e6
TM		 1402 }
1403
54ceac45
DH		 1404 if (s->s_fs_info != server) {
1405 nfs_free_server(server);
1406 server = NULL;
1407 }
f7b422b1 1408
54ceac45
DH		 1409 if (!s->s_root) {
1410 /* initial superblock/root creation */
2283f8d6 1411 nfs_fill_super(s, &data);
54ceac45 1412 }
f7b422b1 1413
54ceac45
DH		 1414 mntroot = nfs_get_root(s, &mntfh);
1415 if (IS_ERR(mntroot)) {
1416 error = PTR_ERR(mntroot);
1417 goto error_splat_super;
f7b422b1 1418 }
816724e6 1419
54ceac45
DH		 1420 s->s_flags |= MS_ACTIVE;
1421 mnt->mnt_sb = s;
1422 mnt->mnt_root = mntroot;
0655960f
CL		 1423 error = 0;
1424
1425out:
2283f8d6 1426 kfree(data.nfs_server.hostname);
0655960f 1427 return error;
816724e6 1428
54ceac45
DH		 1429out_err_nosb:
1430 nfs_free_server(server);
0655960f 1431 goto out;
54ceac45
DH		 1432
1433error_splat_super:
1434 up_write(&s->s_umount);
1435 deactivate_super(s);
0655960f 1436 goto out;
f7b422b1
DH		 1437}
1438
54ceac45
DH		 1439/*
1440 * Destroy an NFS2/3 superblock
1441 */
f7b422b1
DH		 1442static void nfs_kill_super(struct super_block *s)
1443{
1444 struct nfs_server *server = NFS_SB(s);
1445
1446 kill_anon_super(s);
54ceac45 1447 nfs_free_server(server);
f7b422b1
DH		 1448}
1449
54ceac45
DH		 1450/*
1451 * Clone an NFS2/3 server record on xdev traversal (FSID-change)
1452 */
1453static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
1454 const char *dev_name, void *raw_data,
1455 struct vfsmount *mnt)
f7b422b1
DH		 1456{
1457 struct nfs_clone_mount *data = raw_data;
54ceac45
DH		 1458 struct super_block *s;
1459 struct nfs_server *server;
1460 struct dentry *mntroot;
75180df2 1461 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
e89a5a43
TM		 1462 struct nfs_sb_mountdata sb_mntdata = {
1463 .mntflags = flags,
1464 };
54ceac45 1465 int error;
f7b422b1 1466
54ceac45 1467 dprintk("--> nfs_xdev_get_sb()\n");
f7b422b1 1468
54ceac45
DH		 1469 /* create a new volume representation */
1470 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
1471 if (IS_ERR(server)) {
1472 error = PTR_ERR(server);
1473 goto out_err_noserver;
1474 }
e89a5a43 1475 sb_mntdata.server = server;
8fa5c000 1476
75180df2
TM		 1477 if (server->flags & NFS_MOUNT_UNSHARED)
1478 compare_super = NULL;
1479
54ceac45 1480 /* Get a superblock - note that we may end up sharing one that already exists */
e89a5a43 1481 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
54ceac45
DH		 1482 if (IS_ERR(s)) {
1483 error = PTR_ERR(s);
1484 goto out_err_nosb;
1485 }
5006a76c 1486
54ceac45
DH		 1487 if (s->s_fs_info != server) {
1488 nfs_free_server(server);
1489 server = NULL;
f7b422b1 1490 }
24c8dbbb 1491
54ceac45
DH		 1492 if (!s->s_root) {
1493 /* initial superblock/root creation */
54ceac45
DH		 1494 nfs_clone_super(s, data->sb);
1495 }
f7b422b1 1496
54ceac45
DH		 1497 mntroot = nfs_get_root(s, data->fh);
1498 if (IS_ERR(mntroot)) {
1499 error = PTR_ERR(mntroot);
1500 goto error_splat_super;
f7b422b1 1501 }
e9cc6c23 1502 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
4c1fe2f7
NB		 1503 dput(mntroot);
1504 error = -ESTALE;
1505 goto error_splat_super;
1506 }
f7b422b1 1507
54ceac45
DH		 1508 s->s_flags |= MS_ACTIVE;
1509 mnt->mnt_sb = s;
1510 mnt->mnt_root = mntroot;
f7b422b1 1511
54ceac45
DH		 1512 dprintk("<-- nfs_xdev_get_sb() = 0\n");
1513 return 0;
24c8dbbb 1514
54ceac45
DH		 1515out_err_nosb:
1516 nfs_free_server(server);
1517out_err_noserver:
1518 dprintk("<-- nfs_xdev_get_sb() = %d [error]\n", error);
1519 return error;
f7b422b1 1520
54ceac45
DH		 1521error_splat_super:
1522 up_write(&s->s_umount);
1523 deactivate_super(s);
1524 dprintk("<-- nfs_xdev_get_sb() = %d [splat]\n", error);
1525 return error;
f7b422b1
DH		 1526}
1527
54ceac45
DH		 1528#ifdef CONFIG_NFS_V4
1529
f7b422b1 1530/*
54ceac45 1531 * Finish setting up a cloned NFS4 superblock
f7b422b1 1532 */
54ceac45
DH		 1533static void nfs4_clone_super(struct super_block *sb,
1534 const struct super_block *old_sb)
f7b422b1 1535{
54ceac45
DH		 1536 sb->s_blocksize_bits = old_sb->s_blocksize_bits;
1537 sb->s_blocksize = old_sb->s_blocksize;
1538 sb->s_maxbytes = old_sb->s_maxbytes;
f7b422b1 1539 sb->s_time_gran = 1;
54ceac45
DH		 1540 sb->s_op = old_sb->s_op;
1541 nfs_initialise_sb(sb);
f7b422b1
DH		 1542}
1543
54ceac45
DH		 1544/*
1545 * Set up an NFS4 superblock
1546 */
1547static void nfs4_fill_super(struct super_block *sb)
f7b422b1 1548{
54ceac45
DH		 1549 sb->s_time_gran = 1;
1550 sb->s_op = &nfs4_sops;
1551 nfs_initialise_sb(sb);
f7b422b1
DH		 1552}
1553
f0768ebd
CL		 1554/*
1555 * Validate NFSv4 mount options
1556 */
91ea40b9
TT		 1557static int nfs4_validate_mount_data(void *options,
1558 struct nfs_parsed_mount_data *args,
1559 const char *dev_name)
f0768ebd 1560{
91ea40b9 1561 struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
f0768ebd
CL		 1562 char *c;
1563
f16c9603
RK		 1564 memset(args, 0, sizeof(*args));
1565
f0768ebd
CL		 1566 if (data == NULL)
1567 goto out_no_data;
1568
91ea40b9
TT		 1569 args->rsize = NFS_MAX_FILE_IO_SIZE;
1570 args->wsize = NFS_MAX_FILE_IO_SIZE;
1571 args->timeo = 600;
1572 args->retrans = 2;
1573 args->acregmin = 3;
1574 args->acregmax = 60;
1575 args->acdirmin = 30;
1576 args->acdirmax = 60;
0896a725 1577 args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
91ea40b9 1578
f0768ebd
CL		 1579 switch (data->version) {
1580 case 1:
91ea40b9 1581 if (data->host_addrlen != sizeof(args->nfs_server.address))
f0768ebd 1582 goto out_no_address;
91ea40b9
TT		 1583 if (copy_from_user(&args->nfs_server.address,
1584 data->host_addr,
20c71f5e 1585 sizeof(args->nfs_server.address)))
f0768ebd 1586 return -EFAULT;
91ea40b9
TT		 1587 if (args->nfs_server.address.sin_port == 0)
1588 args->nfs_server.address.sin_port = htons(NFS_PORT);
1589 if (!nfs_verify_server_address((struct sockaddr *)
1590 &args->nfs_server.address))
f0768ebd
CL		 1591 goto out_no_address;
1592
1593 switch (data->auth_flavourlen) {
1594 case 0:
91ea40b9 1595 args->auth_flavors[0] = RPC_AUTH_UNIX;
f0768ebd
CL		 1596 break;
1597 case 1:
20c71f5e 1598 if (copy_from_user(&args->auth_flavors[0],
91ea40b9 1599 data->auth_flavours,
20c71f5e 1600 sizeof(args->auth_flavors[0])))
f0768ebd
CL		 1601 return -EFAULT;
1602 break;
1603 default:
1604 goto out_inval_auth;
1605 }
1606
1607 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
1608 if (IS_ERR(c))
1609 return PTR_ERR(c);
91ea40b9 1610 args->nfs_server.hostname = c;
f0768ebd
CL		 1611
1612 c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
1613 if (IS_ERR(c))
1614 return PTR_ERR(c);
91ea40b9
TT		 1615 args->nfs_server.export_path = c;
1616 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
f0768ebd
CL		 1617
1618 c = strndup_user(data->client_addr.data, 16);
1619 if (IS_ERR(c))
1620 return PTR_ERR(c);
91ea40b9
TT		 1621 args->client_address = c;
1622
1623 /*
1624 * Translate to nfs_parsed_mount_data, which nfs4_fill_super
1625 * can deal with.
1626 */
1627
1628 args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
1629 args->rsize = data->rsize;
1630 args->wsize = data->wsize;
1631 args->timeo = data->timeo;
1632 args->retrans = data->retrans;
1633 args->acregmin = data->acregmin;
1634 args->acregmax = data->acregmax;
1635 args->acdirmin = data->acdirmin;
1636 args->acdirmax = data->acdirmax;
1637 args->nfs_server.protocol = data->proto;
f0768ebd
CL		 1638
1639 break;
80071225
CL		 1640 default: {
1641 unsigned int len;
91ea40b9
TT		 1642
1643 if (nfs_parse_mount_options((char *)options, args) == 0)
80071225
CL		 1644 return -EINVAL;
1645
0eb25741
CL		 1646 if (args->nfs_server.address.sin_port == 0)
1647 args->nfs_server.address.sin_port = htons(NFS_PORT);
80071225 1648 if (!nfs_verify_server_address((struct sockaddr *)
91ea40b9 1649 &args->nfs_server.address))
80071225 1650 return -EINVAL;
80071225 1651
91ea40b9 1652 switch (args->auth_flavor_len) {
80071225 1653 case 0:
91ea40b9 1654 args->auth_flavors[0] = RPC_AUTH_UNIX;
80071225
CL		 1655 break;
1656 case 1:
80071225
CL		 1657 break;
1658 default:
1659 goto out_inval_auth;
1660 }
1661
80071225
CL		 1662 /*
1663 * Split "dev_name" into "hostname:mntpath".
1664 */
1665 c = strchr(dev_name, ':');
1666 if (c == NULL)
1667 return -EINVAL;
1668 /* while calculating len, pretend ':' is '\0' */
1669 len = c - dev_name;
1670 if (len > NFS4_MAXNAMLEN)
7d1cca72 1671 return -ENAMETOOLONG;
91ea40b9
TT		 1672 args->nfs_server.hostname = kzalloc(len, GFP_KERNEL);
1673 if (args->nfs_server.hostname == NULL)
80071225 1674 return -ENOMEM;
91ea40b9 1675 strncpy(args->nfs_server.hostname, dev_name, len - 1);
80071225
CL		 1676
1677 c++; /* step over the ':' */
1678 len = strlen(c);
1679 if (len > NFS4_MAXPATHLEN)
7d1cca72 1680 return -ENAMETOOLONG;
91ea40b9
TT		 1681 args->nfs_server.export_path = kzalloc(len + 1, GFP_KERNEL);
1682 if (args->nfs_server.export_path == NULL)
80071225 1683 return -ENOMEM;
91ea40b9 1684 strncpy(args->nfs_server.export_path, c, len);
80071225 1685
91ea40b9 1686 dprintk("MNTPATH: %s\n", args->nfs_server.export_path);
80071225 1687
91ea40b9 1688 if (args->client_address == NULL)
0a87cf12
JL		 1689 goto out_no_client_address;
1690
80071225
CL		 1691 break;
1692 }
f0768ebd
CL		 1693 }
1694
1695 return 0;
1696
1697out_no_data:
1698 dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
1699 return -EINVAL;
1700
1701out_inval_auth:
1702 dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
1703 data->auth_flavourlen);
1704 return -EINVAL;
1705
1706out_no_address:
1707 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
1708 return -EINVAL;
0a87cf12
JL		 1709
1710out_no_client_address:
1711 dfprintk(MOUNT, "NFS4: mount program didn't pass callback address\n");
1712 return -EINVAL;
f0768ebd
CL		 1713}
1714
54ceac45
DH		 1715/*
1716 * Get the superblock for an NFS4 mountpoint
1717 */
816724e6
TM		 1718static int nfs4_get_sb(struct file_system_type *fs_type,
1719 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
f7b422b1 1720{
91ea40b9 1721 struct nfs_parsed_mount_data data;
54ceac45
DH		 1722 struct super_block *s;
1723 struct nfs_server *server;
54ceac45
DH		 1724 struct nfs_fh mntfh;
1725 struct dentry *mntroot;
75180df2 1726 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
e89a5a43
TM		 1727 struct nfs_sb_mountdata sb_mntdata = {
1728 .mntflags = flags,
1729 };
54ceac45 1730 int error;
f7b422b1 1731
f0768ebd 1732 /* Validate the mount data */
91ea40b9 1733 error = nfs4_validate_mount_data(raw_data, &data, dev_name);
f0768ebd
CL		 1734 if (error < 0)
1735 goto out;
f7b422b1 1736
54ceac45 1737 /* Get a volume representation */
91ea40b9 1738 server = nfs4_create_server(&data, &mntfh);
54ceac45
DH		 1739 if (IS_ERR(server)) {
1740 error = PTR_ERR(server);
29eb981a 1741 goto out;
f7b422b1 1742 }
e89a5a43 1743 sb_mntdata.server = server;
f7b422b1 1744
75180df2
TM		 1745 if (server->flags & NFS4_MOUNT_UNSHARED)
1746 compare_super = NULL;
1747
54ceac45 1748 /* Get a superblock - note that we may end up sharing one that already exists */
e89a5a43 1749 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
816724e6
TM		 1750 if (IS_ERR(s)) {
1751 error = PTR_ERR(s);
f7b422b1 1752 goto out_free;
816724e6
TM		 1753 }
1754
5dd3177a
TM		 1755 if (s->s_fs_info != server) {
1756 nfs_free_server(server);
1757 server = NULL;
1758 }
1759
54ceac45
DH		 1760 if (!s->s_root) {
1761 /* initial superblock/root creation */
54ceac45 1762 nfs4_fill_super(s);
54ceac45 1763 }
f7b422b1 1764
54ceac45
DH		 1765 mntroot = nfs4_get_root(s, &mntfh);
1766 if (IS_ERR(mntroot)) {
1767 error = PTR_ERR(mntroot);
1768 goto error_splat_super;
f7b422b1 1769 }
54ceac45 1770
f7b422b1 1771 s->s_flags |= MS_ACTIVE;
54ceac45
DH		 1772 mnt->mnt_sb = s;
1773 mnt->mnt_root = mntroot;
29eb981a
CL		 1774 error = 0;
1775
1776out:
91ea40b9
TT		 1777 kfree(data.client_address);
1778 kfree(data.nfs_server.export_path);
1779 kfree(data.nfs_server.hostname);
29eb981a 1780 return error;
54ceac45 1781
f7b422b1 1782out_free:
54ceac45 1783 nfs_free_server(server);
29eb981a 1784 goto out;
54ceac45
DH		 1785
1786error_splat_super:
1787 up_write(&s->s_umount);
1788 deactivate_super(s);
29eb981a 1789 goto out;
f7b422b1
DH		 1790}
1791
1792static void nfs4_kill_super(struct super_block *sb)
1793{
1794 struct nfs_server *server = NFS_SB(sb);
1795
1796 nfs_return_all_delegations(sb);
1797 kill_anon_super(sb);
1798
1799 nfs4_renewd_prepare_shutdown(server);
54ceac45 1800 nfs_free_server(server);
f7b422b1
DH		 1801}
1802
1803/*
54ceac45 1804 * Clone an NFS4 server record on xdev traversal (FSID-change)
f7b422b1 1805 */
54ceac45
DH		 1806static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
1807 const char *dev_name, void *raw_data,
1808 struct vfsmount *mnt)
f7b422b1 1809{
54ceac45
DH		 1810 struct nfs_clone_mount *data = raw_data;
1811 struct super_block *s;
1812 struct nfs_server *server;
1813 struct dentry *mntroot;
75180df2 1814 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
e89a5a43
TM		 1815 struct nfs_sb_mountdata sb_mntdata = {
1816 .mntflags = flags,
1817 };
54ceac45 1818 int error;
f7b422b1 1819
54ceac45 1820 dprintk("--> nfs4_xdev_get_sb()\n");
f7b422b1 1821
54ceac45
DH		 1822 /* create a new volume representation */
1823 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
1824 if (IS_ERR(server)) {
1825 error = PTR_ERR(server);
1826 goto out_err_noserver;
f7b422b1 1827 }
e89a5a43 1828 sb_mntdata.server = server;
f7b422b1 1829
75180df2
TM		 1830 if (server->flags & NFS4_MOUNT_UNSHARED)
1831 compare_super = NULL;
1832
54ceac45 1833 /* Get a superblock - note that we may end up sharing one that already exists */
e89a5a43 1834 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
54ceac45
DH		 1835 if (IS_ERR(s)) {
1836 error = PTR_ERR(s);
1837 goto out_err_nosb;
f7b422b1 1838 }
f7b422b1 1839
54ceac45
DH		 1840 if (s->s_fs_info != server) {
1841 nfs_free_server(server);
1842 server = NULL;
1843 }
f7b422b1 1844
54ceac45
DH		 1845 if (!s->s_root) {
1846 /* initial superblock/root creation */
54ceac45
DH		 1847 nfs4_clone_super(s, data->sb);
1848 }
f7b422b1 1849
54ceac45
DH		 1850 mntroot = nfs4_get_root(s, data->fh);
1851 if (IS_ERR(mntroot)) {
1852 error = PTR_ERR(mntroot);
1853 goto error_splat_super;
1854 }
e9cc6c23
TM		 1855 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
1856 dput(mntroot);
1857 error = -ESTALE;
1858 goto error_splat_super;
1859 }
f7b422b1 1860
54ceac45
DH		 1861 s->s_flags |= MS_ACTIVE;
1862 mnt->mnt_sb = s;
1863 mnt->mnt_root = mntroot;
1864
1865 dprintk("<-- nfs4_xdev_get_sb() = 0\n");
1866 return 0;
1867
1868out_err_nosb:
1869 nfs_free_server(server);
1870out_err_noserver:
1871 dprintk("<-- nfs4_xdev_get_sb() = %d [error]\n", error);
1872 return error;
1873
1874error_splat_super:
1875 up_write(&s->s_umount);
1876 deactivate_super(s);
1877 dprintk("<-- nfs4_xdev_get_sb() = %d [splat]\n", error);
1878 return error;
f7b422b1
DH		 1879}
1880
54ceac45
DH		 1881/*
1882 * Create an NFS4 server record on referral traversal
1883 */
1884static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
1885 const char *dev_name, void *raw_data,
1886 struct vfsmount *mnt)
f7b422b1
DH		 1887{
1888 struct nfs_clone_mount *data = raw_data;
54ceac45
DH		 1889 struct super_block *s;
1890 struct nfs_server *server;
1891 struct dentry *mntroot;
1892 struct nfs_fh mntfh;
75180df2 1893 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
e89a5a43
TM		 1894 struct nfs_sb_mountdata sb_mntdata = {
1895 .mntflags = flags,
1896 };
54ceac45
DH		 1897 int error;
1898
1899 dprintk("--> nfs4_referral_get_sb()\n");
1900
1901 /* create a new volume representation */
1902 server = nfs4_create_referral_server(data, &mntfh);
1903 if (IS_ERR(server)) {
1904 error = PTR_ERR(server);
1905 goto out_err_noserver;
1906 }
e89a5a43 1907 sb_mntdata.server = server;
54ceac45 1908
75180df2
TM		 1909 if (server->flags & NFS4_MOUNT_UNSHARED)
1910 compare_super = NULL;
1911
54ceac45 1912 /* Get a superblock - note that we may end up sharing one that already exists */
e89a5a43 1913 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
54ceac45
DH		 1914 if (IS_ERR(s)) {
1915 error = PTR_ERR(s);
1916 goto out_err_nosb;
1917 }
1918
1919 if (s->s_fs_info != server) {
1920 nfs_free_server(server);
1921 server = NULL;
1922 }
1923
1924 if (!s->s_root) {
1925 /* initial superblock/root creation */
54ceac45
DH		 1926 nfs4_fill_super(s);
1927 }
1928
f2d0d85e 1929 mntroot = nfs4_get_root(s, &mntfh);
54ceac45
DH		 1930 if (IS_ERR(mntroot)) {
1931 error = PTR_ERR(mntroot);
1932 goto error_splat_super;
1933 }
e9cc6c23
TM		 1934 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
1935 dput(mntroot);
1936 error = -ESTALE;
1937 goto error_splat_super;
1938 }
54ceac45
DH		 1939
1940 s->s_flags |= MS_ACTIVE;
1941 mnt->mnt_sb = s;
1942 mnt->mnt_root = mntroot;
1943
1944 dprintk("<-- nfs4_referral_get_sb() = 0\n");
1945 return 0;
1946
1947out_err_nosb:
1948 nfs_free_server(server);
1949out_err_noserver:
1950 dprintk("<-- nfs4_referral_get_sb() = %d [error]\n", error);
1951 return error;
1952
1953error_splat_super:
1954 up_write(&s->s_umount);
1955 deactivate_super(s);
1956 dprintk("<-- nfs4_referral_get_sb() = %d [splat]\n", error);
1957 return error;
f7b422b1
DH		 1958}
1959
54ceac45 1960#endif /* CONFIG_NFS_V4 */
Linux kernel - Deliverables
This page took 0.272205 seconds and 5 git commands to generate.