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