blob: b961ceac66b43ade04dc3cc960e1e382530f8e66 [file] [log] [blame]
David Howellsf7b422b2006-06-09 09:34:33 -04001/*
2 * linux/fs/nfs/super.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs superblock handling functions
7 *
Alan Cox526719b2008-10-27 15:19:48 +00008 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
David Howellsf7b422b2006-06-09 09:34:33 -04009 * 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 *
David Howells54ceac42006-08-22 20:06:13 -040016 * - 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())
David Howellsf7b422b2006-06-09 09:34:33 -040021 */
22
David Howellsf7b422b2006-06-09 09:34:33 -040023#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>
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -040036#include <linux/sunrpc/xprtsock.h>
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -040037#include <linux/sunrpc/xprtrdma.h>
David Howellsf7b422b2006-06-09 09:34:33 -040038#include <linux/nfs_fs.h>
39#include <linux/nfs_mount.h>
40#include <linux/nfs4_mount.h>
41#include <linux/lockd/bind.h>
David Howellsf7b422b2006-06-09 09:34:33 -040042#include <linux/seq_file.h>
43#include <linux/mount.h>
Trond Myklebustc02d7ad2009-06-22 15:09:14 -040044#include <linux/mnt_namespace.h>
45#include <linux/namei.h>
David Howellsf7b422b2006-06-09 09:34:33 -040046#include <linux/nfs_idmap.h>
47#include <linux/vfs.h>
48#include <linux/inet.h>
Chuck Leverfd00a8f2007-12-10 14:57:38 -050049#include <linux/in6.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090050#include <linux/slab.h>
Chuck Leverfd00a8f2007-12-10 14:57:38 -050051#include <net/ipv6.h>
Chuck Leverd8e77482008-06-23 12:37:01 -040052#include <linux/netdevice.h>
David Howellsf7b422b2006-06-09 09:34:33 -040053#include <linux/nfs_xdr.h>
Adrian Bunkb5d5dfb2007-02-12 00:53:40 -080054#include <linux/magic.h>
Chuck Leverbf0fd762007-07-01 12:13:44 -040055#include <linux/parser.h>
David Howellsf7b422b2006-06-09 09:34:33 -040056
57#include <asm/system.h>
58#include <asm/uaccess.h>
59
60#include "nfs4_fs.h"
61#include "callback.h"
62#include "delegation.h"
63#include "iostat.h"
64#include "internal.h"
David Howells08734042009-04-03 16:42:42 +010065#include "fscache.h"
J. Bruce Fieldsae50c0b2011-05-22 19:48:21 +030066#include "pnfs.h"
David Howellsf7b422b2006-06-09 09:34:33 -040067
68#define NFSDBG_FACILITY NFSDBG_VFS
69
Paulius Zaleckas1e657bd2010-10-31 18:21:05 +020070#ifdef CONFIG_NFS_V3
71#define NFS_DEFAULT_VERSION 3
72#else
73#define NFS_DEFAULT_VERSION 2
74#endif
75
Chuck Leverbf0fd762007-07-01 12:13:44 -040076enum {
77 /* Mount options that take no arguments */
78 Opt_soft, Opt_hard,
Chuck Leverbf0fd762007-07-01 12:13:44 -040079 Opt_posix, Opt_noposix,
80 Opt_cto, Opt_nocto,
81 Opt_ac, Opt_noac,
82 Opt_lock, Opt_nolock,
Chuck Lever764302c2009-09-08 19:50:03 -040083 Opt_v2, Opt_v3, Opt_v4,
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -040084 Opt_udp, Opt_tcp, Opt_rdma,
Chuck Leverbf0fd762007-07-01 12:13:44 -040085 Opt_acl, Opt_noacl,
86 Opt_rdirplus, Opt_nordirplus,
Trond Myklebust75180df2007-05-16 16:53:28 -040087 Opt_sharecache, Opt_nosharecache,
Chuck Leverd7403512008-12-23 15:21:37 -050088 Opt_resvport, Opt_noresvport,
David Howellsb797cac2009-04-03 16:42:48 +010089 Opt_fscache, Opt_nofscache,
Chuck Leverbf0fd762007-07-01 12:13:44 -040090
91 /* Mount options that take integer arguments */
92 Opt_port,
93 Opt_rsize, Opt_wsize, Opt_bsize,
94 Opt_timeo, Opt_retrans,
95 Opt_acregmin, Opt_acregmax,
96 Opt_acdirmin, Opt_acdirmax,
97 Opt_actimeo,
98 Opt_namelen,
99 Opt_mountport,
Chuck Levere887cbc2007-10-26 13:32:29 -0400100 Opt_mountvers,
Chuck Leverad879ce2007-10-26 13:32:24 -0400101 Opt_nfsvers,
Mike Sager3fd5be92009-04-01 09:21:48 -0400102 Opt_minorversion,
Chuck Leverbf0fd762007-07-01 12:13:44 -0400103
104 /* Mount options that take string arguments */
Chuck Lever33832032007-12-10 14:59:13 -0500105 Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
Chuck Lever0ac83772007-09-11 18:01:04 -0400106 Opt_addr, Opt_mountaddr, Opt_clientaddr,
Trond Myklebust7973c1f12008-07-15 17:58:14 -0400107 Opt_lookupcache,
David Howellsb797cac2009-04-03 16:42:48 +0100108 Opt_fscache_uniq,
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400109 Opt_local_lock,
Chuck Leverbf0fd762007-07-01 12:13:44 -0400110
Chuck Leverf45663c2008-06-24 19:28:02 -0400111 /* Special mount options */
112 Opt_userspace, Opt_deprecated, Opt_sloppy,
Chuck Leverbf0fd762007-07-01 12:13:44 -0400113
114 Opt_err
115};
116
Steven Whitehousea447c092008-10-13 10:46:57 +0100117static const match_table_t nfs_mount_option_tokens = {
Chuck Leverbf0fd762007-07-01 12:13:44 -0400118 { Opt_userspace, "bg" },
119 { Opt_userspace, "fg" },
Chuck Leverecbb3842008-06-12 12:37:33 -0400120 { Opt_userspace, "retry=%s" },
121
Chuck Leverf45663c2008-06-24 19:28:02 -0400122 { Opt_sloppy, "sloppy" },
123
Chuck Leverbf0fd762007-07-01 12:13:44 -0400124 { Opt_soft, "soft" },
125 { Opt_hard, "hard" },
Chuck Leverd33e4df2008-06-12 12:37:41 -0400126 { Opt_deprecated, "intr" },
127 { Opt_deprecated, "nointr" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400128 { Opt_posix, "posix" },
129 { Opt_noposix, "noposix" },
130 { Opt_cto, "cto" },
131 { Opt_nocto, "nocto" },
132 { Opt_ac, "ac" },
133 { Opt_noac, "noac" },
134 { Opt_lock, "lock" },
135 { Opt_nolock, "nolock" },
136 { Opt_v2, "v2" },
137 { Opt_v3, "v3" },
Chuck Lever764302c2009-09-08 19:50:03 -0400138 { Opt_v4, "v4" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400139 { Opt_udp, "udp" },
140 { Opt_tcp, "tcp" },
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -0400141 { Opt_rdma, "rdma" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400142 { Opt_acl, "acl" },
143 { Opt_noacl, "noacl" },
144 { Opt_rdirplus, "rdirplus" },
145 { Opt_nordirplus, "nordirplus" },
Trond Myklebust75180df2007-05-16 16:53:28 -0400146 { Opt_sharecache, "sharecache" },
147 { Opt_nosharecache, "nosharecache" },
Chuck Leverd7403512008-12-23 15:21:37 -0500148 { Opt_resvport, "resvport" },
149 { Opt_noresvport, "noresvport" },
David Howellsb797cac2009-04-03 16:42:48 +0100150 { Opt_fscache, "fsc" },
David Howellsb797cac2009-04-03 16:42:48 +0100151 { Opt_nofscache, "nofsc" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400152
Chuck Levera5a16ba2009-06-17 18:02:14 -0700153 { Opt_port, "port=%s" },
154 { Opt_rsize, "rsize=%s" },
155 { Opt_wsize, "wsize=%s" },
156 { Opt_bsize, "bsize=%s" },
157 { Opt_timeo, "timeo=%s" },
158 { Opt_retrans, "retrans=%s" },
159 { Opt_acregmin, "acregmin=%s" },
160 { Opt_acregmax, "acregmax=%s" },
161 { Opt_acdirmin, "acdirmin=%s" },
162 { Opt_acdirmax, "acdirmax=%s" },
163 { Opt_actimeo, "actimeo=%s" },
164 { Opt_namelen, "namlen=%s" },
165 { Opt_mountport, "mountport=%s" },
166 { Opt_mountvers, "mountvers=%s" },
167 { Opt_nfsvers, "nfsvers=%s" },
168 { Opt_nfsvers, "vers=%s" },
Chuck Leverf3f4f4e2009-08-09 15:09:29 -0400169 { Opt_minorversion, "minorversion=%s" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400170
171 { Opt_sec, "sec=%s" },
172 { Opt_proto, "proto=%s" },
173 { Opt_mountproto, "mountproto=%s" },
174 { Opt_addr, "addr=%s" },
175 { Opt_clientaddr, "clientaddr=%s" },
Chuck Lever33832032007-12-10 14:59:13 -0500176 { Opt_mounthost, "mounthost=%s" },
Chuck Lever0ac83772007-09-11 18:01:04 -0400177 { Opt_mountaddr, "mountaddr=%s" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400178
Trond Myklebust7973c1f12008-07-15 17:58:14 -0400179 { Opt_lookupcache, "lookupcache=%s" },
Chuck Levera6d5ff62010-05-07 13:33:58 -0400180 { Opt_fscache_uniq, "fsc=%s" },
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400181 { Opt_local_lock, "local_lock=%s" },
Trond Myklebust7973c1f12008-07-15 17:58:14 -0400182
Chuck Leverbf0fd762007-07-01 12:13:44 -0400183 { Opt_err, NULL }
184};
185
186enum {
Jeff Laytonee671b02009-12-03 15:58:56 -0500187 Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
Chuck Leverbf0fd762007-07-01 12:13:44 -0400188
189 Opt_xprt_err
190};
191
Steven Whitehousea447c092008-10-13 10:46:57 +0100192static const match_table_t nfs_xprt_protocol_tokens = {
Chuck Leverbf0fd762007-07-01 12:13:44 -0400193 { Opt_xprt_udp, "udp" },
Jeff Laytonee671b02009-12-03 15:58:56 -0500194 { Opt_xprt_udp6, "udp6" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400195 { Opt_xprt_tcp, "tcp" },
Jeff Laytonee671b02009-12-03 15:58:56 -0500196 { Opt_xprt_tcp6, "tcp6" },
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -0400197 { Opt_xprt_rdma, "rdma" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400198
199 { Opt_xprt_err, NULL }
200};
201
202enum {
203 Opt_sec_none, Opt_sec_sys,
204 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
205 Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
206 Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
207
208 Opt_sec_err
209};
210
Steven Whitehousea447c092008-10-13 10:46:57 +0100211static const match_table_t nfs_secflavor_tokens = {
Chuck Leverbf0fd762007-07-01 12:13:44 -0400212 { Opt_sec_none, "none" },
213 { Opt_sec_none, "null" },
214 { Opt_sec_sys, "sys" },
215
216 { Opt_sec_krb5, "krb5" },
217 { Opt_sec_krb5i, "krb5i" },
218 { Opt_sec_krb5p, "krb5p" },
219
220 { Opt_sec_lkey, "lkey" },
221 { Opt_sec_lkeyi, "lkeyi" },
222 { Opt_sec_lkeyp, "lkeyp" },
223
Olga Kornievskaia8d042212008-02-13 16:47:06 -0500224 { Opt_sec_spkm, "spkm3" },
225 { Opt_sec_spkmi, "spkm3i" },
226 { Opt_sec_spkmp, "spkm3p" },
227
Chuck Leverbf0fd762007-07-01 12:13:44 -0400228 { Opt_sec_err, NULL }
229};
230
Trond Myklebust7973c1f12008-07-15 17:58:14 -0400231enum {
232 Opt_lookupcache_all, Opt_lookupcache_positive,
233 Opt_lookupcache_none,
234
235 Opt_lookupcache_err
236};
237
238static match_table_t nfs_lookupcache_tokens = {
239 { Opt_lookupcache_all, "all" },
240 { Opt_lookupcache_positive, "pos" },
241 { Opt_lookupcache_positive, "positive" },
242 { Opt_lookupcache_none, "none" },
243
244 { Opt_lookupcache_err, NULL }
245};
246
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400247enum {
248 Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
249 Opt_local_lock_none,
250
251 Opt_local_lock_err
252};
253
254static match_table_t nfs_local_lock_tokens = {
255 { Opt_local_lock_all, "all" },
256 { Opt_local_lock_flock, "flock" },
257 { Opt_local_lock_posix, "posix" },
258 { Opt_local_lock_none, "none" },
259
260 { Opt_local_lock_err, NULL }
261};
262
Chuck Leverbf0fd762007-07-01 12:13:44 -0400263
Al Viro42faad92008-04-24 07:21:56 -0400264static void nfs_umount_begin(struct super_block *);
Trond Myklebust816724e2006-06-24 08:41:41 -0400265static int nfs_statfs(struct dentry *, struct kstatfs *);
David Howellsf7b422b2006-06-09 09:34:33 -0400266static int nfs_show_options(struct seq_file *, struct vfsmount *);
Al Viroc7f404b2011-03-16 06:59:40 -0400267static int nfs_show_devname(struct seq_file *, struct vfsmount *);
268static int nfs_show_path(struct seq_file *, struct vfsmount *);
David Howellsf7b422b2006-06-09 09:34:33 -0400269static int nfs_show_stats(struct seq_file *, struct vfsmount *);
Al Viro01194982011-03-16 07:25:36 -0400270static struct dentry *nfs_fs_mount(struct file_system_type *,
271 int, const char *, void *);
Al Viro31f43472010-10-29 03:38:12 -0400272static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
273 int flags, const char *dev_name, void *raw_data);
Trond Myklebust387c1492010-02-03 08:27:35 -0500274static void nfs_put_super(struct super_block *);
David Howellsf7b422b2006-06-09 09:34:33 -0400275static void nfs_kill_super(struct super_block *);
Jeff Layton48b605f2008-06-10 15:38:39 -0400276static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
David Howellsf7b422b2006-06-09 09:34:33 -0400277
278static struct file_system_type nfs_fs_type = {
279 .owner = THIS_MODULE,
280 .name = "nfs",
Al Viro01194982011-03-16 07:25:36 -0400281 .mount = nfs_fs_mount,
David Howellsf7b422b2006-06-09 09:34:33 -0400282 .kill_sb = nfs_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700283 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400284};
285
David Howells54ceac42006-08-22 20:06:13 -0400286struct file_system_type nfs_xdev_fs_type = {
David Howellsf7b422b2006-06-09 09:34:33 -0400287 .owner = THIS_MODULE,
288 .name = "nfs",
Al Viro31f43472010-10-29 03:38:12 -0400289 .mount = nfs_xdev_mount,
David Howellsf7b422b2006-06-09 09:34:33 -0400290 .kill_sb = nfs_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700291 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400292};
293
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800294static const struct super_operations nfs_sops = {
David Howellsf7b422b2006-06-09 09:34:33 -0400295 .alloc_inode = nfs_alloc_inode,
296 .destroy_inode = nfs_destroy_inode,
297 .write_inode = nfs_write_inode,
Trond Myklebust387c1492010-02-03 08:27:35 -0500298 .put_super = nfs_put_super,
David Howellsf7b422b2006-06-09 09:34:33 -0400299 .statfs = nfs_statfs,
Al Virob57922d2010-06-07 14:34:48 -0400300 .evict_inode = nfs_evict_inode,
David Howellsf7b422b2006-06-09 09:34:33 -0400301 .umount_begin = nfs_umount_begin,
302 .show_options = nfs_show_options,
Al Viroc7f404b2011-03-16 06:59:40 -0400303 .show_devname = nfs_show_devname,
304 .show_path = nfs_show_path,
David Howellsf7b422b2006-06-09 09:34:33 -0400305 .show_stats = nfs_show_stats,
Jeff Layton48b605f2008-06-10 15:38:39 -0400306 .remount_fs = nfs_remount,
David Howellsf7b422b2006-06-09 09:34:33 -0400307};
308
309#ifdef CONFIG_NFS_V4
Chuck Lever7630c852009-09-08 19:49:57 -0400310static int nfs4_validate_text_mount_data(void *options,
311 struct nfs_parsed_mount_data *args, const char *dev_name);
Al Viro01194982011-03-16 07:25:36 -0400312static struct dentry *nfs4_try_mount(int flags, const char *dev_name,
313 struct nfs_parsed_mount_data *data);
314static struct dentry *nfs4_mount(struct file_system_type *fs_type,
315 int flags, const char *dev_name, void *raw_data);
Al Viro31f43472010-10-29 03:38:12 -0400316static struct dentry *nfs4_remote_mount(struct file_system_type *fs_type,
317 int flags, const char *dev_name, void *raw_data);
318static struct dentry *nfs4_xdev_mount(struct file_system_type *fs_type,
319 int flags, const char *dev_name, void *raw_data);
Al Viro01194982011-03-16 07:25:36 -0400320static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
321 int flags, const char *dev_name, void *raw_data);
Al Viro31f43472010-10-29 03:38:12 -0400322static struct dentry *nfs4_remote_referral_mount(struct file_system_type *fs_type,
323 int flags, const char *dev_name, void *raw_data);
David Howellsf7b422b2006-06-09 09:34:33 -0400324static void nfs4_kill_super(struct super_block *sb);
325
326static struct file_system_type nfs4_fs_type = {
327 .owner = THIS_MODULE,
328 .name = "nfs4",
Al Viro01194982011-03-16 07:25:36 -0400329 .mount = nfs4_mount,
David Howellsf7b422b2006-06-09 09:34:33 -0400330 .kill_sb = nfs4_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700331 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400332};
333
Trond Myklebustc02d7ad2009-06-22 15:09:14 -0400334static struct file_system_type nfs4_remote_fs_type = {
335 .owner = THIS_MODULE,
336 .name = "nfs4",
Al Viro31f43472010-10-29 03:38:12 -0400337 .mount = nfs4_remote_mount,
Trond Myklebustc02d7ad2009-06-22 15:09:14 -0400338 .kill_sb = nfs4_kill_super,
339 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
340};
341
David Howells54ceac42006-08-22 20:06:13 -0400342struct file_system_type nfs4_xdev_fs_type = {
David Howellsf7b422b2006-06-09 09:34:33 -0400343 .owner = THIS_MODULE,
344 .name = "nfs4",
Al Viro31f43472010-10-29 03:38:12 -0400345 .mount = nfs4_xdev_mount,
David Howellsf7b422b2006-06-09 09:34:33 -0400346 .kill_sb = nfs4_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700347 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400348};
349
Trond Myklebustc02d7ad2009-06-22 15:09:14 -0400350static struct file_system_type nfs4_remote_referral_fs_type = {
351 .owner = THIS_MODULE,
352 .name = "nfs4",
Al Viro31f43472010-10-29 03:38:12 -0400353 .mount = nfs4_remote_referral_mount,
Trond Myklebustc02d7ad2009-06-22 15:09:14 -0400354 .kill_sb = nfs4_kill_super,
355 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
356};
357
David Howells54ceac42006-08-22 20:06:13 -0400358struct file_system_type nfs4_referral_fs_type = {
David Howellsf7b422b2006-06-09 09:34:33 -0400359 .owner = THIS_MODULE,
360 .name = "nfs4",
Al Viro01194982011-03-16 07:25:36 -0400361 .mount = nfs4_referral_mount,
David Howellsf7b422b2006-06-09 09:34:33 -0400362 .kill_sb = nfs4_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700363 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400364};
365
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800366static const struct super_operations nfs4_sops = {
David Howellsf7b422b2006-06-09 09:34:33 -0400367 .alloc_inode = nfs_alloc_inode,
368 .destroy_inode = nfs_destroy_inode,
369 .write_inode = nfs_write_inode,
Trond Myklebust387c1492010-02-03 08:27:35 -0500370 .put_super = nfs_put_super,
David Howellsf7b422b2006-06-09 09:34:33 -0400371 .statfs = nfs_statfs,
Al Virob57922d2010-06-07 14:34:48 -0400372 .evict_inode = nfs4_evict_inode,
David Howellsf7b422b2006-06-09 09:34:33 -0400373 .umount_begin = nfs_umount_begin,
374 .show_options = nfs_show_options,
Al Viroc7f404b2011-03-16 06:59:40 -0400375 .show_devname = nfs_show_devname,
376 .show_path = nfs_show_path,
David Howellsf7b422b2006-06-09 09:34:33 -0400377 .show_stats = nfs_show_stats,
Jeff Layton48b605f2008-06-10 15:38:39 -0400378 .remount_fs = nfs_remount,
David Howellsf7b422b2006-06-09 09:34:33 -0400379};
380#endif
381
Rusty Russell8e1f9362007-07-17 04:03:17 -0700382static struct shrinker acl_shrinker = {
383 .shrink = nfs_access_cache_shrinker,
384 .seeks = DEFAULT_SEEKS,
385};
Trond Myklebust979df722006-07-25 11:28:19 -0400386
David Howellsf7b422b2006-06-09 09:34:33 -0400387/*
388 * Register the NFS filesystems
389 */
390int __init register_nfs_fs(void)
391{
392 int ret;
393
394 ret = register_filesystem(&nfs_fs_type);
395 if (ret < 0)
396 goto error_0;
397
David Howellsf7b422b2006-06-09 09:34:33 -0400398 ret = nfs_register_sysctl();
399 if (ret < 0)
400 goto error_1;
Peter Zijlstra89a09142007-03-16 13:38:26 -0800401#ifdef CONFIG_NFS_V4
David Howellsf7b422b2006-06-09 09:34:33 -0400402 ret = register_filesystem(&nfs4_fs_type);
403 if (ret < 0)
404 goto error_2;
405#endif
Rusty Russell8e1f9362007-07-17 04:03:17 -0700406 register_shrinker(&acl_shrinker);
David Howellsf7b422b2006-06-09 09:34:33 -0400407 return 0;
408
409#ifdef CONFIG_NFS_V4
410error_2:
411 nfs_unregister_sysctl();
Peter Zijlstra89a09142007-03-16 13:38:26 -0800412#endif
David Howellsf7b422b2006-06-09 09:34:33 -0400413error_1:
414 unregister_filesystem(&nfs_fs_type);
David Howellsf7b422b2006-06-09 09:34:33 -0400415error_0:
416 return ret;
417}
418
419/*
420 * Unregister the NFS filesystems
421 */
422void __exit unregister_nfs_fs(void)
423{
Rusty Russell8e1f9362007-07-17 04:03:17 -0700424 unregister_shrinker(&acl_shrinker);
David Howellsf7b422b2006-06-09 09:34:33 -0400425#ifdef CONFIG_NFS_V4
426 unregister_filesystem(&nfs4_fs_type);
David Howellsf7b422b2006-06-09 09:34:33 -0400427#endif
Alexey Dobriyan49af7ee2007-09-18 22:46:40 -0700428 nfs_unregister_sysctl();
David Howellsf7b422b2006-06-09 09:34:33 -0400429 unregister_filesystem(&nfs_fs_type);
430}
431
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400432void nfs_sb_active(struct super_block *sb)
Steve Dicksonef818a22007-11-08 04:05:04 -0500433{
434 struct nfs_server *server = NFS_SB(sb);
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400435
436 if (atomic_inc_return(&server->active) == 1)
437 atomic_inc(&sb->s_active);
438}
439
440void nfs_sb_deactive(struct super_block *sb)
441{
442 struct nfs_server *server = NFS_SB(sb);
443
444 if (atomic_dec_and_test(&server->active))
445 deactivate_super(sb);
Steve Dicksonef818a22007-11-08 04:05:04 -0500446}
447
David Howellsf7b422b2006-06-09 09:34:33 -0400448/*
449 * Deliver file system statistics to userspace
450 */
Trond Myklebust816724e2006-06-24 08:41:41 -0400451static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
David Howellsf7b422b2006-06-09 09:34:33 -0400452{
David Howells0c7d90c2006-08-22 20:06:10 -0400453 struct nfs_server *server = NFS_SB(dentry->d_sb);
David Howellsf7b422b2006-06-09 09:34:33 -0400454 unsigned char blockbits;
455 unsigned long blockres;
David Howells0c7d90c2006-08-22 20:06:10 -0400456 struct nfs_fh *fh = NFS_FH(dentry->d_inode);
Trond Myklebustca7e9a02010-04-16 16:22:52 -0400457 struct nfs_fsstat res;
458 int error = -ENOMEM;
459
460 res.fattr = nfs_alloc_fattr();
461 if (res.fattr == NULL)
462 goto out_err;
David Howellsf7b422b2006-06-09 09:34:33 -0400463
David Howells8fa5c002006-08-22 20:06:12 -0400464 error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
Menyhart Zoltanfbf3fdd2010-09-12 19:55:26 -0400465 if (unlikely(error == -ESTALE)) {
466 struct dentry *pd_dentry;
Trond Myklebustca7e9a02010-04-16 16:22:52 -0400467
Menyhart Zoltanfbf3fdd2010-09-12 19:55:26 -0400468 pd_dentry = dget_parent(dentry);
469 if (pd_dentry != NULL) {
470 nfs_zap_caches(pd_dentry->d_inode);
471 dput(pd_dentry);
472 }
473 }
Trond Myklebustca7e9a02010-04-16 16:22:52 -0400474 nfs_free_fattr(res.fattr);
David Howellsf7b422b2006-06-09 09:34:33 -0400475 if (error < 0)
476 goto out_err;
Trond Myklebustca7e9a02010-04-16 16:22:52 -0400477
Amnon Aaronsohn1a0ba9a2007-04-09 22:05:26 -0700478 buf->f_type = NFS_SUPER_MAGIC;
David Howellsf7b422b2006-06-09 09:34:33 -0400479
480 /*
481 * Current versions of glibc do not correctly handle the
482 * case where f_frsize != f_bsize. Eventually we want to
483 * report the value of wtmult in this field.
484 */
David Howells0c7d90c2006-08-22 20:06:10 -0400485 buf->f_frsize = dentry->d_sb->s_blocksize;
David Howellsf7b422b2006-06-09 09:34:33 -0400486
487 /*
488 * On most *nix systems, f_blocks, f_bfree, and f_bavail
489 * are reported in units of f_frsize. Linux hasn't had
490 * an f_frsize field in its statfs struct until recently,
491 * thus historically Linux's sys_statfs reports these
492 * fields in units of f_bsize.
493 */
David Howells0c7d90c2006-08-22 20:06:10 -0400494 buf->f_bsize = dentry->d_sb->s_blocksize;
495 blockbits = dentry->d_sb->s_blocksize_bits;
David Howellsf7b422b2006-06-09 09:34:33 -0400496 blockres = (1 << blockbits) - 1;
497 buf->f_blocks = (res.tbytes + blockres) >> blockbits;
498 buf->f_bfree = (res.fbytes + blockres) >> blockbits;
499 buf->f_bavail = (res.abytes + blockres) >> blockbits;
500
501 buf->f_files = res.tfiles;
502 buf->f_ffree = res.afiles;
503
504 buf->f_namelen = server->namelen;
Amnon Aaronsohn1a0ba9a2007-04-09 22:05:26 -0700505
David Howellsf7b422b2006-06-09 09:34:33 -0400506 return 0;
507
508 out_err:
Harvey Harrison3110ff82008-05-02 13:42:44 -0700509 dprintk("%s: statfs error = %d\n", __func__, -error);
Amnon Aaronsohn1a0ba9a2007-04-09 22:05:26 -0700510 return error;
David Howellsf7b422b2006-06-09 09:34:33 -0400511}
512
David Howells7d4e2742006-08-22 20:06:07 -0400513/*
514 * Map the security flavour number to a name
515 */
Trond Myklebust81039f12006-06-09 09:34:34 -0400516static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
517{
David Howells7d4e2742006-08-22 20:06:07 -0400518 static const struct {
Trond Myklebust81039f12006-06-09 09:34:34 -0400519 rpc_authflavor_t flavour;
520 const char *str;
521 } sec_flavours[] = {
522 { RPC_AUTH_NULL, "null" },
523 { RPC_AUTH_UNIX, "sys" },
524 { RPC_AUTH_GSS_KRB5, "krb5" },
525 { RPC_AUTH_GSS_KRB5I, "krb5i" },
526 { RPC_AUTH_GSS_KRB5P, "krb5p" },
527 { RPC_AUTH_GSS_LKEY, "lkey" },
528 { RPC_AUTH_GSS_LKEYI, "lkeyi" },
529 { RPC_AUTH_GSS_LKEYP, "lkeyp" },
530 { RPC_AUTH_GSS_SPKM, "spkm" },
531 { RPC_AUTH_GSS_SPKMI, "spkmi" },
532 { RPC_AUTH_GSS_SPKMP, "spkmp" },
Chuck Lever4d81cd12007-07-01 12:12:40 -0400533 { UINT_MAX, "unknown" }
Trond Myklebust81039f12006-06-09 09:34:34 -0400534 };
535 int i;
536
Chuck Lever4d81cd12007-07-01 12:12:40 -0400537 for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
Trond Myklebust81039f12006-06-09 09:34:34 -0400538 if (sec_flavours[i].flavour == flavour)
539 break;
540 }
541 return sec_flavours[i].str;
542}
543
Jeff Laytonee671b02009-12-03 15:58:56 -0500544static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss,
545 int showdefaults)
546{
547 struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address;
548
549 seq_printf(m, ",mountproto=");
550 switch (sap->sa_family) {
551 case AF_INET:
552 switch (nfss->mountd_protocol) {
553 case IPPROTO_UDP:
554 seq_printf(m, RPCBIND_NETID_UDP);
555 break;
556 case IPPROTO_TCP:
557 seq_printf(m, RPCBIND_NETID_TCP);
558 break;
559 default:
560 if (showdefaults)
561 seq_printf(m, "auto");
562 }
563 break;
564 case AF_INET6:
565 switch (nfss->mountd_protocol) {
566 case IPPROTO_UDP:
567 seq_printf(m, RPCBIND_NETID_UDP6);
568 break;
569 case IPPROTO_TCP:
570 seq_printf(m, RPCBIND_NETID_TCP6);
571 break;
572 default:
573 if (showdefaults)
574 seq_printf(m, "auto");
575 }
576 break;
577 default:
578 if (showdefaults)
579 seq_printf(m, "auto");
580 }
581}
582
Chuck Lever82d101d2008-03-14 14:10:37 -0400583static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
584 int showdefaults)
585{
586 struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;
587
Bryan Schumakerd5eff1a2010-08-03 13:04:00 -0400588 if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE)
589 return;
590
Chuck Lever82d101d2008-03-14 14:10:37 -0400591 switch (sap->sa_family) {
592 case AF_INET: {
593 struct sockaddr_in *sin = (struct sockaddr_in *)sap;
Harvey Harrisonbe859402008-10-31 00:56:28 -0700594 seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr);
Chuck Lever82d101d2008-03-14 14:10:37 -0400595 break;
596 }
597 case AF_INET6: {
598 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
Chuck Leverd250e192009-12-03 15:58:56 -0500599 seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr);
Chuck Lever82d101d2008-03-14 14:10:37 -0400600 break;
601 }
602 default:
603 if (showdefaults)
604 seq_printf(m, ",mountaddr=unspecified");
605 }
606
607 if (nfss->mountd_version || showdefaults)
608 seq_printf(m, ",mountvers=%u", nfss->mountd_version);
Stanislav Kinsburskyaa699472010-12-08 12:40:13 +0300609 if ((nfss->mountd_port &&
610 nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) ||
611 showdefaults)
Chuck Lever82d101d2008-03-14 14:10:37 -0400612 seq_printf(m, ",mountport=%u", nfss->mountd_port);
613
Jeff Laytonee671b02009-12-03 15:58:56 -0500614 nfs_show_mountd_netid(m, nfss, showdefaults);
Chuck Lever82d101d2008-03-14 14:10:37 -0400615}
616
Trond Myklebust0be81892010-06-18 12:23:58 -0400617#ifdef CONFIG_NFS_V4
618static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
619 int showdefaults)
620{
621 struct nfs_client *clp = nfss->nfs_client;
622
623 seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
624 seq_printf(m, ",minorversion=%u", clp->cl_minorversion);
625}
626#else
627static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
628 int showdefaults)
629{
630}
631#endif
632
David Howellsf7b422b2006-06-09 09:34:33 -0400633/*
634 * Describe the mount options in force on this server representation
635 */
Chuck Lever82d101d2008-03-14 14:10:37 -0400636static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
637 int showdefaults)
David Howellsf7b422b2006-06-09 09:34:33 -0400638{
David Howells509de812006-08-22 20:06:11 -0400639 static const struct proc_nfs_info {
David Howellsf7b422b2006-06-09 09:34:33 -0400640 int flag;
David Howells509de812006-08-22 20:06:11 -0400641 const char *str;
642 const char *nostr;
David Howellsf7b422b2006-06-09 09:34:33 -0400643 } nfs_info[] = {
644 { NFS_MOUNT_SOFT, ",soft", ",hard" },
Chuck Lever82d101d2008-03-14 14:10:37 -0400645 { NFS_MOUNT_POSIX, ",posix", "" },
David Howellsf7b422b2006-06-09 09:34:33 -0400646 { NFS_MOUNT_NOCTO, ",nocto", "" },
647 { NFS_MOUNT_NOAC, ",noac", "" },
648 { NFS_MOUNT_NONLM, ",nolock", "" },
649 { NFS_MOUNT_NOACL, ",noacl", "" },
Steve Dickson74dd34e2007-04-14 17:01:15 -0400650 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
Chuck Leverd7403512008-12-23 15:21:37 -0500651 { NFS_MOUNT_UNSHARED, ",nosharecache", "" },
652 { NFS_MOUNT_NORESVPORT, ",noresvport", "" },
David Howellsf7b422b2006-06-09 09:34:33 -0400653 { 0, NULL, NULL }
654 };
David Howells509de812006-08-22 20:06:11 -0400655 const struct proc_nfs_info *nfs_infop;
David Howells8fa5c002006-08-22 20:06:12 -0400656 struct nfs_client *clp = nfss->nfs_client;
Chuck Lever82d101d2008-03-14 14:10:37 -0400657 u32 version = clp->rpc_ops->version;
Suresh Jayaraman7c563cc2010-09-23 14:26:48 -0400658 int local_flock, local_fcntl;
David Howellsf7b422b2006-06-09 09:34:33 -0400659
Chuck Lever82d101d2008-03-14 14:10:37 -0400660 seq_printf(m, ",vers=%u", version);
Chuck Lever2d767432008-03-14 14:10:08 -0400661 seq_printf(m, ",rsize=%u", nfss->rsize);
662 seq_printf(m, ",wsize=%u", nfss->wsize);
Chuck Lever82d101d2008-03-14 14:10:37 -0400663 if (nfss->bsize != 0)
664 seq_printf(m, ",bsize=%u", nfss->bsize);
665 seq_printf(m, ",namlen=%u", nfss->namelen);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400666 if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400667 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400668 if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400669 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400670 if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400671 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400672 if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400673 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
David Howellsf7b422b2006-06-09 09:34:33 -0400674 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
675 if (nfss->flags & nfs_infop->flag)
676 seq_puts(m, nfs_infop->str);
677 else
678 seq_puts(m, nfs_infop->nostr);
679 }
\"Talpey, Thomas\56928ed2007-09-10 13:48:47 -0400680 seq_printf(m, ",proto=%s",
Jeff Laytonee671b02009-12-03 15:58:56 -0500681 rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
Chuck Lever82d101d2008-03-14 14:10:37 -0400682 if (version == 4) {
683 if (nfss->port != NFS_PORT)
684 seq_printf(m, ",port=%u", nfss->port);
685 } else
686 if (nfss->port)
687 seq_printf(m, ",port=%u", nfss->port);
688
Trond Myklebust33170232007-12-20 16:03:59 -0500689 seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
690 seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
Trond Myklebust81039f12006-06-09 09:34:34 -0400691 seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
Chuck Lever82d101d2008-03-14 14:10:37 -0400692
693 if (version != 4)
694 nfs_show_mountd_options(m, nfss, showdefaults);
Trond Myklebust0be81892010-06-18 12:23:58 -0400695 else
696 nfs_show_nfsv4_options(m, nfss, showdefaults);
Chuck Lever82d101d2008-03-14 14:10:37 -0400697
David Howellsb797cac2009-04-03 16:42:48 +0100698 if (nfss->options & NFS_OPTION_FSCACHE)
699 seq_printf(m, ",fsc");
Patrick J. LoPresti9b00c642010-08-10 17:28:01 -0400700
701 if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
702 if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
703 seq_printf(m, ",lookupcache=none");
704 else
705 seq_printf(m, ",lookupcache=pos");
706 }
Suresh Jayaraman7c563cc2010-09-23 14:26:48 -0400707
708 local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
709 local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;
710
711 if (!local_flock && !local_fcntl)
712 seq_printf(m, ",local_lock=none");
713 else if (local_flock && local_fcntl)
714 seq_printf(m, ",local_lock=all");
715 else if (local_flock)
716 seq_printf(m, ",local_lock=flock");
717 else
718 seq_printf(m, ",local_lock=posix");
David Howellsf7b422b2006-06-09 09:34:33 -0400719}
720
721/*
722 * Describe the mount options on this VFS mountpoint
723 */
724static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
725{
726 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
727
728 nfs_show_mount_options(m, nfss, 0);
729
Chuck Lever5d8515c2007-12-10 14:57:16 -0500730 seq_printf(m, ",addr=%s",
731 rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
732 RPC_DISPLAY_ADDR));
David Howellsf7b422b2006-06-09 09:34:33 -0400733
734 return 0;
735}
J. Bruce Fieldsae50c0b2011-05-22 19:48:21 +0300736#ifdef CONFIG_NFS_V4_1
737void show_sessions(struct seq_file *m, struct nfs_server *server)
738{
739 if (nfs4_has_session(server->nfs_client))
740 seq_printf(m, ",sessions");
741}
742#else
743void show_sessions(struct seq_file *m, struct nfs_server *server) {}
744#endif
745
746#ifdef CONFIG_NFS_V4_1
747void show_pnfs(struct seq_file *m, struct nfs_server *server)
748{
749 seq_printf(m, ",pnfs=");
750 if (server->pnfs_curr_ld)
751 seq_printf(m, "%s", server->pnfs_curr_ld->name);
752 else
753 seq_printf(m, "not configured");
754}
755#else /* CONFIG_NFS_V4_1 */
756void show_pnfs(struct seq_file *m, struct nfs_server *server) {}
757#endif /* CONFIG_NFS_V4_1 */
David Howellsf7b422b2006-06-09 09:34:33 -0400758
Al Viroc7f404b2011-03-16 06:59:40 -0400759static int nfs_show_devname(struct seq_file *m, struct vfsmount *mnt)
760{
761 char *page = (char *) __get_free_page(GFP_KERNEL);
762 char *devname, *dummy;
763 int err = 0;
764 if (!page)
765 return -ENOMEM;
766 devname = nfs_path(&dummy, mnt->mnt_root, page, PAGE_SIZE);
767 if (IS_ERR(devname))
768 err = PTR_ERR(devname);
769 else
770 seq_escape(m, devname, " \t\n\\");
771 free_page((unsigned long)page);
772 return err;
773}
774
775static int nfs_show_path(struct seq_file *m, struct vfsmount *mnt)
776{
777 seq_puts(m, "/");
778 return 0;
779}
780
David Howellsf7b422b2006-06-09 09:34:33 -0400781/*
782 * Present statistical information for this VFS mountpoint
783 */
784static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
785{
786 int i, cpu;
787 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
788 struct rpc_auth *auth = nfss->client->cl_auth;
789 struct nfs_iostats totals = { };
790
791 seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
792
793 /*
794 * Display all mount option settings
795 */
796 seq_printf(m, "\n\topts:\t");
797 seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
798 seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
799 seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
800 seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
801 nfs_show_mount_options(m, nfss, 1);
802
803 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
804
805 seq_printf(m, "\n\tcaps:\t");
806 seq_printf(m, "caps=0x%x", nfss->caps);
Chuck Lever2d767432008-03-14 14:10:08 -0400807 seq_printf(m, ",wtmult=%u", nfss->wtmult);
808 seq_printf(m, ",dtsize=%u", nfss->dtsize);
809 seq_printf(m, ",bsize=%u", nfss->bsize);
810 seq_printf(m, ",namlen=%u", nfss->namelen);
David Howellsf7b422b2006-06-09 09:34:33 -0400811
812#ifdef CONFIG_NFS_V4
Trond Myklebust40c553192007-12-14 14:56:07 -0500813 if (nfss->nfs_client->rpc_ops->version == 4) {
David Howellsf7b422b2006-06-09 09:34:33 -0400814 seq_printf(m, "\n\tnfsv4:\t");
815 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
816 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
817 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
J. Bruce Fieldsae50c0b2011-05-22 19:48:21 +0300818 show_sessions(m, nfss);
819 show_pnfs(m, nfss);
David Howellsf7b422b2006-06-09 09:34:33 -0400820 }
821#endif
822
823 /*
824 * Display security flavor in effect for this mount
825 */
Chuck Lever2d767432008-03-14 14:10:08 -0400826 seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
David Howellsf7b422b2006-06-09 09:34:33 -0400827 if (auth->au_flavor)
Chuck Lever2d767432008-03-14 14:10:08 -0400828 seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
David Howellsf7b422b2006-06-09 09:34:33 -0400829
830 /*
831 * Display superblock I/O counters
832 */
833 for_each_possible_cpu(cpu) {
834 struct nfs_iostats *stats;
835
836 preempt_disable();
837 stats = per_cpu_ptr(nfss->io_stats, cpu);
838
839 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
840 totals.events[i] += stats->events[i];
841 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
842 totals.bytes[i] += stats->bytes[i];
David Howells6a510912009-04-03 16:42:43 +0100843#ifdef CONFIG_NFS_FSCACHE
844 for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
845 totals.fscache[i] += stats->fscache[i];
846#endif
David Howellsf7b422b2006-06-09 09:34:33 -0400847
848 preempt_enable();
849 }
850
851 seq_printf(m, "\n\tevents:\t");
852 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
853 seq_printf(m, "%lu ", totals.events[i]);
854 seq_printf(m, "\n\tbytes:\t");
855 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
856 seq_printf(m, "%Lu ", totals.bytes[i]);
David Howells6a510912009-04-03 16:42:43 +0100857#ifdef CONFIG_NFS_FSCACHE
858 if (nfss->options & NFS_OPTION_FSCACHE) {
859 seq_printf(m, "\n\tfsc:\t");
860 for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
861 seq_printf(m, "%Lu ", totals.bytes[i]);
862 }
863#endif
David Howellsf7b422b2006-06-09 09:34:33 -0400864 seq_printf(m, "\n");
865
866 rpc_print_iostats(m, nfss->client);
867
868 return 0;
869}
870
871/*
872 * Begin unmount by attempting to remove all automounted mountpoints we added
David Howells54ceac42006-08-22 20:06:13 -0400873 * in response to xdev traversals and referrals
David Howellsf7b422b2006-06-09 09:34:33 -0400874 */
Al Viro42faad92008-04-24 07:21:56 -0400875static void nfs_umount_begin(struct super_block *sb)
David Howellsf7b422b2006-06-09 09:34:33 -0400876{
Alessio Igor Bogani67e55202009-04-24 09:06:53 +0200877 struct nfs_server *server;
Trond Myklebustfc6ae3c2007-06-05 19:13:47 -0400878 struct rpc_clnt *rpc;
879
Alessio Igor Bogani67e55202009-04-24 09:06:53 +0200880 server = NFS_SB(sb);
Trond Myklebustfc6ae3c2007-06-05 19:13:47 -0400881 /* -EIO all pending I/O */
882 rpc = server->client_acl;
883 if (!IS_ERR(rpc))
884 rpc_killall_tasks(rpc);
885 rpc = server->client;
886 if (!IS_ERR(rpc))
887 rpc_killall_tasks(rpc);
David Howellsf7b422b2006-06-09 09:34:33 -0400888}
889
Trond Myklebustc5811db2009-10-06 15:40:15 -0400890static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(unsigned int version)
Chuck Lever9423a082009-09-23 14:36:38 -0400891{
892 struct nfs_parsed_mount_data *data;
893
894 data = kzalloc(sizeof(*data), GFP_KERNEL);
895 if (data) {
Chuck Lever9423a082009-09-23 14:36:38 -0400896 data->acregmin = NFS_DEF_ACREGMIN;
897 data->acregmax = NFS_DEF_ACREGMAX;
898 data->acdirmin = NFS_DEF_ACDIRMIN;
899 data->acdirmax = NFS_DEF_ACDIRMAX;
Trond Myklebustc5811db2009-10-06 15:40:15 -0400900 data->mount_server.port = NFS_UNSPEC_PORT;
Chuck Lever9423a082009-09-23 14:36:38 -0400901 data->nfs_server.port = NFS_UNSPEC_PORT;
Trond Myklebustc5811db2009-10-06 15:40:15 -0400902 data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Lever9423a082009-09-23 14:36:38 -0400903 data->auth_flavors[0] = RPC_AUTH_UNIX;
904 data->auth_flavor_len = 1;
Trond Myklebustc5811db2009-10-06 15:40:15 -0400905 data->version = version;
Chuck Lever9423a082009-09-23 14:36:38 -0400906 data->minorversion = 0;
907 }
908 return data;
909}
910
David Howellsf7b422b2006-06-09 09:34:33 -0400911/*
Chuck Levercdcd7f92007-12-10 14:57:45 -0500912 * Sanity-check a server address provided by the mount command.
913 *
914 * Address family must be initialized, and address must not be
915 * the ANY address for that family.
Chuck Leverfc50d582007-07-01 12:12:46 -0400916 */
917static int nfs_verify_server_address(struct sockaddr *addr)
918{
919 switch (addr->sa_family) {
920 case AF_INET: {
Chuck Levercdcd7f92007-12-10 14:57:45 -0500921 struct sockaddr_in *sa = (struct sockaddr_in *)addr;
Al Viroe6f1ceb2008-03-17 22:44:53 -0700922 return sa->sin_addr.s_addr != htonl(INADDR_ANY);
Chuck Levercdcd7f92007-12-10 14:57:45 -0500923 }
924 case AF_INET6: {
925 struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
926 return !ipv6_addr_any(sa);
Chuck Leverfc50d582007-07-01 12:12:46 -0400927 }
928 }
929
Chuck Lever53a0b9c2009-08-09 15:09:36 -0400930 dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
Chuck Leverfc50d582007-07-01 12:12:46 -0400931 return 0;
932}
933
Chuck Lever9412b922007-12-10 14:59:21 -0500934/*
Chuck Lever4cfd74f2009-09-08 19:49:47 -0400935 * Select between a default port value and a user-specified port value.
936 * If a zero value is set, then autobind will be used.
937 */
Trond Myklebustf5855fe2009-10-06 15:40:37 -0400938static void nfs_set_port(struct sockaddr *sap, int *port,
Chuck Lever4cfd74f2009-09-08 19:49:47 -0400939 const unsigned short default_port)
940{
Trond Myklebustf5855fe2009-10-06 15:40:37 -0400941 if (*port == NFS_UNSPEC_PORT)
942 *port = default_port;
Chuck Lever4cfd74f2009-09-08 19:49:47 -0400943
Trond Myklebustf5855fe2009-10-06 15:40:37 -0400944 rpc_set_port(sap, *port);
Chuck Lever4cfd74f2009-09-08 19:49:47 -0400945}
946
947/*
Trond Myklebust259875e2008-07-02 14:43:47 -0400948 * Sanity check the NFS transport protocol.
949 *
950 */
951static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
952{
953 switch (mnt->nfs_server.protocol) {
954 case XPRT_TRANSPORT_UDP:
955 case XPRT_TRANSPORT_TCP:
956 case XPRT_TRANSPORT_RDMA:
957 break;
958 default:
959 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
960 }
961}
962
963/*
964 * For text based NFSv2/v3 mounts, the mount protocol transport default
965 * settings should depend upon the specified NFS transport.
966 */
967static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
968{
969 nfs_validate_transport_protocol(mnt);
970
971 if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
972 mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
973 return;
974 switch (mnt->nfs_server.protocol) {
975 case XPRT_TRANSPORT_UDP:
976 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
977 break;
978 case XPRT_TRANSPORT_TCP:
979 case XPRT_TRANSPORT_RDMA:
980 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
981 }
982}
983
984/*
Chuck Lever01060c82008-06-24 16:33:38 -0400985 * Parse the value of the 'sec=' option.
Chuck Lever01060c82008-06-24 16:33:38 -0400986 */
987static int nfs_parse_security_flavors(char *value,
988 struct nfs_parsed_mount_data *mnt)
989{
990 substring_t args[MAX_OPT_ARGS];
991
992 dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
993
994 switch (match_token(value, nfs_secflavor_tokens, args)) {
995 case Opt_sec_none:
Chuck Lever01060c82008-06-24 16:33:38 -0400996 mnt->auth_flavors[0] = RPC_AUTH_NULL;
997 break;
998 case Opt_sec_sys:
Chuck Lever01060c82008-06-24 16:33:38 -0400999 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
1000 break;
1001 case Opt_sec_krb5:
Chuck Lever01060c82008-06-24 16:33:38 -04001002 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
1003 break;
1004 case Opt_sec_krb5i:
Chuck Lever01060c82008-06-24 16:33:38 -04001005 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
1006 break;
1007 case Opt_sec_krb5p:
Chuck Lever01060c82008-06-24 16:33:38 -04001008 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
1009 break;
1010 case Opt_sec_lkey:
Chuck Lever01060c82008-06-24 16:33:38 -04001011 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
1012 break;
1013 case Opt_sec_lkeyi:
Chuck Lever01060c82008-06-24 16:33:38 -04001014 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
1015 break;
1016 case Opt_sec_lkeyp:
Chuck Lever01060c82008-06-24 16:33:38 -04001017 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
1018 break;
1019 case Opt_sec_spkm:
Chuck Lever01060c82008-06-24 16:33:38 -04001020 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
1021 break;
1022 case Opt_sec_spkmi:
Chuck Lever01060c82008-06-24 16:33:38 -04001023 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
1024 break;
1025 case Opt_sec_spkmp:
Chuck Lever01060c82008-06-24 16:33:38 -04001026 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
1027 break;
1028 default:
1029 return 0;
1030 }
1031
Bryan Schumaker9b7160c2011-04-13 14:31:30 -04001032 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
Chuck Lever059f90b2009-08-09 15:09:31 -04001033 mnt->auth_flavor_len = 1;
Chuck Lever01060c82008-06-24 16:33:38 -04001034 return 1;
1035}
1036
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001037static int nfs_get_option_str(substring_t args[], char **option)
1038{
1039 kfree(*option);
1040 *option = match_strdup(args);
1041 return !option;
1042}
1043
1044static int nfs_get_option_ul(substring_t args[], unsigned long *option)
1045{
1046 int rc;
1047 char *string;
1048
1049 string = match_strdup(args);
1050 if (string == NULL)
1051 return -ENOMEM;
1052 rc = strict_strtoul(string, 10, option);
1053 kfree(string);
1054
1055 return rc;
1056}
1057
Chuck Lever01060c82008-06-24 16:33:38 -04001058/*
Chuck Leverbf0fd762007-07-01 12:13:44 -04001059 * Error-check and convert a string of mount options from user space into
Chuck Leverf45663c2008-06-24 19:28:02 -04001060 * a data structure. The whole mount string is processed; bad options are
1061 * skipped as they are encountered. If there were no errors, return 1;
1062 * otherwise return 0 (zero).
Chuck Leverbf0fd762007-07-01 12:13:44 -04001063 */
1064static int nfs_parse_mount_options(char *raw,
1065 struct nfs_parsed_mount_data *mnt)
1066{
Eric Parisf9c3a382008-03-05 14:20:18 -05001067 char *p, *string, *secdata;
Chuck Leverd23c45f2009-06-17 18:02:13 -07001068 int rc, sloppy = 0, invalid_option = 0;
Jeff Laytonee671b02009-12-03 15:58:56 -05001069 unsigned short protofamily = AF_UNSPEC;
1070 unsigned short mountfamily = AF_UNSPEC;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001071
1072 if (!raw) {
1073 dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
1074 return 1;
1075 }
1076 dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
1077
Eric Parisf9c3a382008-03-05 14:20:18 -05001078 secdata = alloc_secdata();
1079 if (!secdata)
1080 goto out_nomem;
1081
1082 rc = security_sb_copy_data(raw, secdata);
1083 if (rc)
1084 goto out_security_failure;
1085
1086 rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
1087 if (rc)
1088 goto out_security_failure;
1089
1090 free_secdata(secdata);
1091
Chuck Leverbf0fd762007-07-01 12:13:44 -04001092 while ((p = strsep(&raw, ",")) != NULL) {
1093 substring_t args[MAX_OPT_ARGS];
Chuck Levera5a16ba2009-06-17 18:02:14 -07001094 unsigned long option;
1095 int token;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001096
1097 if (!*p)
1098 continue;
1099
1100 dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
1101
1102 token = match_token(p, nfs_mount_option_tokens, args);
1103 switch (token) {
Chuck Leverf45663c2008-06-24 19:28:02 -04001104
1105 /*
1106 * boolean options: foo/nofoo
1107 */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001108 case Opt_soft:
1109 mnt->flags |= NFS_MOUNT_SOFT;
1110 break;
1111 case Opt_hard:
1112 mnt->flags &= ~NFS_MOUNT_SOFT;
1113 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001114 case Opt_posix:
1115 mnt->flags |= NFS_MOUNT_POSIX;
1116 break;
1117 case Opt_noposix:
1118 mnt->flags &= ~NFS_MOUNT_POSIX;
1119 break;
1120 case Opt_cto:
1121 mnt->flags &= ~NFS_MOUNT_NOCTO;
1122 break;
1123 case Opt_nocto:
1124 mnt->flags |= NFS_MOUNT_NOCTO;
1125 break;
1126 case Opt_ac:
1127 mnt->flags &= ~NFS_MOUNT_NOAC;
1128 break;
1129 case Opt_noac:
1130 mnt->flags |= NFS_MOUNT_NOAC;
1131 break;
1132 case Opt_lock:
1133 mnt->flags &= ~NFS_MOUNT_NONLM;
Suresh Jayaraman5eebde22010-09-23 08:55:58 -04001134 mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
1135 NFS_MOUNT_LOCAL_FCNTL);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001136 break;
1137 case Opt_nolock:
1138 mnt->flags |= NFS_MOUNT_NONLM;
Suresh Jayaraman5eebde22010-09-23 08:55:58 -04001139 mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
1140 NFS_MOUNT_LOCAL_FCNTL);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001141 break;
1142 case Opt_v2:
1143 mnt->flags &= ~NFS_MOUNT_VER3;
Chuck Lever764302c2009-09-08 19:50:03 -04001144 mnt->version = 2;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001145 break;
1146 case Opt_v3:
1147 mnt->flags |= NFS_MOUNT_VER3;
Chuck Lever764302c2009-09-08 19:50:03 -04001148 mnt->version = 3;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001149 break;
Chuck Lever764302c2009-09-08 19:50:03 -04001150 case Opt_v4:
1151 mnt->flags &= ~NFS_MOUNT_VER3;
1152 mnt->version = 4;
1153 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001154 case Opt_udp:
1155 mnt->flags &= ~NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001156 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001157 break;
1158 case Opt_tcp:
1159 mnt->flags |= NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001160 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001161 break;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001162 case Opt_rdma:
1163 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
1164 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
Tom Talpeya67d18f2009-03-11 14:37:56 -04001165 xprt_load_transport(p);
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001166 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001167 case Opt_acl:
1168 mnt->flags &= ~NFS_MOUNT_NOACL;
1169 break;
1170 case Opt_noacl:
1171 mnt->flags |= NFS_MOUNT_NOACL;
1172 break;
1173 case Opt_rdirplus:
1174 mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
1175 break;
1176 case Opt_nordirplus:
1177 mnt->flags |= NFS_MOUNT_NORDIRPLUS;
1178 break;
Trond Myklebust75180df2007-05-16 16:53:28 -04001179 case Opt_sharecache:
1180 mnt->flags &= ~NFS_MOUNT_UNSHARED;
1181 break;
1182 case Opt_nosharecache:
1183 mnt->flags |= NFS_MOUNT_UNSHARED;
1184 break;
Chuck Leverd7403512008-12-23 15:21:37 -05001185 case Opt_resvport:
1186 mnt->flags &= ~NFS_MOUNT_NORESVPORT;
1187 break;
1188 case Opt_noresvport:
1189 mnt->flags |= NFS_MOUNT_NORESVPORT;
1190 break;
David Howellsb797cac2009-04-03 16:42:48 +01001191 case Opt_fscache:
1192 mnt->options |= NFS_OPTION_FSCACHE;
1193 kfree(mnt->fscache_uniq);
1194 mnt->fscache_uniq = NULL;
1195 break;
1196 case Opt_nofscache:
1197 mnt->options &= ~NFS_OPTION_FSCACHE;
1198 kfree(mnt->fscache_uniq);
1199 mnt->fscache_uniq = NULL;
1200 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001201
Chuck Leverf45663c2008-06-24 19:28:02 -04001202 /*
1203 * options that take numeric values
1204 */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001205 case Opt_port:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001206 if (nfs_get_option_ul(args, &option) ||
1207 option > USHRT_MAX)
Chuck Leverd23c45f2009-06-17 18:02:13 -07001208 goto out_invalid_value;
1209 mnt->nfs_server.port = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001210 break;
1211 case Opt_rsize:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001212 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001213 goto out_invalid_value;
1214 mnt->rsize = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001215 break;
1216 case Opt_wsize:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001217 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001218 goto out_invalid_value;
1219 mnt->wsize = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001220 break;
1221 case Opt_bsize:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001222 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001223 goto out_invalid_value;
1224 mnt->bsize = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001225 break;
1226 case Opt_timeo:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001227 if (nfs_get_option_ul(args, &option) || option == 0)
Chuck Leverd23c45f2009-06-17 18:02:13 -07001228 goto out_invalid_value;
1229 mnt->timeo = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001230 break;
1231 case Opt_retrans:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001232 if (nfs_get_option_ul(args, &option) || option == 0)
Chuck Leverd23c45f2009-06-17 18:02:13 -07001233 goto out_invalid_value;
1234 mnt->retrans = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001235 break;
1236 case Opt_acregmin:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001237 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001238 goto out_invalid_value;
1239 mnt->acregmin = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001240 break;
1241 case Opt_acregmax:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001242 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001243 goto out_invalid_value;
1244 mnt->acregmax = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001245 break;
1246 case Opt_acdirmin:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001247 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001248 goto out_invalid_value;
1249 mnt->acdirmin = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001250 break;
1251 case Opt_acdirmax:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001252 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001253 goto out_invalid_value;
1254 mnt->acdirmax = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001255 break;
1256 case Opt_actimeo:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001257 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001258 goto out_invalid_value;
1259 mnt->acregmin = mnt->acregmax =
1260 mnt->acdirmin = mnt->acdirmax = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001261 break;
1262 case Opt_namelen:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001263 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001264 goto out_invalid_value;
1265 mnt->namlen = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001266 break;
1267 case Opt_mountport:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001268 if (nfs_get_option_ul(args, &option) ||
1269 option > USHRT_MAX)
Chuck Leverd23c45f2009-06-17 18:02:13 -07001270 goto out_invalid_value;
1271 mnt->mount_server.port = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001272 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001273 case Opt_mountvers:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001274 if (nfs_get_option_ul(args, &option) ||
Chuck Leverf45663c2008-06-24 19:28:02 -04001275 option < NFS_MNT_VERSION ||
Chuck Leverd23c45f2009-06-17 18:02:13 -07001276 option > NFS_MNT3_VERSION)
1277 goto out_invalid_value;
1278 mnt->mount_server.version = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001279 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001280 case Opt_nfsvers:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001281 if (nfs_get_option_ul(args, &option))
Chuck Leverd23c45f2009-06-17 18:02:13 -07001282 goto out_invalid_value;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001283 switch (option) {
Chuck Leverf45663c2008-06-24 19:28:02 -04001284 case NFS2_VERSION:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001285 mnt->flags &= ~NFS_MOUNT_VER3;
Chuck Lever764302c2009-09-08 19:50:03 -04001286 mnt->version = 2;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001287 break;
Chuck Leverf45663c2008-06-24 19:28:02 -04001288 case NFS3_VERSION:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001289 mnt->flags |= NFS_MOUNT_VER3;
Chuck Lever764302c2009-09-08 19:50:03 -04001290 mnt->version = 3;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001291 break;
Chuck Lever764302c2009-09-08 19:50:03 -04001292 case NFS4_VERSION:
1293 mnt->flags &= ~NFS_MOUNT_VER3;
1294 mnt->version = 4;
1295 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001296 default:
Chuck Leverd23c45f2009-06-17 18:02:13 -07001297 goto out_invalid_value;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001298 }
1299 break;
Mike Sager3fd5be92009-04-01 09:21:48 -04001300 case Opt_minorversion:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001301 if (nfs_get_option_ul(args, &option))
Chuck Leverf3f4f4e2009-08-09 15:09:29 -04001302 goto out_invalid_value;
1303 if (option > NFS4_MAX_MINOR_VERSION)
1304 goto out_invalid_value;
1305 mnt->minorversion = option;
Mike Sager3fd5be92009-04-01 09:21:48 -04001306 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001307
Chuck Leverf45663c2008-06-24 19:28:02 -04001308 /*
1309 * options that take text values
1310 */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001311 case Opt_sec:
1312 string = match_strdup(args);
1313 if (string == NULL)
1314 goto out_nomem;
Chuck Lever01060c82008-06-24 16:33:38 -04001315 rc = nfs_parse_security_flavors(string, mnt);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001316 kfree(string);
Chuck Leverf45663c2008-06-24 19:28:02 -04001317 if (!rc) {
Chuck Leverf45663c2008-06-24 19:28:02 -04001318 dfprintk(MOUNT, "NFS: unrecognized "
1319 "security flavor\n");
Chuck Leverd23c45f2009-06-17 18:02:13 -07001320 return 0;
Chuck Leverf45663c2008-06-24 19:28:02 -04001321 }
Chuck Leverbf0fd762007-07-01 12:13:44 -04001322 break;
1323 case Opt_proto:
1324 string = match_strdup(args);
1325 if (string == NULL)
1326 goto out_nomem;
1327 token = match_token(string,
1328 nfs_xprt_protocol_tokens, args);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001329
Jeff Laytonee671b02009-12-03 15:58:56 -05001330 protofamily = AF_INET;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001331 switch (token) {
Jeff Laytonee671b02009-12-03 15:58:56 -05001332 case Opt_xprt_udp6:
1333 protofamily = AF_INET6;
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001334 case Opt_xprt_udp:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001335 mnt->flags &= ~NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001336 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001337 break;
Jeff Laytonee671b02009-12-03 15:58:56 -05001338 case Opt_xprt_tcp6:
1339 protofamily = AF_INET6;
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001340 case Opt_xprt_tcp:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001341 mnt->flags |= NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001342 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001343 break;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001344 case Opt_xprt_rdma:
1345 /* vector side protocols to TCP */
1346 mnt->flags |= NFS_MOUNT_TCP;
1347 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
Tom Talpeya67d18f2009-03-11 14:37:56 -04001348 xprt_load_transport(string);
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001349 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001350 default:
Chuck Leverf45663c2008-06-24 19:28:02 -04001351 dfprintk(MOUNT, "NFS: unrecognized "
1352 "transport protocol\n");
Yinghai Lu4223a4a2009-10-20 14:13:46 +09001353 kfree(string);
Chuck Leverd23c45f2009-06-17 18:02:13 -07001354 return 0;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001355 }
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001356 kfree(string);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001357 break;
1358 case Opt_mountproto:
1359 string = match_strdup(args);
1360 if (string == NULL)
1361 goto out_nomem;
1362 token = match_token(string,
1363 nfs_xprt_protocol_tokens, args);
Trond Myklebustd508afb2009-04-06 16:41:35 -07001364 kfree(string);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001365
Jeff Laytonee671b02009-12-03 15:58:56 -05001366 mountfamily = AF_INET;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001367 switch (token) {
Jeff Laytonee671b02009-12-03 15:58:56 -05001368 case Opt_xprt_udp6:
1369 mountfamily = AF_INET6;
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001370 case Opt_xprt_udp:
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001371 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001372 break;
Jeff Laytonee671b02009-12-03 15:58:56 -05001373 case Opt_xprt_tcp6:
1374 mountfamily = AF_INET6;
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001375 case Opt_xprt_tcp:
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001376 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001377 break;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001378 case Opt_xprt_rdma: /* not used for side protocols */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001379 default:
Chuck Leverf45663c2008-06-24 19:28:02 -04001380 dfprintk(MOUNT, "NFS: unrecognized "
1381 "transport protocol\n");
Chuck Leverd23c45f2009-06-17 18:02:13 -07001382 return 0;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001383 }
1384 break;
1385 case Opt_addr:
1386 string = match_strdup(args);
1387 if (string == NULL)
1388 goto out_nomem;
Chuck Lever53a0b9c2009-08-09 15:09:36 -04001389 mnt->nfs_server.addrlen =
1390 rpc_pton(string, strlen(string),
1391 (struct sockaddr *)
1392 &mnt->nfs_server.address,
1393 sizeof(mnt->nfs_server.address));
Chuck Leverbf0fd762007-07-01 12:13:44 -04001394 kfree(string);
Chuck Lever53a0b9c2009-08-09 15:09:36 -04001395 if (mnt->nfs_server.addrlen == 0)
1396 goto out_invalid_address;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001397 break;
1398 case Opt_clientaddr:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001399 if (nfs_get_option_str(args, &mnt->client_address))
Chuck Leverbf0fd762007-07-01 12:13:44 -04001400 goto out_nomem;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001401 break;
Chuck Lever33832032007-12-10 14:59:13 -05001402 case Opt_mounthost:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001403 if (nfs_get_option_str(args,
1404 &mnt->mount_server.hostname))
Chuck Lever33832032007-12-10 14:59:13 -05001405 goto out_nomem;
Chuck Lever33832032007-12-10 14:59:13 -05001406 break;
Chuck Lever0ac83772007-09-11 18:01:04 -04001407 case Opt_mountaddr:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001408 string = match_strdup(args);
1409 if (string == NULL)
1410 goto out_nomem;
Chuck Lever53a0b9c2009-08-09 15:09:36 -04001411 mnt->mount_server.addrlen =
1412 rpc_pton(string, strlen(string),
1413 (struct sockaddr *)
1414 &mnt->mount_server.address,
1415 sizeof(mnt->mount_server.address));
Chuck Leverbf0fd762007-07-01 12:13:44 -04001416 kfree(string);
Chuck Lever53a0b9c2009-08-09 15:09:36 -04001417 if (mnt->mount_server.addrlen == 0)
1418 goto out_invalid_address;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001419 break;
Trond Myklebust7973c1f12008-07-15 17:58:14 -04001420 case Opt_lookupcache:
1421 string = match_strdup(args);
1422 if (string == NULL)
1423 goto out_nomem;
1424 token = match_token(string,
1425 nfs_lookupcache_tokens, args);
1426 kfree(string);
1427 switch (token) {
1428 case Opt_lookupcache_all:
1429 mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
1430 break;
1431 case Opt_lookupcache_positive:
1432 mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
1433 mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
1434 break;
1435 case Opt_lookupcache_none:
1436 mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
1437 break;
1438 default:
Trond Myklebust7973c1f12008-07-15 17:58:14 -04001439 dfprintk(MOUNT, "NFS: invalid "
1440 "lookupcache argument\n");
Chuck Leverd23c45f2009-06-17 18:02:13 -07001441 return 0;
Trond Myklebust7973c1f12008-07-15 17:58:14 -04001442 };
1443 break;
Chuck Levera6d5ff62010-05-07 13:33:58 -04001444 case Opt_fscache_uniq:
Rob Landleyc5cb09b2011-03-09 16:02:37 -06001445 if (nfs_get_option_str(args, &mnt->fscache_uniq))
Chuck Levera6d5ff62010-05-07 13:33:58 -04001446 goto out_nomem;
Chuck Levera6d5ff62010-05-07 13:33:58 -04001447 mnt->options |= NFS_OPTION_FSCACHE;
1448 break;
Suresh Jayaraman5eebde22010-09-23 08:55:58 -04001449 case Opt_local_lock:
1450 string = match_strdup(args);
1451 if (string == NULL)
1452 goto out_nomem;
1453 token = match_token(string, nfs_local_lock_tokens,
1454 args);
1455 kfree(string);
1456 switch (token) {
1457 case Opt_local_lock_all:
1458 mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
1459 NFS_MOUNT_LOCAL_FCNTL);
1460 break;
1461 case Opt_local_lock_flock:
1462 mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
1463 break;
1464 case Opt_local_lock_posix:
1465 mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
1466 break;
1467 case Opt_local_lock_none:
1468 mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
1469 NFS_MOUNT_LOCAL_FCNTL);
1470 break;
1471 default:
1472 dfprintk(MOUNT, "NFS: invalid "
1473 "local_lock argument\n");
1474 return 0;
1475 };
1476 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001477
Chuck Leverf45663c2008-06-24 19:28:02 -04001478 /*
1479 * Special options
1480 */
1481 case Opt_sloppy:
1482 sloppy = 1;
1483 dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
1484 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001485 case Opt_userspace:
1486 case Opt_deprecated:
Chuck Leverd33e4df2008-06-12 12:37:41 -04001487 dfprintk(MOUNT, "NFS: ignoring mount option "
1488 "'%s'\n", p);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001489 break;
1490
1491 default:
Chuck Leverd23c45f2009-06-17 18:02:13 -07001492 invalid_option = 1;
Chuck Leverf45663c2008-06-24 19:28:02 -04001493 dfprintk(MOUNT, "NFS: unrecognized mount option "
1494 "'%s'\n", p);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001495 }
1496 }
1497
Chuck Leverd23c45f2009-06-17 18:02:13 -07001498 if (!sloppy && invalid_option)
1499 return 0;
1500
Jeff Laytonee671b02009-12-03 15:58:56 -05001501 /*
1502 * verify that any proto=/mountproto= options match the address
1503 * familiies in the addr=/mountaddr= options.
1504 */
1505 if (protofamily != AF_UNSPEC &&
1506 protofamily != mnt->nfs_server.address.ss_family)
1507 goto out_proto_mismatch;
1508
1509 if (mountfamily != AF_UNSPEC) {
1510 if (mnt->mount_server.addrlen) {
1511 if (mountfamily != mnt->mount_server.address.ss_family)
1512 goto out_mountproto_mismatch;
1513 } else {
1514 if (mountfamily != mnt->nfs_server.address.ss_family)
1515 goto out_mountproto_mismatch;
1516 }
1517 }
1518
Chuck Leverbf0fd762007-07-01 12:13:44 -04001519 return 1;
1520
Jeff Laytonee671b02009-12-03 15:58:56 -05001521out_mountproto_mismatch:
1522 printk(KERN_INFO "NFS: mount server address does not match mountproto= "
1523 "option\n");
1524 return 0;
1525out_proto_mismatch:
1526 printk(KERN_INFO "NFS: server address does not match proto= option\n");
1527 return 0;
Chuck Lever53a0b9c2009-08-09 15:09:36 -04001528out_invalid_address:
1529 printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
1530 return 0;
Chuck Leverd23c45f2009-06-17 18:02:13 -07001531out_invalid_value:
Chuck Lever53a0b9c2009-08-09 15:09:36 -04001532 printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
Chuck Leverd23c45f2009-06-17 18:02:13 -07001533 return 0;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001534out_nomem:
1535 printk(KERN_INFO "NFS: not enough memory to parse option\n");
1536 return 0;
Eric Parisf9c3a382008-03-05 14:20:18 -05001537out_security_failure:
1538 free_secdata(secdata);
1539 printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1540 return 0;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001541}
1542
1543/*
Chuck Leverec88f282009-08-09 15:09:32 -04001544 * Match the requested auth flavors with the list returned by
1545 * the server. Returns zero and sets the mount's authentication
1546 * flavor on success; returns -EACCES if server does not support
1547 * the requested flavor.
1548 */
1549static int nfs_walk_authlist(struct nfs_parsed_mount_data *args,
1550 struct nfs_mount_request *request)
1551{
1552 unsigned int i, j, server_authlist_len = *(request->auth_flav_len);
1553
1554 /*
Chuck Lever5eecfde2009-08-21 17:50:30 -04001555 * Certain releases of Linux's mountd return an empty
1556 * flavor list. To prevent behavioral regression with
1557 * these servers (ie. rejecting mounts that used to
1558 * succeed), revert to pre-2.6.32 behavior (no checking)
1559 * if the returned flavor list is empty.
1560 */
1561 if (server_authlist_len == 0)
1562 return 0;
1563
1564 /*
Chuck Leverec88f282009-08-09 15:09:32 -04001565 * We avoid sophisticated negotiating here, as there are
1566 * plenty of cases where we can get it wrong, providing
1567 * either too little or too much security.
1568 *
1569 * RFC 2623, section 2.7 suggests we SHOULD prefer the
1570 * flavor listed first. However, some servers list
1571 * AUTH_NULL first. Our caller plants AUTH_SYS, the
1572 * preferred default, in args->auth_flavors[0] if user
1573 * didn't specify sec= mount option.
1574 */
1575 for (i = 0; i < args->auth_flavor_len; i++)
1576 for (j = 0; j < server_authlist_len; j++)
1577 if (args->auth_flavors[i] == request->auth_flavs[j]) {
1578 dfprintk(MOUNT, "NFS: using auth flavor %d\n",
1579 request->auth_flavs[j]);
1580 args->auth_flavors[0] = request->auth_flavs[j];
1581 return 0;
1582 }
1583
1584 dfprintk(MOUNT, "NFS: server does not support requested auth flavor\n");
1585 nfs_umount(request);
1586 return -EACCES;
1587}
1588
1589/*
Chuck Lever0076d7b2007-07-01 12:13:49 -04001590 * Use the remote server's MOUNT service to request the NFS file handle
1591 * corresponding to the provided path.
1592 */
1593static int nfs_try_mount(struct nfs_parsed_mount_data *args,
1594 struct nfs_fh *root_fh)
1595{
Chuck Leverec88f282009-08-09 15:09:32 -04001596 rpc_authflavor_t server_authlist[NFS_MAX_SECFLAVORS];
1597 unsigned int server_authlist_len = ARRAY_SIZE(server_authlist);
Chuck Leverc5d120f2008-12-23 15:21:35 -05001598 struct nfs_mount_request request = {
1599 .sap = (struct sockaddr *)
1600 &args->mount_server.address,
1601 .dirpath = args->nfs_server.export_path,
1602 .protocol = args->mount_server.protocol,
1603 .fh = root_fh,
Chuck Lever50a737f2008-12-23 15:21:37 -05001604 .noresvport = args->flags & NFS_MOUNT_NORESVPORT,
Chuck Leverec88f282009-08-09 15:09:32 -04001605 .auth_flav_len = &server_authlist_len,
1606 .auth_flavs = server_authlist,
Chuck Leverc5d120f2008-12-23 15:21:35 -05001607 };
Chuck Lever4c568012007-12-10 14:59:28 -05001608 int status;
Chuck Lever0076d7b2007-07-01 12:13:49 -04001609
1610 if (args->mount_server.version == 0) {
Trond Myklebust8a6e5de2009-09-23 14:36:37 -04001611 switch (args->version) {
1612 default:
1613 args->mount_server.version = NFS_MNT3_VERSION;
1614 break;
1615 case 2:
1616 args->mount_server.version = NFS_MNT_VERSION;
1617 }
Chuck Lever0076d7b2007-07-01 12:13:49 -04001618 }
Chuck Leverc5d120f2008-12-23 15:21:35 -05001619 request.version = args->mount_server.version;
Chuck Lever0076d7b2007-07-01 12:13:49 -04001620
Chuck Lever33832032007-12-10 14:59:13 -05001621 if (args->mount_server.hostname)
Chuck Leverc5d120f2008-12-23 15:21:35 -05001622 request.hostname = args->mount_server.hostname;
Chuck Lever33832032007-12-10 14:59:13 -05001623 else
Chuck Leverc5d120f2008-12-23 15:21:35 -05001624 request.hostname = args->nfs_server.hostname;
Chuck Lever33832032007-12-10 14:59:13 -05001625
Chuck Lever0076d7b2007-07-01 12:13:49 -04001626 /*
1627 * Construct the mount server's address.
1628 */
Chuck Lever4c568012007-12-10 14:59:28 -05001629 if (args->mount_server.address.ss_family == AF_UNSPEC) {
Chuck Leverc5d120f2008-12-23 15:21:35 -05001630 memcpy(request.sap, &args->nfs_server.address,
Chuck Lever4c568012007-12-10 14:59:28 -05001631 args->nfs_server.addrlen);
1632 args->mount_server.addrlen = args->nfs_server.addrlen;
1633 }
Chuck Leverc5d120f2008-12-23 15:21:35 -05001634 request.salen = args->mount_server.addrlen;
Trond Myklebustf5855fe2009-10-06 15:40:37 -04001635 nfs_set_port(request.sap, &args->mount_server.port, 0);
Chuck Lever0076d7b2007-07-01 12:13:49 -04001636
1637 /*
1638 * Now ask the mount server to map our export path
1639 * to a file handle.
1640 */
Chuck Leverc5d120f2008-12-23 15:21:35 -05001641 status = nfs_mount(&request);
Chuck Leverec88f282009-08-09 15:09:32 -04001642 if (status != 0) {
1643 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
1644 request.hostname, status);
1645 return status;
1646 }
Chuck Lever0076d7b2007-07-01 12:13:49 -04001647
Chuck Leverec88f282009-08-09 15:09:32 -04001648 /*
1649 * MNTv1 (NFSv2) does not support auth flavor negotiation.
1650 */
1651 if (args->mount_server.version != NFS_MNT3_VERSION)
1652 return 0;
1653 return nfs_walk_authlist(args, &request);
Chuck Lever0076d7b2007-07-01 12:13:49 -04001654}
1655
Rob Landleyc12bace2011-03-09 15:54:13 -06001656/*
1657 * Split "dev_name" into "hostname:export_path".
1658 *
1659 * The leftmost colon demarks the split between the server's hostname
1660 * and the export path. If the hostname starts with a left square
1661 * bracket, then it may contain colons.
1662 *
1663 * Note: caller frees hostname and export path, even on error.
1664 */
1665static int nfs_parse_devname(const char *dev_name,
1666 char **hostname, size_t maxnamlen,
1667 char **export_path, size_t maxpathlen)
Chuck Leverdc045892008-06-23 12:36:37 -04001668{
1669 size_t len;
Rob Landleyc12bace2011-03-09 15:54:13 -06001670 char *end;
Chuck Leverdc045892008-06-23 12:36:37 -04001671
Rob Landleyc12bace2011-03-09 15:54:13 -06001672 /* Is the host name protected with square brakcets? */
1673 if (*dev_name == '[') {
1674 end = strchr(++dev_name, ']');
1675 if (end == NULL || end[1] != ':')
1676 goto out_bad_devname;
Chuck Leverdc045892008-06-23 12:36:37 -04001677
Rob Landleyc12bace2011-03-09 15:54:13 -06001678 len = end - dev_name;
1679 end++;
1680 } else {
1681 char *comma;
1682
1683 end = strchr(dev_name, ':');
1684 if (end == NULL)
1685 goto out_bad_devname;
1686 len = end - dev_name;
1687
1688 /* kill possible hostname list: not supported */
1689 comma = strchr(dev_name, ',');
1690 if (comma != NULL && comma < end)
1691 *comma = 0;
1692 }
1693
Chuck Leverdc045892008-06-23 12:36:37 -04001694 if (len > maxnamlen)
1695 goto out_hostname;
1696
1697 /* N.B. caller will free nfs_server.hostname in all cases */
1698 *hostname = kstrndup(dev_name, len, GFP_KERNEL);
Rob Landleyc12bace2011-03-09 15:54:13 -06001699 if (*hostname == NULL)
Chuck Leverdc045892008-06-23 12:36:37 -04001700 goto out_nomem;
Rob Landleyc12bace2011-03-09 15:54:13 -06001701 len = strlen(++end);
Chuck Leverdc045892008-06-23 12:36:37 -04001702 if (len > maxpathlen)
1703 goto out_path;
Rob Landleyc12bace2011-03-09 15:54:13 -06001704 *export_path = kstrndup(end, len, GFP_KERNEL);
Chuck Leverdc045892008-06-23 12:36:37 -04001705 if (!*export_path)
1706 goto out_nomem;
1707
1708 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1709 return 0;
1710
1711out_bad_devname:
1712 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1713 return -EINVAL;
1714
1715out_nomem:
1716 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1717 return -ENOMEM;
1718
1719out_hostname:
1720 dfprintk(MOUNT, "NFS: server hostname too long\n");
1721 return -ENAMETOOLONG;
1722
1723out_path:
1724 dfprintk(MOUNT, "NFS: export pathname too long\n");
1725 return -ENAMETOOLONG;
1726}
1727
1728/*
David Howells54ceac42006-08-22 20:06:13 -04001729 * Validate the NFS2/NFS3 mount data
1730 * - fills in the mount root filehandle
Chuck Lever136d5582007-07-01 12:13:54 -04001731 *
1732 * For option strings, user space handles the following behaviors:
1733 *
1734 * + DNS: mapping server host name to IP address ("addr=" option)
1735 *
1736 * + failure mode: how to behave if a mount request can't be handled
1737 * immediately ("fg/bg" option)
1738 *
1739 * + retry: how often to retry a mount request ("retry=" option)
1740 *
1741 * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
1742 * mountproto=tcp after mountproto=udp, and so on
David Howellsf7b422b2006-06-09 09:34:33 -04001743 */
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001744static int nfs_validate_mount_data(void *options,
1745 struct nfs_parsed_mount_data *args,
Chuck Lever136d5582007-07-01 12:13:54 -04001746 struct nfs_fh *mntfh,
1747 const char *dev_name)
David Howellsf7b422b2006-06-09 09:34:33 -04001748{
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001749 struct nfs_mount_data *data = (struct nfs_mount_data *)options;
Chuck Lever4cfd74f2009-09-08 19:49:47 -04001750 struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
Chuck Lever136d5582007-07-01 12:13:54 -04001751
Chuck Lever5df36e72007-07-01 12:12:56 -04001752 if (data == NULL)
1753 goto out_no_data;
David Howells54ceac42006-08-22 20:06:13 -04001754
David Howellsf7b422b2006-06-09 09:34:33 -04001755 switch (data->version) {
Chuck Lever5df36e72007-07-01 12:12:56 -04001756 case 1:
1757 data->namlen = 0;
1758 case 2:
1759 data->bsize = 0;
1760 case 3:
1761 if (data->flags & NFS_MOUNT_VER3)
1762 goto out_no_v3;
1763 data->root.size = NFS2_FHSIZE;
1764 memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
1765 case 4:
1766 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1767 goto out_no_sec;
1768 case 5:
1769 memset(data->context, 0, sizeof(data->context));
1770 case 6:
Trond Myklebustb7e24452008-06-19 15:21:11 -04001771 if (data->flags & NFS_MOUNT_VER3) {
1772 if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
1773 goto out_invalid_fh;
Chuck Lever5df36e72007-07-01 12:12:56 -04001774 mntfh->size = data->root.size;
Chuck Lever764302c2009-09-08 19:50:03 -04001775 args->version = 3;
1776 } else {
Chuck Lever5df36e72007-07-01 12:12:56 -04001777 mntfh->size = NFS2_FHSIZE;
Chuck Lever764302c2009-09-08 19:50:03 -04001778 args->version = 2;
1779 }
Chuck Lever5df36e72007-07-01 12:12:56 -04001780
Chuck Lever5df36e72007-07-01 12:12:56 -04001781
1782 memcpy(mntfh->data, data->root.data, mntfh->size);
1783 if (mntfh->size < sizeof(mntfh->data))
1784 memset(mntfh->data + mntfh->size, 0,
1785 sizeof(mntfh->data) - mntfh->size);
Chuck Lever6e88e062007-09-24 15:39:50 -04001786
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001787 /*
1788 * Translate to nfs_parsed_mount_data, which nfs_fill_super
1789 * can deal with.
1790 */
Trond Myklebustff3525a2008-08-15 16:59:14 -04001791 args->flags = data->flags & NFS_MOUNT_FLAGMASK;
Bryan Schumakerd5eff1a2010-08-03 13:04:00 -04001792 args->flags |= NFS_MOUNT_LEGACY_INTERFACE;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001793 args->rsize = data->rsize;
1794 args->wsize = data->wsize;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001795 args->timeo = data->timeo;
1796 args->retrans = data->retrans;
1797 args->acregmin = data->acregmin;
1798 args->acregmax = data->acregmax;
1799 args->acdirmin = data->acdirmin;
1800 args->acdirmax = data->acdirmax;
Chuck Lever4c568012007-12-10 14:59:28 -05001801
Chuck Lever4cfd74f2009-09-08 19:49:47 -04001802 memcpy(sap, &data->addr, sizeof(data->addr));
Chuck Lever4c568012007-12-10 14:59:28 -05001803 args->nfs_server.addrlen = sizeof(data->addr);
Chuck Lever4cfd74f2009-09-08 19:49:47 -04001804 if (!nfs_verify_server_address(sap))
Chuck Lever4c568012007-12-10 14:59:28 -05001805 goto out_no_address;
1806
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001807 if (!(data->flags & NFS_MOUNT_TCP))
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001808 args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001809 /* N.B. caller will free nfs_server.hostname in all cases */
1810 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
1811 args->namlen = data->namlen;
1812 args->bsize = data->bsize;
Chuck Leverdd07c942008-06-24 16:33:46 -04001813
1814 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1815 args->auth_flavors[0] = data->pseudoflavor;
Cyrill Gorcunov63649bd2008-04-17 20:42:09 +04001816 if (!args->nfs_server.hostname)
1817 goto out_nomem;
Eric Parisf9c3a382008-03-05 14:20:18 -05001818
Suresh Jayaraman5eebde22010-09-23 08:55:58 -04001819 if (!(data->flags & NFS_MOUNT_NONLM))
1820 args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
1821 NFS_MOUNT_LOCAL_FCNTL);
1822 else
1823 args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
1824 NFS_MOUNT_LOCAL_FCNTL);
Eric Parisf9c3a382008-03-05 14:20:18 -05001825 /*
1826 * The legacy version 6 binary mount data from userspace has a
1827 * field used only to transport selinux information into the
1828 * the kernel. To continue to support that functionality we
1829 * have a touch of selinux knowledge here in the NFS code. The
1830 * userspace code converted context=blah to just blah so we are
1831 * converting back to the full string selinux understands.
1832 */
1833 if (data->context[0]){
1834#ifdef CONFIG_SECURITY_SELINUX
1835 int rc;
1836 char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
1837 if (!opts_str)
1838 return -ENOMEM;
1839 strcpy(opts_str, "context=");
1840 data->context[NFS_MAX_CONTEXT_LEN] = '\0';
1841 strcat(opts_str, &data->context[0]);
1842 rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
1843 kfree(opts_str);
1844 if (rc)
1845 return rc;
1846#else
1847 return -EINVAL;
1848#endif
1849 }
1850
Chuck Lever5df36e72007-07-01 12:12:56 -04001851 break;
Chuck Lever136d5582007-07-01 12:13:54 -04001852 default: {
Chuck Lever136d5582007-07-01 12:13:54 -04001853 int status;
Chuck Lever136d5582007-07-01 12:13:54 -04001854
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001855 if (nfs_parse_mount_options((char *)options, args) == 0)
Chuck Lever136d5582007-07-01 12:13:54 -04001856 return -EINVAL;
1857
Chuck Lever4cfd74f2009-09-08 19:49:47 -04001858 if (!nfs_verify_server_address(sap))
Chuck Lever6e88e062007-09-24 15:39:50 -04001859 goto out_no_address;
1860
Chuck Lever764302c2009-09-08 19:50:03 -04001861 if (args->version == 4)
1862#ifdef CONFIG_NFS_V4
1863 return nfs4_validate_text_mount_data(options,
1864 args, dev_name);
1865#else
1866 goto out_v4_not_compiled;
1867#endif
1868
Trond Myklebustf5855fe2009-10-06 15:40:37 -04001869 nfs_set_port(sap, &args->nfs_server.port, 0);
Chuck Levered596a82008-06-26 17:47:05 -04001870
Trond Myklebust259875e2008-07-02 14:43:47 -04001871 nfs_set_mount_transport_protocol(args);
1872
Chuck Leverdc045892008-06-23 12:36:37 -04001873 status = nfs_parse_devname(dev_name,
1874 &args->nfs_server.hostname,
1875 PAGE_SIZE,
1876 &args->nfs_server.export_path,
1877 NFS_MAXPATHLEN);
1878 if (!status)
1879 status = nfs_try_mount(args, mntfh);
Chuck Lever136d5582007-07-01 12:13:54 -04001880
Chuck Leverdc045892008-06-23 12:36:37 -04001881 kfree(args->nfs_server.export_path);
1882 args->nfs_server.export_path = NULL;
Chuck Lever136d5582007-07-01 12:13:54 -04001883
Chuck Lever136d5582007-07-01 12:13:54 -04001884 if (status)
Chuck Leverfdc6e2c2007-08-29 17:58:59 -04001885 return status;
Chuck Lever136d5582007-07-01 12:13:54 -04001886
Chuck Lever136d5582007-07-01 12:13:54 -04001887 break;
1888 }
David Howellsf7b422b2006-06-09 09:34:33 -04001889 }
David Howells54ceac42006-08-22 20:06:13 -04001890
David Howellsf7b422b2006-06-09 09:34:33 -04001891#ifndef CONFIG_NFS_V3
Trond Myklebust8a6e5de2009-09-23 14:36:37 -04001892 if (args->version == 3)
Chuck Lever5df36e72007-07-01 12:12:56 -04001893 goto out_v3_not_compiled;
1894#endif /* !CONFIG_NFS_V3 */
David Howells54ceac42006-08-22 20:06:13 -04001895
David Howells54ceac42006-08-22 20:06:13 -04001896 return 0;
Chuck Lever5df36e72007-07-01 12:12:56 -04001897
1898out_no_data:
1899 dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
1900 return -EINVAL;
1901
1902out_no_v3:
1903 dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
1904 data->version);
1905 return -EINVAL;
1906
1907out_no_sec:
1908 dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
1909 return -EINVAL;
1910
Chuck Lever5df36e72007-07-01 12:12:56 -04001911#ifndef CONFIG_NFS_V3
1912out_v3_not_compiled:
1913 dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
1914 return -EPROTONOSUPPORT;
1915#endif /* !CONFIG_NFS_V3 */
1916
Chuck Lever764302c2009-09-08 19:50:03 -04001917#ifndef CONFIG_NFS_V4
1918out_v4_not_compiled:
1919 dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
1920 return -EPROTONOSUPPORT;
1921#endif /* !CONFIG_NFS_V4 */
1922
Cyrill Gorcunov63649bd2008-04-17 20:42:09 +04001923out_nomem:
1924 dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
1925 return -ENOMEM;
1926
Chuck Lever5df36e72007-07-01 12:12:56 -04001927out_no_address:
1928 dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
1929 return -EINVAL;
1930
1931out_invalid_fh:
1932 dfprintk(MOUNT, "NFS: invalid root filehandle\n");
1933 return -EINVAL;
David Howells54ceac42006-08-22 20:06:13 -04001934}
1935
Jeff Layton48b605f2008-06-10 15:38:39 -04001936static int
1937nfs_compare_remount_data(struct nfs_server *nfss,
1938 struct nfs_parsed_mount_data *data)
1939{
1940 if (data->flags != nfss->flags ||
1941 data->rsize != nfss->rsize ||
1942 data->wsize != nfss->wsize ||
1943 data->retrans != nfss->client->cl_timeout->to_retries ||
1944 data->auth_flavors[0] != nfss->client->cl_auth->au_flavor ||
1945 data->acregmin != nfss->acregmin / HZ ||
1946 data->acregmax != nfss->acregmax / HZ ||
1947 data->acdirmin != nfss->acdirmin / HZ ||
1948 data->acdirmax != nfss->acdirmax / HZ ||
1949 data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
Trond Myklebustbcd2ea12009-10-06 15:41:22 -04001950 data->nfs_server.port != nfss->port ||
Jeff Layton48b605f2008-06-10 15:38:39 -04001951 data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
Stefan Richtera1be9ee2009-10-12 11:26:12 -04001952 !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
1953 (struct sockaddr *)&nfss->nfs_client->cl_addr))
Jeff Layton48b605f2008-06-10 15:38:39 -04001954 return -EINVAL;
1955
1956 return 0;
1957}
1958
1959static int
1960nfs_remount(struct super_block *sb, int *flags, char *raw_data)
1961{
1962 int error;
1963 struct nfs_server *nfss = sb->s_fs_info;
1964 struct nfs_parsed_mount_data *data;
1965 struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
1966 struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
Trond Myklebustcd100722008-06-17 16:12:00 -04001967 u32 nfsvers = nfss->nfs_client->rpc_ops->version;
Jeff Layton48b605f2008-06-10 15:38:39 -04001968
1969 /*
1970 * Userspace mount programs that send binary options generally send
1971 * them populated with default values. We have no way to know which
1972 * ones were explicitly specified. Fall back to legacy behavior and
1973 * just return success.
1974 */
Marc Zyngier31c94462008-07-17 13:21:55 +02001975 if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
1976 (nfsvers <= 3 && (!options || (options->version >= 1 &&
1977 options->version <= 6))))
Jeff Layton48b605f2008-06-10 15:38:39 -04001978 return 0;
1979
1980 data = kzalloc(sizeof(*data), GFP_KERNEL);
1981 if (data == NULL)
1982 return -ENOMEM;
1983
1984 /* fill out struct with values from existing mount */
1985 data->flags = nfss->flags;
1986 data->rsize = nfss->rsize;
1987 data->wsize = nfss->wsize;
1988 data->retrans = nfss->client->cl_timeout->to_retries;
1989 data->auth_flavors[0] = nfss->client->cl_auth->au_flavor;
1990 data->acregmin = nfss->acregmin / HZ;
1991 data->acregmax = nfss->acregmax / HZ;
1992 data->acdirmin = nfss->acdirmin / HZ;
1993 data->acdirmax = nfss->acdirmax / HZ;
1994 data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
Trond Myklebustbcd2ea12009-10-06 15:41:22 -04001995 data->nfs_server.port = nfss->port;
Jeff Layton48b605f2008-06-10 15:38:39 -04001996 data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
1997 memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
1998 data->nfs_server.addrlen);
1999
2000 /* overwrite those values with any that were specified */
2001 error = nfs_parse_mount_options((char *)options, data);
2002 if (error < 0)
2003 goto out;
2004
Jeff Layton26c4c172011-04-27 11:49:09 -04002005 /*
2006 * noac is a special case. It implies -o sync, but that's not
2007 * necessarily reflected in the mtab options. do_remount_sb
2008 * will clear MS_SYNCHRONOUS if -o sync wasn't specified in the
2009 * remount options, so we have to explicitly reset it.
2010 */
2011 if (data->flags & NFS_MOUNT_NOAC)
2012 *flags |= MS_SYNCHRONOUS;
2013
Jeff Layton48b605f2008-06-10 15:38:39 -04002014 /* compare new mount options with old ones */
2015 error = nfs_compare_remount_data(nfss, data);
2016out:
2017 kfree(data);
2018 return error;
2019}
2020
David Howells54ceac42006-08-22 20:06:13 -04002021/*
2022 * Initialise the common bits of the superblock
2023 */
2024static inline void nfs_initialise_sb(struct super_block *sb)
2025{
2026 struct nfs_server *server = NFS_SB(sb);
2027
2028 sb->s_magic = NFS_SUPER_MAGIC;
2029
2030 /* We probably want something more informative here */
2031 snprintf(sb->s_id, sizeof(sb->s_id),
2032 "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
2033
2034 if (sb->s_blocksize == 0)
2035 sb->s_blocksize = nfs_block_bits(server->wsize,
2036 &sb->s_blocksize_bits);
2037
2038 if (server->flags & NFS_MOUNT_NOAC)
2039 sb->s_flags |= MS_SYNCHRONOUS;
2040
Jens Axboe32a88aa2009-09-16 15:02:33 +02002041 sb->s_bdi = &server->backing_dev_info;
2042
David Howells54ceac42006-08-22 20:06:13 -04002043 nfs_super_set_maxbytes(sb, server->maxfilesize);
2044}
2045
2046/*
2047 * Finish setting up an NFS2/3 superblock
2048 */
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04002049static void nfs_fill_super(struct super_block *sb,
2050 struct nfs_parsed_mount_data *data)
David Howells54ceac42006-08-22 20:06:13 -04002051{
2052 struct nfs_server *server = NFS_SB(sb);
2053
2054 sb->s_blocksize_bits = 0;
2055 sb->s_blocksize = 0;
2056 if (data->bsize)
2057 sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
2058
Trond Myklebust8a6e5de2009-09-23 14:36:37 -04002059 if (server->nfs_client->rpc_ops->version == 3) {
David Howells54ceac42006-08-22 20:06:13 -04002060 /* The VFS shouldn't apply the umask to mode bits. We will do
2061 * so ourselves when necessary.
2062 */
2063 sb->s_flags |= MS_POSIXACL;
2064 sb->s_time_gran = 1;
2065 }
2066
2067 sb->s_op = &nfs_sops;
2068 nfs_initialise_sb(sb);
2069}
2070
2071/*
2072 * Finish setting up a cloned NFS2/3 superblock
2073 */
2074static void nfs_clone_super(struct super_block *sb,
2075 const struct super_block *old_sb)
2076{
2077 struct nfs_server *server = NFS_SB(sb);
2078
2079 sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2080 sb->s_blocksize = old_sb->s_blocksize;
2081 sb->s_maxbytes = old_sb->s_maxbytes;
2082
Trond Myklebust8a6e5de2009-09-23 14:36:37 -04002083 if (server->nfs_client->rpc_ops->version == 3) {
David Howells54ceac42006-08-22 20:06:13 -04002084 /* The VFS shouldn't apply the umask to mode bits. We will do
2085 * so ourselves when necessary.
2086 */
2087 sb->s_flags |= MS_POSIXACL;
2088 sb->s_time_gran = 1;
2089 }
2090
2091 sb->s_op = old_sb->s_op;
2092 nfs_initialise_sb(sb);
2093}
2094
Trond Myklebust275a5d22007-05-16 16:53:28 -04002095static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
2096{
2097 const struct nfs_server *a = s->s_fs_info;
2098 const struct rpc_clnt *clnt_a = a->client;
2099 const struct rpc_clnt *clnt_b = b->client;
2100
2101 if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
2102 goto Ebusy;
2103 if (a->nfs_client != b->nfs_client)
2104 goto Ebusy;
2105 if (a->flags != b->flags)
2106 goto Ebusy;
2107 if (a->wsize != b->wsize)
2108 goto Ebusy;
2109 if (a->rsize != b->rsize)
2110 goto Ebusy;
2111 if (a->acregmin != b->acregmin)
2112 goto Ebusy;
2113 if (a->acregmax != b->acregmax)
2114 goto Ebusy;
2115 if (a->acdirmin != b->acdirmin)
2116 goto Ebusy;
2117 if (a->acdirmax != b->acdirmax)
2118 goto Ebusy;
2119 if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
2120 goto Ebusy;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002121 return 1;
Trond Myklebust275a5d22007-05-16 16:53:28 -04002122Ebusy:
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002123 return 0;
2124}
2125
2126struct nfs_sb_mountdata {
2127 struct nfs_server *server;
2128 int mntflags;
2129};
2130
2131static int nfs_set_super(struct super_block *s, void *data)
2132{
2133 struct nfs_sb_mountdata *sb_mntdata = data;
2134 struct nfs_server *server = sb_mntdata->server;
2135 int ret;
2136
2137 s->s_flags = sb_mntdata->mntflags;
2138 s->s_fs_info = server;
Al Viro8b244ff2010-12-18 11:29:39 -05002139 s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002140 ret = set_anon_super(s, server);
2141 if (ret == 0)
2142 server->s_dev = s->s_dev;
2143 return ret;
2144}
2145
Chuck Leverfd00a8f2007-12-10 14:57:38 -05002146static int nfs_compare_super_address(struct nfs_server *server1,
2147 struct nfs_server *server2)
2148{
2149 struct sockaddr *sap1, *sap2;
2150
2151 sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
2152 sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
2153
2154 if (sap1->sa_family != sap2->sa_family)
2155 return 0;
2156
2157 switch (sap1->sa_family) {
2158 case AF_INET: {
2159 struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
2160 struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
2161 if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
2162 return 0;
2163 if (sin1->sin_port != sin2->sin_port)
2164 return 0;
2165 break;
2166 }
2167 case AF_INET6: {
2168 struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
2169 struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
2170 if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
2171 return 0;
2172 if (sin1->sin6_port != sin2->sin6_port)
2173 return 0;
2174 break;
2175 }
2176 default:
2177 return 0;
2178 }
2179
2180 return 1;
2181}
2182
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002183static int nfs_compare_super(struct super_block *sb, void *data)
2184{
2185 struct nfs_sb_mountdata *sb_mntdata = data;
2186 struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
2187 int mntflags = sb_mntdata->mntflags;
2188
Chuck Leverfd00a8f2007-12-10 14:57:38 -05002189 if (!nfs_compare_super_address(old, server))
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002190 return 0;
2191 /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
2192 if (old->flags & NFS_MOUNT_UNSHARED)
2193 return 0;
2194 if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
2195 return 0;
2196 return nfs_compare_mount_options(sb, server, mntflags);
Trond Myklebust275a5d22007-05-16 16:53:28 -04002197}
2198
Miklos Szeredifa799752008-04-30 00:54:33 -07002199static int nfs_bdi_register(struct nfs_server *server)
2200{
2201 return bdi_register_dev(&server->backing_dev_info, server->s_dev);
2202}
2203
Al Viro01194982011-03-16 07:25:36 -04002204static struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
2205 int flags, const char *dev_name, void *raw_data)
David Howells54ceac42006-08-22 20:06:13 -04002206{
2207 struct nfs_server *server = NULL;
2208 struct super_block *s;
Trond Myklebust33852a12008-06-19 14:20:11 -04002209 struct nfs_parsed_mount_data *data;
2210 struct nfs_fh *mntfh;
Al Viro01194982011-03-16 07:25:36 -04002211 struct dentry *mntroot = ERR_PTR(-ENOMEM);
Trond Myklebust75180df2007-05-16 16:53:28 -04002212 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002213 struct nfs_sb_mountdata sb_mntdata = {
2214 .mntflags = flags,
2215 };
Al Viro01194982011-03-16 07:25:36 -04002216 int error;
David Howells54ceac42006-08-22 20:06:13 -04002217
Paulius Zaleckas1e657bd2010-10-31 18:21:05 +02002218 data = nfs_alloc_parsed_mount_data(NFS_DEFAULT_VERSION);
Trond Myklebustb157b062010-04-19 19:05:48 -04002219 mntfh = nfs_alloc_fhandle();
Trond Myklebust33852a12008-06-19 14:20:11 -04002220 if (data == NULL || mntfh == NULL)
2221 goto out_free_fh;
2222
2223 security_init_mnt_opts(&data->lsm_opts);
Eric Parisf9c3a382008-03-05 14:20:18 -05002224
David Howells54ceac42006-08-22 20:06:13 -04002225 /* Validate the mount data */
Trond Myklebust33852a12008-06-19 14:20:11 -04002226 error = nfs_validate_mount_data(raw_data, data, mntfh, dev_name);
Al Viro01194982011-03-16 07:25:36 -04002227 if (error < 0) {
2228 mntroot = ERR_PTR(error);
Chuck Lever06559602007-07-01 12:12:35 -04002229 goto out;
Al Viro01194982011-03-16 07:25:36 -04002230 }
David Howells54ceac42006-08-22 20:06:13 -04002231
Chuck Lever764302c2009-09-08 19:50:03 -04002232#ifdef CONFIG_NFS_V4
2233 if (data->version == 4) {
Al Viro01194982011-03-16 07:25:36 -04002234 mntroot = nfs4_try_mount(flags, dev_name, data);
Chuck Lever764302c2009-09-08 19:50:03 -04002235 kfree(data->client_address);
Xiaotian Feng9699eda2010-04-22 18:56:17 +08002236 kfree(data->nfs_server.export_path);
Chuck Lever764302c2009-09-08 19:50:03 -04002237 goto out;
2238 }
2239#endif /* CONFIG_NFS_V4 */
2240
David Howells54ceac42006-08-22 20:06:13 -04002241 /* Get a volume representation */
Trond Myklebust33852a12008-06-19 14:20:11 -04002242 server = nfs_create_server(data, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002243 if (IS_ERR(server)) {
Al Viro01194982011-03-16 07:25:36 -04002244 mntroot = ERR_CAST(server);
Chuck Lever06559602007-07-01 12:12:35 -04002245 goto out;
David Howells54ceac42006-08-22 20:06:13 -04002246 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002247 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002248
Trond Myklebust75180df2007-05-16 16:53:28 -04002249 if (server->flags & NFS_MOUNT_UNSHARED)
2250 compare_super = NULL;
2251
David Howells54ceac42006-08-22 20:06:13 -04002252 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002253 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
Trond Myklebust816724e2006-06-24 08:41:41 -04002254 if (IS_ERR(s)) {
Al Viro01194982011-03-16 07:25:36 -04002255 mntroot = ERR_CAST(s);
David Howells54ceac42006-08-22 20:06:13 -04002256 goto out_err_nosb;
Trond Myklebust816724e2006-06-24 08:41:41 -04002257 }
2258
David Howells54ceac42006-08-22 20:06:13 -04002259 if (s->s_fs_info != server) {
2260 nfs_free_server(server);
2261 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002262 } else {
2263 error = nfs_bdi_register(server);
Al Viro01194982011-03-16 07:25:36 -04002264 if (error) {
2265 mntroot = ERR_PTR(error);
NeilBrowncfbc0682010-03-11 11:20:17 +11002266 goto error_splat_bdi;
Al Viro01194982011-03-16 07:25:36 -04002267 }
David Howellsf7b422b2006-06-09 09:34:33 -04002268 }
David Howells54ceac42006-08-22 20:06:13 -04002269
2270 if (!s->s_root) {
2271 /* initial superblock/root creation */
Trond Myklebust33852a12008-06-19 14:20:11 -04002272 nfs_fill_super(s, data);
Jesper Juhl160bc162011-04-10 17:57:07 +02002273 nfs_fscache_get_super_cookie(s, data->fscache_uniq, NULL);
David Howells54ceac42006-08-22 20:06:13 -04002274 }
2275
Al Viro0d5839a2011-03-16 05:27:27 -04002276 mntroot = nfs_get_root(s, mntfh, dev_name);
Al Viro01194982011-03-16 07:25:36 -04002277 if (IS_ERR(mntroot))
David Howells54ceac42006-08-22 20:06:13 -04002278 goto error_splat_super;
David Howells54ceac42006-08-22 20:06:13 -04002279
Trond Myklebust33852a12008-06-19 14:20:11 -04002280 error = security_sb_set_mnt_opts(s, &data->lsm_opts);
Eric Parisf9c3a382008-03-05 14:20:18 -05002281 if (error)
2282 goto error_splat_root;
2283
David Howellsf7b422b2006-06-09 09:34:33 -04002284 s->s_flags |= MS_ACTIVE;
Chuck Lever06559602007-07-01 12:12:35 -04002285
2286out:
Trond Myklebust33852a12008-06-19 14:20:11 -04002287 kfree(data->nfs_server.hostname);
2288 kfree(data->mount_server.hostname);
David Howells08734042009-04-03 16:42:42 +01002289 kfree(data->fscache_uniq);
Trond Myklebust33852a12008-06-19 14:20:11 -04002290 security_free_mnt_opts(&data->lsm_opts);
2291out_free_fh:
Trond Myklebustb157b062010-04-19 19:05:48 -04002292 nfs_free_fhandle(mntfh);
Trond Myklebust33852a12008-06-19 14:20:11 -04002293 kfree(data);
Al Viro01194982011-03-16 07:25:36 -04002294 return mntroot;
Trond Myklebust816724e2006-06-24 08:41:41 -04002295
David Howells54ceac42006-08-22 20:06:13 -04002296out_err_nosb:
2297 nfs_free_server(server);
Chuck Lever06559602007-07-01 12:12:35 -04002298 goto out;
David Howells54ceac42006-08-22 20:06:13 -04002299
Eric Parisf9c3a382008-03-05 14:20:18 -05002300error_splat_root:
2301 dput(mntroot);
Al Viro01194982011-03-16 07:25:36 -04002302 mntroot = ERR_PTR(error);
David Howells54ceac42006-08-22 20:06:13 -04002303error_splat_super:
NeilBrowncfbc0682010-03-11 11:20:17 +11002304 if (server && !s->s_root)
2305 bdi_unregister(&server->backing_dev_info);
2306error_splat_bdi:
Al Viro6f5bbff2009-05-06 01:34:22 -04002307 deactivate_locked_super(s);
Chuck Lever06559602007-07-01 12:12:35 -04002308 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002309}
2310
David Howells54ceac42006-08-22 20:06:13 -04002311/*
Trond Myklebust387c1492010-02-03 08:27:35 -05002312 * Ensure that we unregister the bdi before kill_anon_super
2313 * releases the device name
2314 */
2315static void nfs_put_super(struct super_block *s)
2316{
2317 struct nfs_server *server = NFS_SB(s);
2318
2319 bdi_unregister(&server->backing_dev_info);
2320}
2321
2322/*
David Howells54ceac42006-08-22 20:06:13 -04002323 * Destroy an NFS2/3 superblock
2324 */
David Howellsf7b422b2006-06-09 09:34:33 -04002325static void nfs_kill_super(struct super_block *s)
2326{
2327 struct nfs_server *server = NFS_SB(s);
2328
2329 kill_anon_super(s);
David Howells08734042009-04-03 16:42:42 +01002330 nfs_fscache_release_super_cookie(s);
David Howells54ceac42006-08-22 20:06:13 -04002331 nfs_free_server(server);
David Howellsf7b422b2006-06-09 09:34:33 -04002332}
2333
David Howells54ceac42006-08-22 20:06:13 -04002334/*
2335 * Clone an NFS2/3 server record on xdev traversal (FSID-change)
2336 */
Al Viro31f43472010-10-29 03:38:12 -04002337static struct dentry *
2338nfs_xdev_mount(struct file_system_type *fs_type, int flags,
2339 const char *dev_name, void *raw_data)
David Howellsf7b422b2006-06-09 09:34:33 -04002340{
2341 struct nfs_clone_mount *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002342 struct super_block *s;
2343 struct nfs_server *server;
2344 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04002345 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002346 struct nfs_sb_mountdata sb_mntdata = {
2347 .mntflags = flags,
2348 };
David Howells54ceac42006-08-22 20:06:13 -04002349 int error;
2350
Al Viro31f43472010-10-29 03:38:12 -04002351 dprintk("--> nfs_xdev_mount()\n");
David Howells54ceac42006-08-22 20:06:13 -04002352
2353 /* create a new volume representation */
2354 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
2355 if (IS_ERR(server)) {
2356 error = PTR_ERR(server);
2357 goto out_err_noserver;
2358 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002359 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002360
Trond Myklebust75180df2007-05-16 16:53:28 -04002361 if (server->flags & NFS_MOUNT_UNSHARED)
2362 compare_super = NULL;
2363
David Howells54ceac42006-08-22 20:06:13 -04002364 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002365 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
David Howells54ceac42006-08-22 20:06:13 -04002366 if (IS_ERR(s)) {
2367 error = PTR_ERR(s);
2368 goto out_err_nosb;
2369 }
2370
2371 if (s->s_fs_info != server) {
2372 nfs_free_server(server);
2373 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002374 } else {
2375 error = nfs_bdi_register(server);
2376 if (error)
NeilBrowncfbc0682010-03-11 11:20:17 +11002377 goto error_splat_bdi;
David Howells54ceac42006-08-22 20:06:13 -04002378 }
2379
2380 if (!s->s_root) {
2381 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002382 nfs_clone_super(s, data->sb);
David Howells2df54802009-09-23 14:36:39 -04002383 nfs_fscache_get_super_cookie(s, NULL, data);
David Howells54ceac42006-08-22 20:06:13 -04002384 }
2385
Al Viro0d5839a2011-03-16 05:27:27 -04002386 mntroot = nfs_get_root(s, data->fh, dev_name);
David Howells54ceac42006-08-22 20:06:13 -04002387 if (IS_ERR(mntroot)) {
2388 error = PTR_ERR(mntroot);
2389 goto error_splat_super;
2390 }
Trond Myklebuste9cc6c22008-01-02 13:28:57 -05002391 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
Neil Brown4c1fe2f2007-11-01 16:50:20 +11002392 dput(mntroot);
2393 error = -ESTALE;
2394 goto error_splat_super;
2395 }
David Howells54ceac42006-08-22 20:06:13 -04002396
2397 s->s_flags |= MS_ACTIVE;
David Howells54ceac42006-08-22 20:06:13 -04002398
Eric Parisf9c3a382008-03-05 14:20:18 -05002399 /* clone any lsm security options from the parent to the new sb */
2400 security_sb_clone_mnt_opts(data->sb, s);
2401
Al Viro31f43472010-10-29 03:38:12 -04002402 dprintk("<-- nfs_xdev_mount() = 0\n");
2403 return mntroot;
David Howells54ceac42006-08-22 20:06:13 -04002404
2405out_err_nosb:
2406 nfs_free_server(server);
2407out_err_noserver:
Al Viro31f43472010-10-29 03:38:12 -04002408 dprintk("<-- nfs_xdev_mount() = %d [error]\n", error);
2409 return ERR_PTR(error);
David Howells54ceac42006-08-22 20:06:13 -04002410
2411error_splat_super:
NeilBrowncfbc0682010-03-11 11:20:17 +11002412 if (server && !s->s_root)
2413 bdi_unregister(&server->backing_dev_info);
2414error_splat_bdi:
Al Viro6f5bbff2009-05-06 01:34:22 -04002415 deactivate_locked_super(s);
Al Viro31f43472010-10-29 03:38:12 -04002416 dprintk("<-- nfs_xdev_mount() = %d [splat]\n", error);
2417 return ERR_PTR(error);
David Howellsf7b422b2006-06-09 09:34:33 -04002418}
2419
2420#ifdef CONFIG_NFS_V4
David Howells54ceac42006-08-22 20:06:13 -04002421
2422/*
2423 * Finish setting up a cloned NFS4 superblock
2424 */
2425static void nfs4_clone_super(struct super_block *sb,
2426 const struct super_block *old_sb)
David Howellsf7b422b2006-06-09 09:34:33 -04002427{
David Howells54ceac42006-08-22 20:06:13 -04002428 sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2429 sb->s_blocksize = old_sb->s_blocksize;
2430 sb->s_maxbytes = old_sb->s_maxbytes;
2431 sb->s_time_gran = 1;
2432 sb->s_op = old_sb->s_op;
Aneesh Kumar K.Va8a5da92010-12-09 11:35:14 +00002433 /*
2434 * The VFS shouldn't apply the umask to mode bits. We will do
2435 * so ourselves when necessary.
2436 */
2437 sb->s_flags |= MS_POSIXACL;
Aneesh Kumar K.V64c2ce82010-12-09 11:35:25 +00002438 sb->s_xattr = old_sb->s_xattr;
2439 nfs_initialise_sb(sb);
David Howellsf7b422b2006-06-09 09:34:33 -04002440}
2441
2442/*
2443 * Set up an NFS4 superblock
2444 */
David Howells54ceac42006-08-22 20:06:13 -04002445static void nfs4_fill_super(struct super_block *sb)
David Howellsf7b422b2006-06-09 09:34:33 -04002446{
David Howellsf7b422b2006-06-09 09:34:33 -04002447 sb->s_time_gran = 1;
David Howellsf7b422b2006-06-09 09:34:33 -04002448 sb->s_op = &nfs4_sops;
Aneesh Kumar K.Va8a5da92010-12-09 11:35:14 +00002449 /*
2450 * The VFS shouldn't apply the umask to mode bits. We will do
2451 * so ourselves when necessary.
2452 */
2453 sb->s_flags |= MS_POSIXACL;
Aneesh Kumar K.V64c2ce82010-12-09 11:35:25 +00002454 sb->s_xattr = nfs4_xattr_handlers;
David Howells54ceac42006-08-22 20:06:13 -04002455 nfs_initialise_sb(sb);
David Howellsf7b422b2006-06-09 09:34:33 -04002456}
2457
Trond Myklebust01c3f052009-06-17 13:22:58 -07002458static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
2459{
Suresh Jayaraman5eebde22010-09-23 08:55:58 -04002460 args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
2461 NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
Trond Myklebust01c3f052009-06-17 13:22:58 -07002462}
2463
Chuck Lever7630c852009-09-08 19:49:57 -04002464static int nfs4_validate_text_mount_data(void *options,
2465 struct nfs_parsed_mount_data *args,
2466 const char *dev_name)
2467{
2468 struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
2469
Trond Myklebustf5855fe2009-10-06 15:40:37 -04002470 nfs_set_port(sap, &args->nfs_server.port, NFS_PORT);
Chuck Lever7630c852009-09-08 19:49:57 -04002471
2472 nfs_validate_transport_protocol(args);
2473
2474 nfs4_validate_mount_flags(args);
2475
Trond Myklebust2ecda722009-09-08 19:50:07 -04002476 if (args->version != 4) {
2477 dfprintk(MOUNT,
2478 "NFS4: Illegal mount version\n");
2479 return -EINVAL;
2480 }
2481
Chuck Lever7630c852009-09-08 19:49:57 -04002482 if (args->auth_flavor_len > 1) {
2483 dfprintk(MOUNT,
2484 "NFS4: Too many RPC auth flavours specified\n");
2485 return -EINVAL;
2486 }
2487
2488 if (args->client_address == NULL) {
2489 dfprintk(MOUNT,
2490 "NFS4: mount program didn't pass callback address\n");
2491 return -EINVAL;
2492 }
2493
2494 return nfs_parse_devname(dev_name,
2495 &args->nfs_server.hostname,
2496 NFS4_MAXNAMLEN,
2497 &args->nfs_server.export_path,
2498 NFS4_MAXPATHLEN);
2499}
2500
David Howells54ceac42006-08-22 20:06:13 -04002501/*
Chuck Leverf0768eb2007-07-01 12:13:01 -04002502 * Validate NFSv4 mount options
2503 */
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002504static int nfs4_validate_mount_data(void *options,
2505 struct nfs_parsed_mount_data *args,
2506 const char *dev_name)
Chuck Leverf0768eb2007-07-01 12:13:01 -04002507{
Chuck Lever4cfd74f2009-09-08 19:49:47 -04002508 struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002509 struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002510 char *c;
2511
2512 if (data == NULL)
2513 goto out_no_data;
2514
2515 switch (data->version) {
2516 case 1:
Chuck Lever4c568012007-12-10 14:59:28 -05002517 if (data->host_addrlen > sizeof(args->nfs_server.address))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002518 goto out_no_address;
Chuck Lever4c568012007-12-10 14:59:28 -05002519 if (data->host_addrlen == 0)
2520 goto out_no_address;
2521 args->nfs_server.addrlen = data->host_addrlen;
Chuck Lever4cfd74f2009-09-08 19:49:47 -04002522 if (copy_from_user(sap, data->host_addr, data->host_addrlen))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002523 return -EFAULT;
Chuck Lever4cfd74f2009-09-08 19:49:47 -04002524 if (!nfs_verify_server_address(sap))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002525 goto out_no_address;
2526
Chuck Lever6738b252008-06-24 16:33:54 -04002527 if (data->auth_flavourlen) {
2528 if (data->auth_flavourlen > 1)
2529 goto out_inval_auth;
Trond Myklebust20c71f52007-09-20 20:23:51 -04002530 if (copy_from_user(&args->auth_flavors[0],
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002531 data->auth_flavours,
Trond Myklebust20c71f52007-09-20 20:23:51 -04002532 sizeof(args->auth_flavors[0])))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002533 return -EFAULT;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002534 }
2535
2536 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
2537 if (IS_ERR(c))
2538 return PTR_ERR(c);
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002539 args->nfs_server.hostname = c;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002540
2541 c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
2542 if (IS_ERR(c))
2543 return PTR_ERR(c);
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002544 args->nfs_server.export_path = c;
2545 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
Chuck Leverf0768eb2007-07-01 12:13:01 -04002546
2547 c = strndup_user(data->client_addr.data, 16);
2548 if (IS_ERR(c))
2549 return PTR_ERR(c);
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002550 args->client_address = c;
2551
2552 /*
2553 * Translate to nfs_parsed_mount_data, which nfs4_fill_super
2554 * can deal with.
2555 */
2556
2557 args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
2558 args->rsize = data->rsize;
2559 args->wsize = data->wsize;
2560 args->timeo = data->timeo;
2561 args->retrans = data->retrans;
2562 args->acregmin = data->acregmin;
2563 args->acregmax = data->acregmax;
2564 args->acdirmin = data->acdirmin;
2565 args->acdirmax = data->acdirmax;
2566 args->nfs_server.protocol = data->proto;
Trond Myklebust259875e2008-07-02 14:43:47 -04002567 nfs_validate_transport_protocol(args);
Chuck Leverf0768eb2007-07-01 12:13:01 -04002568
2569 break;
Chuck Lever7630c852009-09-08 19:49:57 -04002570 default:
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002571 if (nfs_parse_mount_options((char *)options, args) == 0)
Chuck Lever80071222007-07-01 12:13:59 -04002572 return -EINVAL;
2573
Chuck Lever4cfd74f2009-09-08 19:49:47 -04002574 if (!nfs_verify_server_address(sap))
Chuck Lever80071222007-07-01 12:13:59 -04002575 return -EINVAL;
Chuck Levered596a82008-06-26 17:47:05 -04002576
Chuck Lever7630c852009-09-08 19:49:57 -04002577 return nfs4_validate_text_mount_data(options, args, dev_name);
Chuck Leverf0768eb2007-07-01 12:13:01 -04002578 }
2579
2580 return 0;
2581
2582out_no_data:
2583 dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
2584 return -EINVAL;
2585
2586out_inval_auth:
2587 dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
2588 data->auth_flavourlen);
2589 return -EINVAL;
2590
2591out_no_address:
2592 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
2593 return -EINVAL;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002594}
2595
2596/*
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002597 * Get the superblock for the NFS4 root partition
David Howells54ceac42006-08-22 20:06:13 -04002598 */
Al Viro31f43472010-10-29 03:38:12 -04002599static struct dentry *
2600nfs4_remote_mount(struct file_system_type *fs_type, int flags,
2601 const char *dev_name, void *raw_data)
David Howellsf7b422b2006-06-09 09:34:33 -04002602{
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002603 struct nfs_parsed_mount_data *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002604 struct super_block *s;
2605 struct nfs_server *server;
Trond Myklebust33852a12008-06-19 14:20:11 -04002606 struct nfs_fh *mntfh;
David Howells54ceac42006-08-22 20:06:13 -04002607 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04002608 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002609 struct nfs_sb_mountdata sb_mntdata = {
2610 .mntflags = flags,
2611 };
Trond Myklebust33852a12008-06-19 14:20:11 -04002612 int error = -ENOMEM;
David Howellsf7b422b2006-06-09 09:34:33 -04002613
Trond Myklebustb157b062010-04-19 19:05:48 -04002614 mntfh = nfs_alloc_fhandle();
Trond Myklebust33852a12008-06-19 14:20:11 -04002615 if (data == NULL || mntfh == NULL)
2616 goto out_free_fh;
2617
2618 security_init_mnt_opts(&data->lsm_opts);
Eric Parisf9c3a382008-03-05 14:20:18 -05002619
David Howells54ceac42006-08-22 20:06:13 -04002620 /* Get a volume representation */
Trond Myklebust33852a12008-06-19 14:20:11 -04002621 server = nfs4_create_server(data, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002622 if (IS_ERR(server)) {
2623 error = PTR_ERR(server);
Chuck Lever29eb9812007-07-01 12:12:30 -04002624 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002625 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002626 sb_mntdata.server = server;
David Howellsf7b422b2006-06-09 09:34:33 -04002627
Trond Myklebust75180df2007-05-16 16:53:28 -04002628 if (server->flags & NFS4_MOUNT_UNSHARED)
2629 compare_super = NULL;
2630
David Howells54ceac42006-08-22 20:06:13 -04002631 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002632 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
Trond Myklebust816724e2006-06-24 08:41:41 -04002633 if (IS_ERR(s)) {
2634 error = PTR_ERR(s);
David Howellsf7b422b2006-06-09 09:34:33 -04002635 goto out_free;
Trond Myklebust816724e2006-06-24 08:41:41 -04002636 }
2637
Trond Myklebust5dd31772006-08-24 01:03:05 -04002638 if (s->s_fs_info != server) {
2639 nfs_free_server(server);
2640 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002641 } else {
2642 error = nfs_bdi_register(server);
2643 if (error)
NeilBrowncfbc0682010-03-11 11:20:17 +11002644 goto error_splat_bdi;
Trond Myklebust5dd31772006-08-24 01:03:05 -04002645 }
2646
David Howells54ceac42006-08-22 20:06:13 -04002647 if (!s->s_root) {
2648 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002649 nfs4_fill_super(s);
David Howells2df54802009-09-23 14:36:39 -04002650 nfs_fscache_get_super_cookie(
2651 s, data ? data->fscache_uniq : NULL, NULL);
Trond Myklebust816724e2006-06-24 08:41:41 -04002652 }
David Howellsf7b422b2006-06-09 09:34:33 -04002653
Al Viro0d5839a2011-03-16 05:27:27 -04002654 mntroot = nfs4_get_root(s, mntfh, dev_name);
David Howells54ceac42006-08-22 20:06:13 -04002655 if (IS_ERR(mntroot)) {
2656 error = PTR_ERR(mntroot);
2657 goto error_splat_super;
David Howellsf7b422b2006-06-09 09:34:33 -04002658 }
David Howells54ceac42006-08-22 20:06:13 -04002659
Trond Myklebust33852a12008-06-19 14:20:11 -04002660 error = security_sb_set_mnt_opts(s, &data->lsm_opts);
Eric Paris46c8ac72008-05-02 13:42:42 -07002661 if (error)
2662 goto error_splat_root;
2663
David Howellsf7b422b2006-06-09 09:34:33 -04002664 s->s_flags |= MS_ACTIVE;
Al Viro31f43472010-10-29 03:38:12 -04002665
2666 security_free_mnt_opts(&data->lsm_opts);
2667 nfs_free_fhandle(mntfh);
2668 return mntroot;
David Howells54ceac42006-08-22 20:06:13 -04002669
Chuck Lever29eb9812007-07-01 12:12:30 -04002670out:
Trond Myklebust33852a12008-06-19 14:20:11 -04002671 security_free_mnt_opts(&data->lsm_opts);
2672out_free_fh:
Trond Myklebustb157b062010-04-19 19:05:48 -04002673 nfs_free_fhandle(mntfh);
Al Viro31f43472010-10-29 03:38:12 -04002674 return ERR_PTR(error);
David Howells54ceac42006-08-22 20:06:13 -04002675
Chuck Lever29eb9812007-07-01 12:12:30 -04002676out_free:
2677 nfs_free_server(server);
2678 goto out;
2679
Eric Paris46c8ac72008-05-02 13:42:42 -07002680error_splat_root:
2681 dput(mntroot);
David Howells54ceac42006-08-22 20:06:13 -04002682error_splat_super:
NeilBrowncfbc0682010-03-11 11:20:17 +11002683 if (server && !s->s_root)
2684 bdi_unregister(&server->backing_dev_info);
2685error_splat_bdi:
Al Viro6f5bbff2009-05-06 01:34:22 -04002686 deactivate_locked_super(s);
Chuck Lever29eb9812007-07-01 12:12:30 -04002687 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002688}
2689
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002690static struct vfsmount *nfs_do_root_mount(struct file_system_type *fs_type,
2691 int flags, void *data, const char *hostname)
2692{
2693 struct vfsmount *root_mnt;
2694 char *root_devname;
2695 size_t len;
2696
2697 len = strlen(hostname) + 3;
2698 root_devname = kmalloc(len, GFP_KERNEL);
2699 if (root_devname == NULL)
2700 return ERR_PTR(-ENOMEM);
2701 snprintf(root_devname, len, "%s:/", hostname);
2702 root_mnt = vfs_kern_mount(fs_type, flags, root_devname, data);
2703 kfree(root_devname);
2704 return root_mnt;
2705}
2706
Trond Myklebustce587e02010-04-16 16:22:52 -04002707struct nfs_referral_count {
2708 struct list_head list;
2709 const struct task_struct *task;
2710 unsigned int referral_count;
2711};
2712
2713static LIST_HEAD(nfs_referral_count_list);
2714static DEFINE_SPINLOCK(nfs_referral_count_list_lock);
2715
2716static struct nfs_referral_count *nfs_find_referral_count(void)
2717{
2718 struct nfs_referral_count *p;
2719
2720 list_for_each_entry(p, &nfs_referral_count_list, list) {
2721 if (p->task == current)
2722 return p;
2723 }
2724 return NULL;
2725}
2726
2727#define NFS_MAX_NESTED_REFERRALS 2
2728
2729static int nfs_referral_loop_protect(void)
2730{
2731 struct nfs_referral_count *p, *new;
2732 int ret = -ENOMEM;
2733
2734 new = kmalloc(sizeof(*new), GFP_KERNEL);
2735 if (!new)
2736 goto out;
2737 new->task = current;
2738 new->referral_count = 1;
2739
2740 ret = 0;
2741 spin_lock(&nfs_referral_count_list_lock);
2742 p = nfs_find_referral_count();
2743 if (p != NULL) {
2744 if (p->referral_count >= NFS_MAX_NESTED_REFERRALS)
2745 ret = -ELOOP;
2746 else
2747 p->referral_count++;
2748 } else {
2749 list_add(&new->list, &nfs_referral_count_list);
2750 new = NULL;
2751 }
2752 spin_unlock(&nfs_referral_count_list_lock);
2753 kfree(new);
2754out:
2755 return ret;
2756}
2757
2758static void nfs_referral_loop_unprotect(void)
2759{
2760 struct nfs_referral_count *p;
2761
2762 spin_lock(&nfs_referral_count_list_lock);
2763 p = nfs_find_referral_count();
2764 p->referral_count--;
2765 if (p->referral_count == 0)
2766 list_del(&p->list);
2767 else
2768 p = NULL;
2769 spin_unlock(&nfs_referral_count_list_lock);
2770 kfree(p);
2771}
2772
Al Viro01194982011-03-16 07:25:36 -04002773static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
2774 const char *export_path)
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002775{
Linus Torvaldsa2770d82009-12-17 12:51:05 -08002776 struct mnt_namespace *ns_private;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002777 struct super_block *s;
Al Viro01194982011-03-16 07:25:36 -04002778 struct dentry *dentry;
Al Viroe0a01242011-06-27 17:00:37 -04002779 struct path path;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002780 int ret;
2781
Linus Torvaldsa2770d82009-12-17 12:51:05 -08002782 ns_private = create_mnt_ns(root_mnt);
2783 ret = PTR_ERR(ns_private);
2784 if (IS_ERR(ns_private))
2785 goto out_mntput;
2786
Trond Myklebustce587e02010-04-16 16:22:52 -04002787 ret = nfs_referral_loop_protect();
2788 if (ret != 0)
2789 goto out_put_mnt_ns;
2790
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002791 ret = vfs_path_lookup(root_mnt->mnt_root, root_mnt,
Al Viroe0a01242011-06-27 17:00:37 -04002792 export_path, LOOKUP_FOLLOW, &path);
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002793
Trond Myklebustce587e02010-04-16 16:22:52 -04002794 nfs_referral_loop_unprotect();
Linus Torvaldsa2770d82009-12-17 12:51:05 -08002795 put_mnt_ns(ns_private);
2796
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002797 if (ret != 0)
2798 goto out_err;
2799
Al Viroe0a01242011-06-27 17:00:37 -04002800 s = path.mnt->mnt_sb;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002801 atomic_inc(&s->s_active);
Al Viroe0a01242011-06-27 17:00:37 -04002802 dentry = dget(path.dentry);
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002803
Al Viroe0a01242011-06-27 17:00:37 -04002804 path_put(&path);
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002805 down_write(&s->s_umount);
Al Viro01194982011-03-16 07:25:36 -04002806 return dentry;
Trond Myklebustce587e02010-04-16 16:22:52 -04002807out_put_mnt_ns:
2808 put_mnt_ns(ns_private);
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002809out_mntput:
2810 mntput(root_mnt);
2811out_err:
Al Viro01194982011-03-16 07:25:36 -04002812 return ERR_PTR(ret);
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002813}
2814
Al Viro01194982011-03-16 07:25:36 -04002815static struct dentry *nfs4_try_mount(int flags, const char *dev_name,
2816 struct nfs_parsed_mount_data *data)
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002817{
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002818 char *export_path;
2819 struct vfsmount *root_mnt;
Al Viro01194982011-03-16 07:25:36 -04002820 struct dentry *res;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002821
Chuck Levera6fe23b2009-09-08 19:50:00 -04002822 dfprintk(MOUNT, "--> nfs4_try_mount()\n");
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002823
2824 export_path = data->nfs_server.export_path;
2825 data->nfs_server.export_path = "/";
2826 root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, data,
2827 data->nfs_server.hostname);
2828 data->nfs_server.export_path = export_path;
2829
Al Viro01194982011-03-16 07:25:36 -04002830 res = ERR_CAST(root_mnt);
2831 if (!IS_ERR(root_mnt))
2832 res = nfs_follow_remote_path(root_mnt, export_path);
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002833
Al Viro01194982011-03-16 07:25:36 -04002834 dfprintk(MOUNT, "<-- nfs4_try_mount() = %ld%s\n",
2835 IS_ERR(res) ? PTR_ERR(res) : 0,
2836 IS_ERR(res) ? " [error]" : "");
2837 return res;
Chuck Levera6fe23b2009-09-08 19:50:00 -04002838}
2839
2840/*
2841 * Get the superblock for an NFS4 mountpoint
2842 */
Al Viro01194982011-03-16 07:25:36 -04002843static struct dentry *nfs4_mount(struct file_system_type *fs_type,
2844 int flags, const char *dev_name, void *raw_data)
Chuck Levera6fe23b2009-09-08 19:50:00 -04002845{
2846 struct nfs_parsed_mount_data *data;
2847 int error = -ENOMEM;
Al Viro01194982011-03-16 07:25:36 -04002848 struct dentry *res = ERR_PTR(-ENOMEM);
Chuck Levera6fe23b2009-09-08 19:50:00 -04002849
Trond Myklebustc5811db2009-10-06 15:40:15 -04002850 data = nfs_alloc_parsed_mount_data(4);
Chuck Levera6fe23b2009-09-08 19:50:00 -04002851 if (data == NULL)
2852 goto out_free_data;
2853
2854 /* Validate the mount data */
2855 error = nfs4_validate_mount_data(raw_data, data, dev_name);
Al Viro01194982011-03-16 07:25:36 -04002856 if (error < 0) {
2857 res = ERR_PTR(error);
Chuck Levera6fe23b2009-09-08 19:50:00 -04002858 goto out;
Al Viro01194982011-03-16 07:25:36 -04002859 }
Chuck Levera6fe23b2009-09-08 19:50:00 -04002860
Al Viro01194982011-03-16 07:25:36 -04002861 res = nfs4_try_mount(flags, dev_name, data);
2862 if (IS_ERR(res))
2863 error = PTR_ERR(res);
Chuck Levera6fe23b2009-09-08 19:50:00 -04002864
2865out:
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002866 kfree(data->client_address);
2867 kfree(data->nfs_server.export_path);
2868 kfree(data->nfs_server.hostname);
2869 kfree(data->fscache_uniq);
2870out_free_data:
2871 kfree(data);
Al Viro01194982011-03-16 07:25:36 -04002872 dprintk("<-- nfs4_mount() = %d%s\n", error,
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002873 error != 0 ? " [error]" : "");
Al Viro01194982011-03-16 07:25:36 -04002874 return res;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04002875}
2876
David Howellsf7b422b2006-06-09 09:34:33 -04002877static void nfs4_kill_super(struct super_block *sb)
2878{
2879 struct nfs_server *server = NFS_SB(sb);
2880
Andy Adamson0f3e66c2009-04-01 09:22:34 -04002881 dprintk("--> %s\n", __func__);
Trond Myklebust515d8612008-12-23 15:21:46 -05002882 nfs_super_return_all_delegations(sb);
David Howellsf7b422b2006-06-09 09:34:33 -04002883 kill_anon_super(sb);
David Howells08734042009-04-03 16:42:42 +01002884 nfs_fscache_release_super_cookie(sb);
David Howells54ceac42006-08-22 20:06:13 -04002885 nfs_free_server(server);
Andy Adamson0f3e66c2009-04-01 09:22:34 -04002886 dprintk("<-- %s\n", __func__);
David Howellsf7b422b2006-06-09 09:34:33 -04002887}
2888
2889/*
David Howells54ceac42006-08-22 20:06:13 -04002890 * Clone an NFS4 server record on xdev traversal (FSID-change)
David Howellsf7b422b2006-06-09 09:34:33 -04002891 */
Al Viro31f43472010-10-29 03:38:12 -04002892static struct dentry *
2893nfs4_xdev_mount(struct file_system_type *fs_type, int flags,
2894 const char *dev_name, void *raw_data)
David Howellsf7b422b2006-06-09 09:34:33 -04002895{
2896 struct nfs_clone_mount *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002897 struct super_block *s;
2898 struct nfs_server *server;
2899 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04002900 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002901 struct nfs_sb_mountdata sb_mntdata = {
2902 .mntflags = flags,
2903 };
David Howells54ceac42006-08-22 20:06:13 -04002904 int error;
2905
Al Viro31f43472010-10-29 03:38:12 -04002906 dprintk("--> nfs4_xdev_mount()\n");
David Howells54ceac42006-08-22 20:06:13 -04002907
2908 /* create a new volume representation */
2909 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
2910 if (IS_ERR(server)) {
2911 error = PTR_ERR(server);
2912 goto out_err_noserver;
2913 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002914 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002915
Trond Myklebust75180df2007-05-16 16:53:28 -04002916 if (server->flags & NFS4_MOUNT_UNSHARED)
2917 compare_super = NULL;
2918
David Howells54ceac42006-08-22 20:06:13 -04002919 /* Get a superblock - note that we may end up sharing one that already exists */
Andy Adamsonec9a05c2008-10-17 10:44:37 -04002920 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
David Howells54ceac42006-08-22 20:06:13 -04002921 if (IS_ERR(s)) {
2922 error = PTR_ERR(s);
2923 goto out_err_nosb;
2924 }
2925
2926 if (s->s_fs_info != server) {
2927 nfs_free_server(server);
2928 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002929 } else {
2930 error = nfs_bdi_register(server);
2931 if (error)
NeilBrowncfbc0682010-03-11 11:20:17 +11002932 goto error_splat_bdi;
David Howells54ceac42006-08-22 20:06:13 -04002933 }
2934
2935 if (!s->s_root) {
2936 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002937 nfs4_clone_super(s, data->sb);
David Howells2df54802009-09-23 14:36:39 -04002938 nfs_fscache_get_super_cookie(s, NULL, data);
David Howells54ceac42006-08-22 20:06:13 -04002939 }
2940
Al Viro0d5839a2011-03-16 05:27:27 -04002941 mntroot = nfs4_get_root(s, data->fh, dev_name);
David Howells54ceac42006-08-22 20:06:13 -04002942 if (IS_ERR(mntroot)) {
2943 error = PTR_ERR(mntroot);
2944 goto error_splat_super;
2945 }
Trond Myklebuste9cc6c22008-01-02 13:28:57 -05002946 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
2947 dput(mntroot);
2948 error = -ESTALE;
2949 goto error_splat_super;
2950 }
David Howells54ceac42006-08-22 20:06:13 -04002951
2952 s->s_flags |= MS_ACTIVE;
David Howells54ceac42006-08-22 20:06:13 -04002953
Eric Paris46c8ac72008-05-02 13:42:42 -07002954 security_sb_clone_mnt_opts(data->sb, s);
2955
Al Viro31f43472010-10-29 03:38:12 -04002956 dprintk("<-- nfs4_xdev_mount() = 0\n");
2957 return mntroot;
David Howells54ceac42006-08-22 20:06:13 -04002958
2959out_err_nosb:
2960 nfs_free_server(server);
2961out_err_noserver:
Al Viro31f43472010-10-29 03:38:12 -04002962 dprintk("<-- nfs4_xdev_mount() = %d [error]\n", error);
2963 return ERR_PTR(error);
David Howells54ceac42006-08-22 20:06:13 -04002964
2965error_splat_super:
NeilBrowncfbc0682010-03-11 11:20:17 +11002966 if (server && !s->s_root)
2967 bdi_unregister(&server->backing_dev_info);
2968error_splat_bdi:
Al Viro6f5bbff2009-05-06 01:34:22 -04002969 deactivate_locked_super(s);
Al Viro31f43472010-10-29 03:38:12 -04002970 dprintk("<-- nfs4_xdev_mount() = %d [splat]\n", error);
2971 return ERR_PTR(error);
David Howellsf7b422b2006-06-09 09:34:33 -04002972}
2973
Al Viro31f43472010-10-29 03:38:12 -04002974static struct dentry *
2975nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags,
2976 const char *dev_name, void *raw_data)
David Howellsf7b422b2006-06-09 09:34:33 -04002977{
2978 struct nfs_clone_mount *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002979 struct super_block *s;
2980 struct nfs_server *server;
2981 struct dentry *mntroot;
Trond Myklebust4f727292010-04-16 16:22:48 -04002982 struct nfs_fh *mntfh;
Trond Myklebust75180df2007-05-16 16:53:28 -04002983 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002984 struct nfs_sb_mountdata sb_mntdata = {
2985 .mntflags = flags,
2986 };
Trond Myklebust4f727292010-04-16 16:22:48 -04002987 int error = -ENOMEM;
David Howells54ceac42006-08-22 20:06:13 -04002988
2989 dprintk("--> nfs4_referral_get_sb()\n");
2990
Trond Myklebust4f727292010-04-16 16:22:48 -04002991 mntfh = nfs_alloc_fhandle();
2992 if (mntfh == NULL)
2993 goto out_err_nofh;
2994
David Howells54ceac42006-08-22 20:06:13 -04002995 /* create a new volume representation */
Trond Myklebust4f727292010-04-16 16:22:48 -04002996 server = nfs4_create_referral_server(data, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002997 if (IS_ERR(server)) {
2998 error = PTR_ERR(server);
2999 goto out_err_noserver;
3000 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04003001 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04003002
Trond Myklebust75180df2007-05-16 16:53:28 -04003003 if (server->flags & NFS4_MOUNT_UNSHARED)
3004 compare_super = NULL;
3005
David Howells54ceac42006-08-22 20:06:13 -04003006 /* Get a superblock - note that we may end up sharing one that already exists */
Andy Adamsonec9a05c2008-10-17 10:44:37 -04003007 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
David Howells54ceac42006-08-22 20:06:13 -04003008 if (IS_ERR(s)) {
3009 error = PTR_ERR(s);
3010 goto out_err_nosb;
3011 }
3012
3013 if (s->s_fs_info != server) {
3014 nfs_free_server(server);
3015 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07003016 } else {
3017 error = nfs_bdi_register(server);
3018 if (error)
NeilBrowncfbc0682010-03-11 11:20:17 +11003019 goto error_splat_bdi;
David Howells54ceac42006-08-22 20:06:13 -04003020 }
3021
3022 if (!s->s_root) {
3023 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04003024 nfs4_fill_super(s);
David Howells2df54802009-09-23 14:36:39 -04003025 nfs_fscache_get_super_cookie(s, NULL, data);
David Howells54ceac42006-08-22 20:06:13 -04003026 }
3027
Al Viro0d5839a2011-03-16 05:27:27 -04003028 mntroot = nfs4_get_root(s, mntfh, dev_name);
David Howells54ceac42006-08-22 20:06:13 -04003029 if (IS_ERR(mntroot)) {
3030 error = PTR_ERR(mntroot);
3031 goto error_splat_super;
3032 }
Trond Myklebuste9cc6c22008-01-02 13:28:57 -05003033 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
3034 dput(mntroot);
3035 error = -ESTALE;
3036 goto error_splat_super;
3037 }
David Howells54ceac42006-08-22 20:06:13 -04003038
3039 s->s_flags |= MS_ACTIVE;
David Howells54ceac42006-08-22 20:06:13 -04003040
Eric Paris46c8ac72008-05-02 13:42:42 -07003041 security_sb_clone_mnt_opts(data->sb, s);
3042
Trond Myklebust4f727292010-04-16 16:22:48 -04003043 nfs_free_fhandle(mntfh);
David Howells54ceac42006-08-22 20:06:13 -04003044 dprintk("<-- nfs4_referral_get_sb() = 0\n");
Al Viro31f43472010-10-29 03:38:12 -04003045 return mntroot;
David Howells54ceac42006-08-22 20:06:13 -04003046
3047out_err_nosb:
3048 nfs_free_server(server);
3049out_err_noserver:
Trond Myklebust4f727292010-04-16 16:22:48 -04003050 nfs_free_fhandle(mntfh);
3051out_err_nofh:
David Howells54ceac42006-08-22 20:06:13 -04003052 dprintk("<-- nfs4_referral_get_sb() = %d [error]\n", error);
Al Viro31f43472010-10-29 03:38:12 -04003053 return ERR_PTR(error);
David Howells54ceac42006-08-22 20:06:13 -04003054
3055error_splat_super:
NeilBrowncfbc0682010-03-11 11:20:17 +11003056 if (server && !s->s_root)
3057 bdi_unregister(&server->backing_dev_info);
3058error_splat_bdi:
Al Viro6f5bbff2009-05-06 01:34:22 -04003059 deactivate_locked_super(s);
Trond Myklebust4f727292010-04-16 16:22:48 -04003060 nfs_free_fhandle(mntfh);
David Howells54ceac42006-08-22 20:06:13 -04003061 dprintk("<-- nfs4_referral_get_sb() = %d [splat]\n", error);
Al Viro31f43472010-10-29 03:38:12 -04003062 return ERR_PTR(error);
David Howellsf7b422b2006-06-09 09:34:33 -04003063}
3064
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04003065/*
3066 * Create an NFS4 server record on referral traversal
3067 */
Al Viro01194982011-03-16 07:25:36 -04003068static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
3069 int flags, const char *dev_name, void *raw_data)
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04003070{
3071 struct nfs_clone_mount *data = raw_data;
3072 char *export_path;
3073 struct vfsmount *root_mnt;
Al Viro01194982011-03-16 07:25:36 -04003074 struct dentry *res;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04003075
Al Viro01194982011-03-16 07:25:36 -04003076 dprintk("--> nfs4_referral_mount()\n");
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04003077
3078 export_path = data->mnt_path;
3079 data->mnt_path = "/";
3080
3081 root_mnt = nfs_do_root_mount(&nfs4_remote_referral_fs_type,
3082 flags, data, data->hostname);
3083 data->mnt_path = export_path;
3084
Al Viro01194982011-03-16 07:25:36 -04003085 res = ERR_CAST(root_mnt);
3086 if (!IS_ERR(root_mnt))
3087 res = nfs_follow_remote_path(root_mnt, export_path);
3088 dprintk("<-- nfs4_referral_mount() = %ld%s\n",
3089 IS_ERR(res) ? PTR_ERR(res) : 0,
3090 IS_ERR(res) ? " [error]" : "");
3091 return res;
Trond Myklebustc02d7ad2009-06-22 15:09:14 -04003092}
3093
David Howells54ceac42006-08-22 20:06:13 -04003094#endif /* CONFIG_NFS_V4 */