blob: 8b28b95c9e44a6cafe221609111a05bb0c495361 [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 *
8 * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
9 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
10 *
11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12 * J.S.Peatfield@damtp.cam.ac.uk
13 *
14 * Split from inode.c by David Howells <dhowells@redhat.com>
15 *
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>
42#include <linux/smp_lock.h>
43#include <linux/seq_file.h>
44#include <linux/mount.h>
45#include <linux/nfs_idmap.h>
46#include <linux/vfs.h>
47#include <linux/inet.h>
Chuck Leverfd00a8f2007-12-10 14:57:38 -050048#include <linux/in6.h>
49#include <net/ipv6.h>
Chuck Leverd8e77482008-06-23 12:37:01 -040050#include <linux/netdevice.h>
David Howellsf7b422b2006-06-09 09:34:33 -040051#include <linux/nfs_xdr.h>
Adrian Bunkb5d5dfb2007-02-12 00:53:40 -080052#include <linux/magic.h>
Chuck Leverbf0fd762007-07-01 12:13:44 -040053#include <linux/parser.h>
David Howellsf7b422b2006-06-09 09:34:33 -040054
55#include <asm/system.h>
56#include <asm/uaccess.h>
57
58#include "nfs4_fs.h"
59#include "callback.h"
60#include "delegation.h"
61#include "iostat.h"
62#include "internal.h"
63
64#define NFSDBG_FACILITY NFSDBG_VFS
65
Chuck Leverbf0fd762007-07-01 12:13:44 -040066enum {
67 /* Mount options that take no arguments */
68 Opt_soft, Opt_hard,
Chuck Leverbf0fd762007-07-01 12:13:44 -040069 Opt_posix, Opt_noposix,
70 Opt_cto, Opt_nocto,
71 Opt_ac, Opt_noac,
72 Opt_lock, Opt_nolock,
73 Opt_v2, Opt_v3,
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -040074 Opt_udp, Opt_tcp, Opt_rdma,
Chuck Leverbf0fd762007-07-01 12:13:44 -040075 Opt_acl, Opt_noacl,
76 Opt_rdirplus, Opt_nordirplus,
Trond Myklebust75180df2007-05-16 16:53:28 -040077 Opt_sharecache, Opt_nosharecache,
Chuck Leverbf0fd762007-07-01 12:13:44 -040078
79 /* Mount options that take integer arguments */
80 Opt_port,
81 Opt_rsize, Opt_wsize, Opt_bsize,
82 Opt_timeo, Opt_retrans,
83 Opt_acregmin, Opt_acregmax,
84 Opt_acdirmin, Opt_acdirmax,
85 Opt_actimeo,
86 Opt_namelen,
87 Opt_mountport,
Chuck Levere887cbc2007-10-26 13:32:29 -040088 Opt_mountvers,
Chuck Leverad879ce2007-10-26 13:32:24 -040089 Opt_nfsvers,
Chuck Leverbf0fd762007-07-01 12:13:44 -040090
91 /* Mount options that take string arguments */
Chuck Lever33832032007-12-10 14:59:13 -050092 Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
Chuck Lever0ac83772007-09-11 18:01:04 -040093 Opt_addr, Opt_mountaddr, Opt_clientaddr,
Trond Myklebust7973c1f2008-07-15 17:58:14 -040094 Opt_lookupcache,
Chuck Leverbf0fd762007-07-01 12:13:44 -040095
Chuck Leverf45663c2008-06-24 19:28:02 -040096 /* Special mount options */
97 Opt_userspace, Opt_deprecated, Opt_sloppy,
Chuck Leverbf0fd762007-07-01 12:13:44 -040098
99 Opt_err
100};
101
Steven Whitehousea447c092008-10-13 10:46:57 +0100102static const match_table_t nfs_mount_option_tokens = {
Chuck Leverbf0fd762007-07-01 12:13:44 -0400103 { Opt_userspace, "bg" },
104 { Opt_userspace, "fg" },
Chuck Leverecbb3842008-06-12 12:37:33 -0400105 { Opt_userspace, "retry=%s" },
106
Chuck Leverf45663c2008-06-24 19:28:02 -0400107 { Opt_sloppy, "sloppy" },
108
Chuck Leverbf0fd762007-07-01 12:13:44 -0400109 { Opt_soft, "soft" },
110 { Opt_hard, "hard" },
Chuck Leverd33e4df2008-06-12 12:37:41 -0400111 { Opt_deprecated, "intr" },
112 { Opt_deprecated, "nointr" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400113 { Opt_posix, "posix" },
114 { Opt_noposix, "noposix" },
115 { Opt_cto, "cto" },
116 { Opt_nocto, "nocto" },
117 { Opt_ac, "ac" },
118 { Opt_noac, "noac" },
119 { Opt_lock, "lock" },
120 { Opt_nolock, "nolock" },
121 { Opt_v2, "v2" },
122 { Opt_v3, "v3" },
123 { Opt_udp, "udp" },
124 { Opt_tcp, "tcp" },
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -0400125 { Opt_rdma, "rdma" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400126 { Opt_acl, "acl" },
127 { Opt_noacl, "noacl" },
128 { Opt_rdirplus, "rdirplus" },
129 { Opt_nordirplus, "nordirplus" },
Trond Myklebust75180df2007-05-16 16:53:28 -0400130 { Opt_sharecache, "sharecache" },
131 { Opt_nosharecache, "nosharecache" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400132
133 { Opt_port, "port=%u" },
134 { Opt_rsize, "rsize=%u" },
135 { Opt_wsize, "wsize=%u" },
136 { Opt_bsize, "bsize=%u" },
137 { Opt_timeo, "timeo=%u" },
138 { Opt_retrans, "retrans=%u" },
139 { Opt_acregmin, "acregmin=%u" },
140 { Opt_acregmax, "acregmax=%u" },
141 { Opt_acdirmin, "acdirmin=%u" },
142 { Opt_acdirmax, "acdirmax=%u" },
143 { Opt_actimeo, "actimeo=%u" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400144 { Opt_namelen, "namlen=%u" },
145 { Opt_mountport, "mountport=%u" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400146 { Opt_mountvers, "mountvers=%u" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400147 { Opt_nfsvers, "nfsvers=%u" },
148 { Opt_nfsvers, "vers=%u" },
149
150 { Opt_sec, "sec=%s" },
151 { Opt_proto, "proto=%s" },
152 { Opt_mountproto, "mountproto=%s" },
153 { Opt_addr, "addr=%s" },
154 { Opt_clientaddr, "clientaddr=%s" },
Chuck Lever33832032007-12-10 14:59:13 -0500155 { Opt_mounthost, "mounthost=%s" },
Chuck Lever0ac83772007-09-11 18:01:04 -0400156 { Opt_mountaddr, "mountaddr=%s" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400157
Trond Myklebust7973c1f2008-07-15 17:58:14 -0400158 { Opt_lookupcache, "lookupcache=%s" },
159
Chuck Leverbf0fd762007-07-01 12:13:44 -0400160 { Opt_err, NULL }
161};
162
163enum {
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -0400164 Opt_xprt_udp, Opt_xprt_tcp, Opt_xprt_rdma,
Chuck Leverbf0fd762007-07-01 12:13:44 -0400165
166 Opt_xprt_err
167};
168
Steven Whitehousea447c092008-10-13 10:46:57 +0100169static const match_table_t nfs_xprt_protocol_tokens = {
Chuck Leverbf0fd762007-07-01 12:13:44 -0400170 { Opt_xprt_udp, "udp" },
171 { Opt_xprt_tcp, "tcp" },
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -0400172 { Opt_xprt_rdma, "rdma" },
Chuck Leverbf0fd762007-07-01 12:13:44 -0400173
174 { Opt_xprt_err, NULL }
175};
176
177enum {
178 Opt_sec_none, Opt_sec_sys,
179 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
180 Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
181 Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
182
183 Opt_sec_err
184};
185
Steven Whitehousea447c092008-10-13 10:46:57 +0100186static const match_table_t nfs_secflavor_tokens = {
Chuck Leverbf0fd762007-07-01 12:13:44 -0400187 { Opt_sec_none, "none" },
188 { Opt_sec_none, "null" },
189 { Opt_sec_sys, "sys" },
190
191 { Opt_sec_krb5, "krb5" },
192 { Opt_sec_krb5i, "krb5i" },
193 { Opt_sec_krb5p, "krb5p" },
194
195 { Opt_sec_lkey, "lkey" },
196 { Opt_sec_lkeyi, "lkeyi" },
197 { Opt_sec_lkeyp, "lkeyp" },
198
Olga Kornievskaia8d042212008-02-13 16:47:06 -0500199 { Opt_sec_spkm, "spkm3" },
200 { Opt_sec_spkmi, "spkm3i" },
201 { Opt_sec_spkmp, "spkm3p" },
202
Chuck Leverbf0fd762007-07-01 12:13:44 -0400203 { Opt_sec_err, NULL }
204};
205
Trond Myklebust7973c1f2008-07-15 17:58:14 -0400206enum {
207 Opt_lookupcache_all, Opt_lookupcache_positive,
208 Opt_lookupcache_none,
209
210 Opt_lookupcache_err
211};
212
213static match_table_t nfs_lookupcache_tokens = {
214 { Opt_lookupcache_all, "all" },
215 { Opt_lookupcache_positive, "pos" },
216 { Opt_lookupcache_positive, "positive" },
217 { Opt_lookupcache_none, "none" },
218
219 { Opt_lookupcache_err, NULL }
220};
221
Chuck Leverbf0fd762007-07-01 12:13:44 -0400222
Al Viro42faad92008-04-24 07:21:56 -0400223static void nfs_umount_begin(struct super_block *);
Trond Myklebust816724e2006-06-24 08:41:41 -0400224static int nfs_statfs(struct dentry *, struct kstatfs *);
David Howellsf7b422b2006-06-09 09:34:33 -0400225static int nfs_show_options(struct seq_file *, struct vfsmount *);
226static int nfs_show_stats(struct seq_file *, struct vfsmount *);
Trond Myklebust816724e2006-06-24 08:41:41 -0400227static int nfs_get_sb(struct file_system_type *, int, const char *, void *, struct vfsmount *);
David Howells54ceac42006-08-22 20:06:13 -0400228static int nfs_xdev_get_sb(struct file_system_type *fs_type,
Trond Myklebust816724e2006-06-24 08:41:41 -0400229 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
David Howellsf7b422b2006-06-09 09:34:33 -0400230static void nfs_kill_super(struct super_block *);
Jeff Layton48b605f2008-06-10 15:38:39 -0400231static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
David Howellsf7b422b2006-06-09 09:34:33 -0400232
233static struct file_system_type nfs_fs_type = {
234 .owner = THIS_MODULE,
235 .name = "nfs",
236 .get_sb = nfs_get_sb,
237 .kill_sb = nfs_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700238 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400239};
240
David Howells54ceac42006-08-22 20:06:13 -0400241struct file_system_type nfs_xdev_fs_type = {
David Howellsf7b422b2006-06-09 09:34:33 -0400242 .owner = THIS_MODULE,
243 .name = "nfs",
David Howells54ceac42006-08-22 20:06:13 -0400244 .get_sb = nfs_xdev_get_sb,
David Howellsf7b422b2006-06-09 09:34:33 -0400245 .kill_sb = nfs_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700246 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400247};
248
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800249static const struct super_operations nfs_sops = {
David Howellsf7b422b2006-06-09 09:34:33 -0400250 .alloc_inode = nfs_alloc_inode,
251 .destroy_inode = nfs_destroy_inode,
252 .write_inode = nfs_write_inode,
253 .statfs = nfs_statfs,
254 .clear_inode = nfs_clear_inode,
255 .umount_begin = nfs_umount_begin,
256 .show_options = nfs_show_options,
257 .show_stats = nfs_show_stats,
Jeff Layton48b605f2008-06-10 15:38:39 -0400258 .remount_fs = nfs_remount,
David Howellsf7b422b2006-06-09 09:34:33 -0400259};
260
261#ifdef CONFIG_NFS_V4
Trond Myklebust816724e2006-06-24 08:41:41 -0400262static int nfs4_get_sb(struct file_system_type *fs_type,
263 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
David Howells54ceac42006-08-22 20:06:13 -0400264static int nfs4_xdev_get_sb(struct file_system_type *fs_type,
265 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
266static int nfs4_referral_get_sb(struct file_system_type *fs_type,
267 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
David Howellsf7b422b2006-06-09 09:34:33 -0400268static void nfs4_kill_super(struct super_block *sb);
269
270static struct file_system_type nfs4_fs_type = {
271 .owner = THIS_MODULE,
272 .name = "nfs4",
273 .get_sb = nfs4_get_sb,
274 .kill_sb = nfs4_kill_super,
Mark Fasheh349457c2006-09-08 14:22:21 -0700275 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
David Howellsf7b422b2006-06-09 09:34:33 -0400276};
277
David Howells54ceac42006-08-22 20:06:13 -0400278struct file_system_type nfs4_xdev_fs_type = {
David Howellsf7b422b2006-06-09 09:34:33 -0400279 .owner = THIS_MODULE,
280 .name = "nfs4",
David Howells54ceac42006-08-22 20:06:13 -0400281 .get_sb = nfs4_xdev_get_sb,
David Howellsf7b422b2006-06-09 09:34:33 -0400282 .kill_sb = nfs4_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 nfs4_referral_fs_type = {
David Howellsf7b422b2006-06-09 09:34:33 -0400287 .owner = THIS_MODULE,
288 .name = "nfs4",
David Howells54ceac42006-08-22 20:06:13 -0400289 .get_sb = nfs4_referral_get_sb,
David Howellsf7b422b2006-06-09 09:34:33 -0400290 .kill_sb = nfs4_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 nfs4_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,
298 .statfs = nfs_statfs,
299 .clear_inode = nfs4_clear_inode,
300 .umount_begin = nfs_umount_begin,
301 .show_options = nfs_show_options,
302 .show_stats = nfs_show_stats,
Jeff Layton48b605f2008-06-10 15:38:39 -0400303 .remount_fs = nfs_remount,
David Howellsf7b422b2006-06-09 09:34:33 -0400304};
305#endif
306
Rusty Russell8e1f9362007-07-17 04:03:17 -0700307static struct shrinker acl_shrinker = {
308 .shrink = nfs_access_cache_shrinker,
309 .seeks = DEFAULT_SEEKS,
310};
Trond Myklebust979df722006-07-25 11:28:19 -0400311
David Howellsf7b422b2006-06-09 09:34:33 -0400312/*
313 * Register the NFS filesystems
314 */
315int __init register_nfs_fs(void)
316{
317 int ret;
318
319 ret = register_filesystem(&nfs_fs_type);
320 if (ret < 0)
321 goto error_0;
322
David Howellsf7b422b2006-06-09 09:34:33 -0400323 ret = nfs_register_sysctl();
324 if (ret < 0)
325 goto error_1;
Peter Zijlstra89a09142007-03-16 13:38:26 -0800326#ifdef CONFIG_NFS_V4
David Howellsf7b422b2006-06-09 09:34:33 -0400327 ret = register_filesystem(&nfs4_fs_type);
328 if (ret < 0)
329 goto error_2;
330#endif
Rusty Russell8e1f9362007-07-17 04:03:17 -0700331 register_shrinker(&acl_shrinker);
David Howellsf7b422b2006-06-09 09:34:33 -0400332 return 0;
333
334#ifdef CONFIG_NFS_V4
335error_2:
336 nfs_unregister_sysctl();
Peter Zijlstra89a09142007-03-16 13:38:26 -0800337#endif
David Howellsf7b422b2006-06-09 09:34:33 -0400338error_1:
339 unregister_filesystem(&nfs_fs_type);
David Howellsf7b422b2006-06-09 09:34:33 -0400340error_0:
341 return ret;
342}
343
344/*
345 * Unregister the NFS filesystems
346 */
347void __exit unregister_nfs_fs(void)
348{
Rusty Russell8e1f9362007-07-17 04:03:17 -0700349 unregister_shrinker(&acl_shrinker);
David Howellsf7b422b2006-06-09 09:34:33 -0400350#ifdef CONFIG_NFS_V4
351 unregister_filesystem(&nfs4_fs_type);
David Howellsf7b422b2006-06-09 09:34:33 -0400352#endif
Alexey Dobriyan49af7ee2007-09-18 22:46:40 -0700353 nfs_unregister_sysctl();
David Howellsf7b422b2006-06-09 09:34:33 -0400354 unregister_filesystem(&nfs_fs_type);
355}
356
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400357void nfs_sb_active(struct super_block *sb)
Steve Dicksonef818a22007-11-08 04:05:04 -0500358{
359 struct nfs_server *server = NFS_SB(sb);
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400360
361 if (atomic_inc_return(&server->active) == 1)
362 atomic_inc(&sb->s_active);
363}
364
365void nfs_sb_deactive(struct super_block *sb)
366{
367 struct nfs_server *server = NFS_SB(sb);
368
369 if (atomic_dec_and_test(&server->active))
370 deactivate_super(sb);
Steve Dicksonef818a22007-11-08 04:05:04 -0500371}
372
David Howellsf7b422b2006-06-09 09:34:33 -0400373/*
374 * Deliver file system statistics to userspace
375 */
Trond Myklebust816724e2006-06-24 08:41:41 -0400376static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
David Howellsf7b422b2006-06-09 09:34:33 -0400377{
David Howells0c7d90c2006-08-22 20:06:10 -0400378 struct nfs_server *server = NFS_SB(dentry->d_sb);
David Howellsf7b422b2006-06-09 09:34:33 -0400379 unsigned char blockbits;
380 unsigned long blockres;
David Howells0c7d90c2006-08-22 20:06:10 -0400381 struct nfs_fh *fh = NFS_FH(dentry->d_inode);
David Howellsf7b422b2006-06-09 09:34:33 -0400382 struct nfs_fattr fattr;
383 struct nfs_fsstat res = {
384 .fattr = &fattr,
385 };
386 int error;
387
David Howells8fa5c002006-08-22 20:06:12 -0400388 error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
David Howellsf7b422b2006-06-09 09:34:33 -0400389 if (error < 0)
390 goto out_err;
Amnon Aaronsohn1a0ba9a2007-04-09 22:05:26 -0700391 buf->f_type = NFS_SUPER_MAGIC;
David Howellsf7b422b2006-06-09 09:34:33 -0400392
393 /*
394 * Current versions of glibc do not correctly handle the
395 * case where f_frsize != f_bsize. Eventually we want to
396 * report the value of wtmult in this field.
397 */
David Howells0c7d90c2006-08-22 20:06:10 -0400398 buf->f_frsize = dentry->d_sb->s_blocksize;
David Howellsf7b422b2006-06-09 09:34:33 -0400399
400 /*
401 * On most *nix systems, f_blocks, f_bfree, and f_bavail
402 * are reported in units of f_frsize. Linux hasn't had
403 * an f_frsize field in its statfs struct until recently,
404 * thus historically Linux's sys_statfs reports these
405 * fields in units of f_bsize.
406 */
David Howells0c7d90c2006-08-22 20:06:10 -0400407 buf->f_bsize = dentry->d_sb->s_blocksize;
408 blockbits = dentry->d_sb->s_blocksize_bits;
David Howellsf7b422b2006-06-09 09:34:33 -0400409 blockres = (1 << blockbits) - 1;
410 buf->f_blocks = (res.tbytes + blockres) >> blockbits;
411 buf->f_bfree = (res.fbytes + blockres) >> blockbits;
412 buf->f_bavail = (res.abytes + blockres) >> blockbits;
413
414 buf->f_files = res.tfiles;
415 buf->f_ffree = res.afiles;
416
417 buf->f_namelen = server->namelen;
Amnon Aaronsohn1a0ba9a2007-04-09 22:05:26 -0700418
David Howellsf7b422b2006-06-09 09:34:33 -0400419 return 0;
420
421 out_err:
Harvey Harrison3110ff82008-05-02 13:42:44 -0700422 dprintk("%s: statfs error = %d\n", __func__, -error);
Amnon Aaronsohn1a0ba9a2007-04-09 22:05:26 -0700423 return error;
David Howellsf7b422b2006-06-09 09:34:33 -0400424}
425
David Howells7d4e2742006-08-22 20:06:07 -0400426/*
427 * Map the security flavour number to a name
428 */
Trond Myklebust81039f12006-06-09 09:34:34 -0400429static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
430{
David Howells7d4e2742006-08-22 20:06:07 -0400431 static const struct {
Trond Myklebust81039f12006-06-09 09:34:34 -0400432 rpc_authflavor_t flavour;
433 const char *str;
434 } sec_flavours[] = {
435 { RPC_AUTH_NULL, "null" },
436 { RPC_AUTH_UNIX, "sys" },
437 { RPC_AUTH_GSS_KRB5, "krb5" },
438 { RPC_AUTH_GSS_KRB5I, "krb5i" },
439 { RPC_AUTH_GSS_KRB5P, "krb5p" },
440 { RPC_AUTH_GSS_LKEY, "lkey" },
441 { RPC_AUTH_GSS_LKEYI, "lkeyi" },
442 { RPC_AUTH_GSS_LKEYP, "lkeyp" },
443 { RPC_AUTH_GSS_SPKM, "spkm" },
444 { RPC_AUTH_GSS_SPKMI, "spkmi" },
445 { RPC_AUTH_GSS_SPKMP, "spkmp" },
Chuck Lever4d81cd12007-07-01 12:12:40 -0400446 { UINT_MAX, "unknown" }
Trond Myklebust81039f12006-06-09 09:34:34 -0400447 };
448 int i;
449
Chuck Lever4d81cd12007-07-01 12:12:40 -0400450 for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
Trond Myklebust81039f12006-06-09 09:34:34 -0400451 if (sec_flavours[i].flavour == flavour)
452 break;
453 }
454 return sec_flavours[i].str;
455}
456
Chuck Lever82d101d2008-03-14 14:10:37 -0400457static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
458 int showdefaults)
459{
460 struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;
461
462 switch (sap->sa_family) {
463 case AF_INET: {
464 struct sockaddr_in *sin = (struct sockaddr_in *)sap;
465 seq_printf(m, ",mountaddr=" NIPQUAD_FMT,
466 NIPQUAD(sin->sin_addr.s_addr));
467 break;
468 }
469 case AF_INET6: {
470 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
471 seq_printf(m, ",mountaddr=" NIP6_FMT,
472 NIP6(sin6->sin6_addr));
473 break;
474 }
475 default:
476 if (showdefaults)
477 seq_printf(m, ",mountaddr=unspecified");
478 }
479
480 if (nfss->mountd_version || showdefaults)
481 seq_printf(m, ",mountvers=%u", nfss->mountd_version);
482 if (nfss->mountd_port || showdefaults)
483 seq_printf(m, ",mountport=%u", nfss->mountd_port);
484
485 switch (nfss->mountd_protocol) {
486 case IPPROTO_UDP:
487 seq_printf(m, ",mountproto=udp");
488 break;
489 case IPPROTO_TCP:
490 seq_printf(m, ",mountproto=tcp");
491 break;
492 default:
493 if (showdefaults)
494 seq_printf(m, ",mountproto=auto");
495 }
496}
497
David Howellsf7b422b2006-06-09 09:34:33 -0400498/*
499 * Describe the mount options in force on this server representation
500 */
Chuck Lever82d101d2008-03-14 14:10:37 -0400501static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
502 int showdefaults)
David Howellsf7b422b2006-06-09 09:34:33 -0400503{
David Howells509de812006-08-22 20:06:11 -0400504 static const struct proc_nfs_info {
David Howellsf7b422b2006-06-09 09:34:33 -0400505 int flag;
David Howells509de812006-08-22 20:06:11 -0400506 const char *str;
507 const char *nostr;
David Howellsf7b422b2006-06-09 09:34:33 -0400508 } nfs_info[] = {
509 { NFS_MOUNT_SOFT, ",soft", ",hard" },
Chuck Lever82d101d2008-03-14 14:10:37 -0400510 { NFS_MOUNT_INTR, ",intr", ",nointr" },
511 { NFS_MOUNT_POSIX, ",posix", "" },
David Howellsf7b422b2006-06-09 09:34:33 -0400512 { NFS_MOUNT_NOCTO, ",nocto", "" },
513 { NFS_MOUNT_NOAC, ",noac", "" },
514 { NFS_MOUNT_NONLM, ",nolock", "" },
515 { NFS_MOUNT_NOACL, ",noacl", "" },
Steve Dickson74dd34e2007-04-14 17:01:15 -0400516 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
Trond Myklebust75180df2007-05-16 16:53:28 -0400517 { NFS_MOUNT_UNSHARED, ",nosharecache", ""},
David Howellsf7b422b2006-06-09 09:34:33 -0400518 { 0, NULL, NULL }
519 };
David Howells509de812006-08-22 20:06:11 -0400520 const struct proc_nfs_info *nfs_infop;
David Howells8fa5c002006-08-22 20:06:12 -0400521 struct nfs_client *clp = nfss->nfs_client;
Chuck Lever82d101d2008-03-14 14:10:37 -0400522 u32 version = clp->rpc_ops->version;
David Howellsf7b422b2006-06-09 09:34:33 -0400523
Chuck Lever82d101d2008-03-14 14:10:37 -0400524 seq_printf(m, ",vers=%u", version);
Chuck Lever2d767432008-03-14 14:10:08 -0400525 seq_printf(m, ",rsize=%u", nfss->rsize);
526 seq_printf(m, ",wsize=%u", nfss->wsize);
Chuck Lever82d101d2008-03-14 14:10:37 -0400527 if (nfss->bsize != 0)
528 seq_printf(m, ",bsize=%u", nfss->bsize);
529 seq_printf(m, ",namlen=%u", nfss->namelen);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400530 if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400531 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400532 if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400533 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400534 if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400535 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
Chuck Lever0e0cab72008-06-26 17:47:12 -0400536 if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
Chuck Lever2d767432008-03-14 14:10:08 -0400537 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
David Howellsf7b422b2006-06-09 09:34:33 -0400538 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
539 if (nfss->flags & nfs_infop->flag)
540 seq_puts(m, nfs_infop->str);
541 else
542 seq_puts(m, nfs_infop->nostr);
543 }
\"Talpey, Thomas\56928ed2007-09-10 13:48:47 -0400544 seq_printf(m, ",proto=%s",
545 rpc_peeraddr2str(nfss->client, RPC_DISPLAY_PROTO));
Chuck Lever82d101d2008-03-14 14:10:37 -0400546 if (version == 4) {
547 if (nfss->port != NFS_PORT)
548 seq_printf(m, ",port=%u", nfss->port);
549 } else
550 if (nfss->port)
551 seq_printf(m, ",port=%u", nfss->port);
552
Trond Myklebust33170232007-12-20 16:03:59 -0500553 seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
554 seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
Trond Myklebust81039f12006-06-09 09:34:34 -0400555 seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
Chuck Lever82d101d2008-03-14 14:10:37 -0400556
557 if (version != 4)
558 nfs_show_mountd_options(m, nfss, showdefaults);
559
560#ifdef CONFIG_NFS_V4
561 if (clp->rpc_ops->version == 4)
562 seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
563#endif
David Howellsf7b422b2006-06-09 09:34:33 -0400564}
565
566/*
567 * Describe the mount options on this VFS mountpoint
568 */
569static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
570{
571 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
572
573 nfs_show_mount_options(m, nfss, 0);
574
Chuck Lever5d8515c2007-12-10 14:57:16 -0500575 seq_printf(m, ",addr=%s",
576 rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
577 RPC_DISPLAY_ADDR));
David Howellsf7b422b2006-06-09 09:34:33 -0400578
579 return 0;
580}
581
582/*
583 * Present statistical information for this VFS mountpoint
584 */
585static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
586{
587 int i, cpu;
588 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
589 struct rpc_auth *auth = nfss->client->cl_auth;
590 struct nfs_iostats totals = { };
591
592 seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
593
594 /*
595 * Display all mount option settings
596 */
597 seq_printf(m, "\n\topts:\t");
598 seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
599 seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
600 seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
601 seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
602 nfs_show_mount_options(m, nfss, 1);
603
604 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
605
606 seq_printf(m, "\n\tcaps:\t");
607 seq_printf(m, "caps=0x%x", nfss->caps);
Chuck Lever2d767432008-03-14 14:10:08 -0400608 seq_printf(m, ",wtmult=%u", nfss->wtmult);
609 seq_printf(m, ",dtsize=%u", nfss->dtsize);
610 seq_printf(m, ",bsize=%u", nfss->bsize);
611 seq_printf(m, ",namlen=%u", nfss->namelen);
David Howellsf7b422b2006-06-09 09:34:33 -0400612
613#ifdef CONFIG_NFS_V4
Trond Myklebust40c553192007-12-14 14:56:07 -0500614 if (nfss->nfs_client->rpc_ops->version == 4) {
David Howellsf7b422b2006-06-09 09:34:33 -0400615 seq_printf(m, "\n\tnfsv4:\t");
616 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
617 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
618 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
619 }
620#endif
621
622 /*
623 * Display security flavor in effect for this mount
624 */
Chuck Lever2d767432008-03-14 14:10:08 -0400625 seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
David Howellsf7b422b2006-06-09 09:34:33 -0400626 if (auth->au_flavor)
Chuck Lever2d767432008-03-14 14:10:08 -0400627 seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
David Howellsf7b422b2006-06-09 09:34:33 -0400628
629 /*
630 * Display superblock I/O counters
631 */
632 for_each_possible_cpu(cpu) {
633 struct nfs_iostats *stats;
634
635 preempt_disable();
636 stats = per_cpu_ptr(nfss->io_stats, cpu);
637
638 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
639 totals.events[i] += stats->events[i];
640 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
641 totals.bytes[i] += stats->bytes[i];
642
643 preempt_enable();
644 }
645
646 seq_printf(m, "\n\tevents:\t");
647 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
648 seq_printf(m, "%lu ", totals.events[i]);
649 seq_printf(m, "\n\tbytes:\t");
650 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
651 seq_printf(m, "%Lu ", totals.bytes[i]);
652 seq_printf(m, "\n");
653
654 rpc_print_iostats(m, nfss->client);
655
656 return 0;
657}
658
659/*
660 * Begin unmount by attempting to remove all automounted mountpoints we added
David Howells54ceac42006-08-22 20:06:13 -0400661 * in response to xdev traversals and referrals
David Howellsf7b422b2006-06-09 09:34:33 -0400662 */
Al Viro42faad92008-04-24 07:21:56 -0400663static void nfs_umount_begin(struct super_block *sb)
David Howellsf7b422b2006-06-09 09:34:33 -0400664{
Al Viro42faad92008-04-24 07:21:56 -0400665 struct nfs_server *server = NFS_SB(sb);
Trond Myklebustfc6ae3c2007-06-05 19:13:47 -0400666 struct rpc_clnt *rpc;
667
Trond Myklebustfc6ae3c2007-06-05 19:13:47 -0400668 /* -EIO all pending I/O */
669 rpc = server->client_acl;
670 if (!IS_ERR(rpc))
671 rpc_killall_tasks(rpc);
672 rpc = server->client;
673 if (!IS_ERR(rpc))
674 rpc_killall_tasks(rpc);
David Howellsf7b422b2006-06-09 09:34:33 -0400675}
676
677/*
Chuck Levercdcd7f92007-12-10 14:57:45 -0500678 * Sanity-check a server address provided by the mount command.
679 *
680 * Address family must be initialized, and address must not be
681 * the ANY address for that family.
Chuck Leverfc50d582007-07-01 12:12:46 -0400682 */
683static int nfs_verify_server_address(struct sockaddr *addr)
684{
685 switch (addr->sa_family) {
686 case AF_INET: {
Chuck Levercdcd7f92007-12-10 14:57:45 -0500687 struct sockaddr_in *sa = (struct sockaddr_in *)addr;
Al Viroe6f1ceb2008-03-17 22:44:53 -0700688 return sa->sin_addr.s_addr != htonl(INADDR_ANY);
Chuck Levercdcd7f92007-12-10 14:57:45 -0500689 }
690 case AF_INET6: {
691 struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
692 return !ipv6_addr_any(sa);
Chuck Leverfc50d582007-07-01 12:12:46 -0400693 }
694 }
695
696 return 0;
697}
698
Chuck Leverce3b7e12008-06-23 12:36:53 -0400699static void nfs_parse_ipv4_address(char *string, size_t str_len,
700 struct sockaddr *sap, size_t *addr_len)
Chuck Lever9412b922007-12-10 14:59:21 -0500701{
Chuck Leverce3b7e12008-06-23 12:36:53 -0400702 struct sockaddr_in *sin = (struct sockaddr_in *)sap;
703 u8 *addr = (u8 *)&sin->sin_addr.s_addr;
Chuck Lever9412b922007-12-10 14:59:21 -0500704
Chuck Leverce3b7e12008-06-23 12:36:53 -0400705 if (str_len <= INET_ADDRSTRLEN) {
706 dfprintk(MOUNT, "NFS: parsing IPv4 address %*s\n",
707 (int)str_len, string);
Chuck Lever3c7c7e42007-12-10 14:59:35 -0500708
Chuck Leverce3b7e12008-06-23 12:36:53 -0400709 sin->sin_family = AF_INET;
710 *addr_len = sizeof(*sin);
711 if (in4_pton(string, str_len, addr, '\0', NULL))
Chuck Lever3c7c7e42007-12-10 14:59:35 -0500712 return;
713 }
Chuck Lever9412b922007-12-10 14:59:21 -0500714
715 sap->sa_family = AF_UNSPEC;
Chuck Leverce3b7e12008-06-23 12:36:53 -0400716 *addr_len = 0;
717}
718
719#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Chuck Lever5e2e7722008-10-08 15:38:10 -0400720static int nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
721 const char *delim,
722 struct sockaddr_in6 *sin6)
Chuck Leverd8e77482008-06-23 12:37:01 -0400723{
724 char *p;
725 size_t len;
726
Chuck Lever5e2e7722008-10-08 15:38:10 -0400727 if ((string + str_len) == delim)
728 return 1;
729
Chuck Leverd8e77482008-06-23 12:37:01 -0400730 if (*delim != IPV6_SCOPE_DELIMITER)
Chuck Lever5e2e7722008-10-08 15:38:10 -0400731 return 0;
732
733 if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
734 return 0;
Chuck Leverd8e77482008-06-23 12:37:01 -0400735
736 len = (string + str_len) - delim - 1;
737 p = kstrndup(delim + 1, len, GFP_KERNEL);
738 if (p) {
739 unsigned long scope_id = 0;
740 struct net_device *dev;
741
742 dev = dev_get_by_name(&init_net, p);
743 if (dev != NULL) {
744 scope_id = dev->ifindex;
745 dev_put(dev);
746 } else {
Chuck Lever5e2e7722008-10-08 15:38:10 -0400747 if (strict_strtoul(p, 10, &scope_id) == 0) {
748 kfree(p);
749 return 0;
750 }
Chuck Leverd8e77482008-06-23 12:37:01 -0400751 }
752
753 kfree(p);
Chuck Lever5e2e7722008-10-08 15:38:10 -0400754
Chuck Leverd8e77482008-06-23 12:37:01 -0400755 sin6->sin6_scope_id = scope_id;
756 dfprintk(MOUNT, "NFS: IPv6 scope ID = %lu\n", scope_id);
Chuck Lever5e2e7722008-10-08 15:38:10 -0400757 return 1;
Chuck Leverd8e77482008-06-23 12:37:01 -0400758 }
Chuck Lever5e2e7722008-10-08 15:38:10 -0400759
760 return 0;
Chuck Leverd8e77482008-06-23 12:37:01 -0400761}
762
Chuck Leverce3b7e12008-06-23 12:36:53 -0400763static void nfs_parse_ipv6_address(char *string, size_t str_len,
764 struct sockaddr *sap, size_t *addr_len)
765{
766 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
767 u8 *addr = (u8 *)&sin6->sin6_addr.in6_u;
Chuck Leverd8e77482008-06-23 12:37:01 -0400768 const char *delim;
Chuck Leverce3b7e12008-06-23 12:36:53 -0400769
770 if (str_len <= INET6_ADDRSTRLEN) {
771 dfprintk(MOUNT, "NFS: parsing IPv6 address %*s\n",
772 (int)str_len, string);
773
774 sin6->sin6_family = AF_INET6;
775 *addr_len = sizeof(*sin6);
Chuck Lever5e2e7722008-10-08 15:38:10 -0400776 if (in6_pton(string, str_len, addr,
777 IPV6_SCOPE_DELIMITER, &delim) != 0) {
778 if (nfs_parse_ipv6_scope_id(string, str_len,
779 delim, sin6) != 0)
780 return;
Chuck Leverd8e77482008-06-23 12:37:01 -0400781 }
Chuck Leverce3b7e12008-06-23 12:36:53 -0400782 }
783
784 sap->sa_family = AF_UNSPEC;
785 *addr_len = 0;
786}
787#else
788static void nfs_parse_ipv6_address(char *string, size_t str_len,
789 struct sockaddr *sap, size_t *addr_len)
790{
791 sap->sa_family = AF_UNSPEC;
792 *addr_len = 0;
793}
794#endif
795
796/*
797 * Construct a sockaddr based on the contents of a string that contains
798 * an IP address in presentation format.
799 *
800 * If there is a problem constructing the new sockaddr, set the address
801 * family to AF_UNSPEC.
802 */
J. Bruce Fieldsea31a4432008-08-20 16:10:23 -0400803void nfs_parse_ip_address(char *string, size_t str_len,
Chuck Leverce3b7e12008-06-23 12:36:53 -0400804 struct sockaddr *sap, size_t *addr_len)
805{
806 unsigned int i, colons;
807
808 colons = 0;
809 for (i = 0; i < str_len; i++)
810 if (string[i] == ':')
811 colons++;
812
813 if (colons >= 2)
814 nfs_parse_ipv6_address(string, str_len, sap, addr_len);
815 else
816 nfs_parse_ipv4_address(string, str_len, sap, addr_len);
Chuck Lever9412b922007-12-10 14:59:21 -0500817}
818
819/*
Trond Myklebust259875e2008-07-02 14:43:47 -0400820 * Sanity check the NFS transport protocol.
821 *
822 */
823static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
824{
825 switch (mnt->nfs_server.protocol) {
826 case XPRT_TRANSPORT_UDP:
827 case XPRT_TRANSPORT_TCP:
828 case XPRT_TRANSPORT_RDMA:
829 break;
830 default:
831 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
832 }
833}
834
835/*
836 * For text based NFSv2/v3 mounts, the mount protocol transport default
837 * settings should depend upon the specified NFS transport.
838 */
839static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
840{
841 nfs_validate_transport_protocol(mnt);
842
843 if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
844 mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
845 return;
846 switch (mnt->nfs_server.protocol) {
847 case XPRT_TRANSPORT_UDP:
848 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
849 break;
850 case XPRT_TRANSPORT_TCP:
851 case XPRT_TRANSPORT_RDMA:
852 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
853 }
854}
855
856/*
Chuck Lever01060c82008-06-24 16:33:38 -0400857 * Parse the value of the 'sec=' option.
858 *
Chuck Leverdd07c942008-06-24 16:33:46 -0400859 * The flavor_len setting is for v4 mounts.
Chuck Lever01060c82008-06-24 16:33:38 -0400860 */
861static int nfs_parse_security_flavors(char *value,
862 struct nfs_parsed_mount_data *mnt)
863{
864 substring_t args[MAX_OPT_ARGS];
865
866 dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
867
868 switch (match_token(value, nfs_secflavor_tokens, args)) {
869 case Opt_sec_none:
Chuck Lever01060c82008-06-24 16:33:38 -0400870 mnt->auth_flavor_len = 0;
871 mnt->auth_flavors[0] = RPC_AUTH_NULL;
872 break;
873 case Opt_sec_sys:
Chuck Lever01060c82008-06-24 16:33:38 -0400874 mnt->auth_flavor_len = 0;
875 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
876 break;
877 case Opt_sec_krb5:
Chuck Lever01060c82008-06-24 16:33:38 -0400878 mnt->auth_flavor_len = 1;
879 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
880 break;
881 case Opt_sec_krb5i:
Chuck Lever01060c82008-06-24 16:33:38 -0400882 mnt->auth_flavor_len = 1;
883 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
884 break;
885 case Opt_sec_krb5p:
Chuck Lever01060c82008-06-24 16:33:38 -0400886 mnt->auth_flavor_len = 1;
887 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
888 break;
889 case Opt_sec_lkey:
Chuck Lever01060c82008-06-24 16:33:38 -0400890 mnt->auth_flavor_len = 1;
891 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
892 break;
893 case Opt_sec_lkeyi:
Chuck Lever01060c82008-06-24 16:33:38 -0400894 mnt->auth_flavor_len = 1;
895 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
896 break;
897 case Opt_sec_lkeyp:
Chuck Lever01060c82008-06-24 16:33:38 -0400898 mnt->auth_flavor_len = 1;
899 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
900 break;
901 case Opt_sec_spkm:
Chuck Lever01060c82008-06-24 16:33:38 -0400902 mnt->auth_flavor_len = 1;
903 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
904 break;
905 case Opt_sec_spkmi:
Chuck Lever01060c82008-06-24 16:33:38 -0400906 mnt->auth_flavor_len = 1;
907 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
908 break;
909 case Opt_sec_spkmp:
Chuck Lever01060c82008-06-24 16:33:38 -0400910 mnt->auth_flavor_len = 1;
911 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
912 break;
913 default:
914 return 0;
915 }
916
917 return 1;
918}
919
Chuck Leverf45663c2008-06-24 19:28:02 -0400920static void nfs_parse_invalid_value(const char *option)
921{
922 dfprintk(MOUNT, "NFS: bad value specified for %s option\n", option);
923}
924
Chuck Lever01060c82008-06-24 16:33:38 -0400925/*
Chuck Leverbf0fd762007-07-01 12:13:44 -0400926 * Error-check and convert a string of mount options from user space into
Chuck Leverf45663c2008-06-24 19:28:02 -0400927 * a data structure. The whole mount string is processed; bad options are
928 * skipped as they are encountered. If there were no errors, return 1;
929 * otherwise return 0 (zero).
Chuck Leverbf0fd762007-07-01 12:13:44 -0400930 */
931static int nfs_parse_mount_options(char *raw,
932 struct nfs_parsed_mount_data *mnt)
933{
Eric Parisf9c3a382008-03-05 14:20:18 -0500934 char *p, *string, *secdata;
Chuck Leverf45663c2008-06-24 19:28:02 -0400935 int rc, sloppy = 0, errors = 0;
Chuck Leverbf0fd762007-07-01 12:13:44 -0400936
937 if (!raw) {
938 dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
939 return 1;
940 }
941 dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
942
Eric Parisf9c3a382008-03-05 14:20:18 -0500943 secdata = alloc_secdata();
944 if (!secdata)
945 goto out_nomem;
946
947 rc = security_sb_copy_data(raw, secdata);
948 if (rc)
949 goto out_security_failure;
950
951 rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
952 if (rc)
953 goto out_security_failure;
954
955 free_secdata(secdata);
956
Chuck Leverbf0fd762007-07-01 12:13:44 -0400957 while ((p = strsep(&raw, ",")) != NULL) {
958 substring_t args[MAX_OPT_ARGS];
959 int option, token;
960
961 if (!*p)
962 continue;
963
964 dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
965
966 token = match_token(p, nfs_mount_option_tokens, args);
967 switch (token) {
Chuck Leverf45663c2008-06-24 19:28:02 -0400968
969 /*
970 * boolean options: foo/nofoo
971 */
Chuck Leverbf0fd762007-07-01 12:13:44 -0400972 case Opt_soft:
973 mnt->flags |= NFS_MOUNT_SOFT;
974 break;
975 case Opt_hard:
976 mnt->flags &= ~NFS_MOUNT_SOFT;
977 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -0400978 case Opt_posix:
979 mnt->flags |= NFS_MOUNT_POSIX;
980 break;
981 case Opt_noposix:
982 mnt->flags &= ~NFS_MOUNT_POSIX;
983 break;
984 case Opt_cto:
985 mnt->flags &= ~NFS_MOUNT_NOCTO;
986 break;
987 case Opt_nocto:
988 mnt->flags |= NFS_MOUNT_NOCTO;
989 break;
990 case Opt_ac:
991 mnt->flags &= ~NFS_MOUNT_NOAC;
992 break;
993 case Opt_noac:
994 mnt->flags |= NFS_MOUNT_NOAC;
995 break;
996 case Opt_lock:
997 mnt->flags &= ~NFS_MOUNT_NONLM;
998 break;
999 case Opt_nolock:
1000 mnt->flags |= NFS_MOUNT_NONLM;
1001 break;
1002 case Opt_v2:
1003 mnt->flags &= ~NFS_MOUNT_VER3;
1004 break;
1005 case Opt_v3:
1006 mnt->flags |= NFS_MOUNT_VER3;
1007 break;
1008 case Opt_udp:
1009 mnt->flags &= ~NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001010 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001011 break;
1012 case Opt_tcp:
1013 mnt->flags |= NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001014 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001015 break;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001016 case Opt_rdma:
1017 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
1018 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001019 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001020 case Opt_acl:
1021 mnt->flags &= ~NFS_MOUNT_NOACL;
1022 break;
1023 case Opt_noacl:
1024 mnt->flags |= NFS_MOUNT_NOACL;
1025 break;
1026 case Opt_rdirplus:
1027 mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
1028 break;
1029 case Opt_nordirplus:
1030 mnt->flags |= NFS_MOUNT_NORDIRPLUS;
1031 break;
Trond Myklebust75180df2007-05-16 16:53:28 -04001032 case Opt_sharecache:
1033 mnt->flags &= ~NFS_MOUNT_UNSHARED;
1034 break;
1035 case Opt_nosharecache:
1036 mnt->flags |= NFS_MOUNT_UNSHARED;
1037 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001038
Chuck Leverf45663c2008-06-24 19:28:02 -04001039 /*
1040 * options that take numeric values
1041 */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001042 case Opt_port:
Chuck Leverf45663c2008-06-24 19:28:02 -04001043 if (match_int(args, &option) ||
1044 option < 0 || option > USHORT_MAX) {
1045 errors++;
1046 nfs_parse_invalid_value("port");
1047 } else
1048 mnt->nfs_server.port = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001049 break;
1050 case Opt_rsize:
Chuck Leverf45663c2008-06-24 19:28:02 -04001051 if (match_int(args, &option) || option < 0) {
1052 errors++;
1053 nfs_parse_invalid_value("rsize");
1054 } else
1055 mnt->rsize = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001056 break;
1057 case Opt_wsize:
Chuck Leverf45663c2008-06-24 19:28:02 -04001058 if (match_int(args, &option) || option < 0) {
1059 errors++;
1060 nfs_parse_invalid_value("wsize");
1061 } else
1062 mnt->wsize = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001063 break;
1064 case Opt_bsize:
Chuck Leverf45663c2008-06-24 19:28:02 -04001065 if (match_int(args, &option) || option < 0) {
1066 errors++;
1067 nfs_parse_invalid_value("bsize");
1068 } else
1069 mnt->bsize = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001070 break;
1071 case Opt_timeo:
Chuck Leverf45663c2008-06-24 19:28:02 -04001072 if (match_int(args, &option) || option <= 0) {
1073 errors++;
1074 nfs_parse_invalid_value("timeo");
1075 } else
1076 mnt->timeo = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001077 break;
1078 case Opt_retrans:
Chuck Leverf45663c2008-06-24 19:28:02 -04001079 if (match_int(args, &option) || option <= 0) {
1080 errors++;
1081 nfs_parse_invalid_value("retrans");
1082 } else
1083 mnt->retrans = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001084 break;
1085 case Opt_acregmin:
Chuck Leverf45663c2008-06-24 19:28:02 -04001086 if (match_int(args, &option) || option < 0) {
1087 errors++;
1088 nfs_parse_invalid_value("acregmin");
1089 } else
1090 mnt->acregmin = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001091 break;
1092 case Opt_acregmax:
Chuck Leverf45663c2008-06-24 19:28:02 -04001093 if (match_int(args, &option) || option < 0) {
1094 errors++;
1095 nfs_parse_invalid_value("acregmax");
1096 } else
1097 mnt->acregmax = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001098 break;
1099 case Opt_acdirmin:
Chuck Leverf45663c2008-06-24 19:28:02 -04001100 if (match_int(args, &option) || option < 0) {
1101 errors++;
1102 nfs_parse_invalid_value("acdirmin");
1103 } else
1104 mnt->acdirmin = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001105 break;
1106 case Opt_acdirmax:
Chuck Leverf45663c2008-06-24 19:28:02 -04001107 if (match_int(args, &option) || option < 0) {
1108 errors++;
1109 nfs_parse_invalid_value("acdirmax");
1110 } else
1111 mnt->acdirmax = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001112 break;
1113 case Opt_actimeo:
Chuck Leverf45663c2008-06-24 19:28:02 -04001114 if (match_int(args, &option) || option < 0) {
1115 errors++;
1116 nfs_parse_invalid_value("actimeo");
1117 } else
1118 mnt->acregmin = mnt->acregmax =
1119 mnt->acdirmin = mnt->acdirmax = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001120 break;
1121 case Opt_namelen:
Chuck Leverf45663c2008-06-24 19:28:02 -04001122 if (match_int(args, &option) || option < 0) {
1123 errors++;
1124 nfs_parse_invalid_value("namlen");
1125 } else
1126 mnt->namlen = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001127 break;
1128 case Opt_mountport:
Chuck Leverf45663c2008-06-24 19:28:02 -04001129 if (match_int(args, &option) ||
1130 option < 0 || option > USHORT_MAX) {
1131 errors++;
1132 nfs_parse_invalid_value("mountport");
1133 } else
1134 mnt->mount_server.port = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001135 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001136 case Opt_mountvers:
Chuck Leverf45663c2008-06-24 19:28:02 -04001137 if (match_int(args, &option) ||
1138 option < NFS_MNT_VERSION ||
1139 option > NFS_MNT3_VERSION) {
1140 errors++;
1141 nfs_parse_invalid_value("mountvers");
1142 } else
1143 mnt->mount_server.version = option;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001144 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001145 case Opt_nfsvers:
Chuck Leverf45663c2008-06-24 19:28:02 -04001146 if (match_int(args, &option)) {
1147 errors++;
1148 nfs_parse_invalid_value("nfsvers");
1149 break;
1150 }
Chuck Leverbf0fd762007-07-01 12:13:44 -04001151 switch (option) {
Chuck Leverf45663c2008-06-24 19:28:02 -04001152 case NFS2_VERSION:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001153 mnt->flags &= ~NFS_MOUNT_VER3;
1154 break;
Chuck Leverf45663c2008-06-24 19:28:02 -04001155 case NFS3_VERSION:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001156 mnt->flags |= NFS_MOUNT_VER3;
1157 break;
1158 default:
Chuck Leverf45663c2008-06-24 19:28:02 -04001159 errors++;
1160 nfs_parse_invalid_value("nfsvers");
Chuck Leverbf0fd762007-07-01 12:13:44 -04001161 }
1162 break;
1163
Chuck Leverf45663c2008-06-24 19:28:02 -04001164 /*
1165 * options that take text values
1166 */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001167 case Opt_sec:
1168 string = match_strdup(args);
1169 if (string == NULL)
1170 goto out_nomem;
Chuck Lever01060c82008-06-24 16:33:38 -04001171 rc = nfs_parse_security_flavors(string, mnt);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001172 kfree(string);
Chuck Leverf45663c2008-06-24 19:28:02 -04001173 if (!rc) {
1174 errors++;
1175 dfprintk(MOUNT, "NFS: unrecognized "
1176 "security flavor\n");
1177 }
Chuck Leverbf0fd762007-07-01 12:13:44 -04001178 break;
1179 case Opt_proto:
1180 string = match_strdup(args);
1181 if (string == NULL)
1182 goto out_nomem;
1183 token = match_token(string,
1184 nfs_xprt_protocol_tokens, args);
1185 kfree(string);
1186
1187 switch (token) {
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001188 case Opt_xprt_udp:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001189 mnt->flags &= ~NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001190 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001191 break;
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001192 case Opt_xprt_tcp:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001193 mnt->flags |= NFS_MOUNT_TCP;
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001194 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001195 break;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001196 case Opt_xprt_rdma:
1197 /* vector side protocols to TCP */
1198 mnt->flags |= NFS_MOUNT_TCP;
1199 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001200 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001201 default:
Chuck Leverf45663c2008-06-24 19:28:02 -04001202 errors++;
1203 dfprintk(MOUNT, "NFS: unrecognized "
1204 "transport protocol\n");
Chuck Leverbf0fd762007-07-01 12:13:44 -04001205 }
1206 break;
1207 case Opt_mountproto:
1208 string = match_strdup(args);
1209 if (string == NULL)
1210 goto out_nomem;
1211 token = match_token(string,
1212 nfs_xprt_protocol_tokens, args);
1213 kfree(string);
1214
1215 switch (token) {
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001216 case Opt_xprt_udp:
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001217 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001218 break;
Chuck Leverfdb66ff2007-08-29 17:58:57 -04001219 case Opt_xprt_tcp:
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001220 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001221 break;
\"Talpey, Thomas\2cf7ff72007-09-10 13:49:41 -04001222 case Opt_xprt_rdma: /* not used for side protocols */
Chuck Leverbf0fd762007-07-01 12:13:44 -04001223 default:
Chuck Leverf45663c2008-06-24 19:28:02 -04001224 errors++;
1225 dfprintk(MOUNT, "NFS: unrecognized "
1226 "transport protocol\n");
Chuck Leverbf0fd762007-07-01 12:13:44 -04001227 }
1228 break;
1229 case Opt_addr:
1230 string = match_strdup(args);
1231 if (string == NULL)
1232 goto out_nomem;
Chuck Leverce3b7e12008-06-23 12:36:53 -04001233 nfs_parse_ip_address(string, strlen(string),
1234 (struct sockaddr *)
1235 &mnt->nfs_server.address,
1236 &mnt->nfs_server.addrlen);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001237 kfree(string);
1238 break;
1239 case Opt_clientaddr:
1240 string = match_strdup(args);
1241 if (string == NULL)
1242 goto out_nomem;
Chuck Leverfc601472008-01-16 16:38:10 -05001243 kfree(mnt->client_address);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001244 mnt->client_address = string;
1245 break;
Chuck Lever33832032007-12-10 14:59:13 -05001246 case Opt_mounthost:
1247 string = match_strdup(args);
1248 if (string == NULL)
1249 goto out_nomem;
Chuck Leverfc601472008-01-16 16:38:10 -05001250 kfree(mnt->mount_server.hostname);
Chuck Lever33832032007-12-10 14:59:13 -05001251 mnt->mount_server.hostname = string;
1252 break;
Chuck Lever0ac83772007-09-11 18:01:04 -04001253 case Opt_mountaddr:
Chuck Leverbf0fd762007-07-01 12:13:44 -04001254 string = match_strdup(args);
1255 if (string == NULL)
1256 goto out_nomem;
Chuck Leverce3b7e12008-06-23 12:36:53 -04001257 nfs_parse_ip_address(string, strlen(string),
1258 (struct sockaddr *)
1259 &mnt->mount_server.address,
1260 &mnt->mount_server.addrlen);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001261 kfree(string);
1262 break;
Trond Myklebust7973c1f2008-07-15 17:58:14 -04001263 case Opt_lookupcache:
1264 string = match_strdup(args);
1265 if (string == NULL)
1266 goto out_nomem;
1267 token = match_token(string,
1268 nfs_lookupcache_tokens, args);
1269 kfree(string);
1270 switch (token) {
1271 case Opt_lookupcache_all:
1272 mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
1273 break;
1274 case Opt_lookupcache_positive:
1275 mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
1276 mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
1277 break;
1278 case Opt_lookupcache_none:
1279 mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
1280 break;
1281 default:
1282 errors++;
1283 dfprintk(MOUNT, "NFS: invalid "
1284 "lookupcache argument\n");
1285 };
1286 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001287
Chuck Leverf45663c2008-06-24 19:28:02 -04001288 /*
1289 * Special options
1290 */
1291 case Opt_sloppy:
1292 sloppy = 1;
1293 dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
1294 break;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001295 case Opt_userspace:
1296 case Opt_deprecated:
Chuck Leverd33e4df2008-06-12 12:37:41 -04001297 dfprintk(MOUNT, "NFS: ignoring mount option "
1298 "'%s'\n", p);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001299 break;
1300
1301 default:
Chuck Leverf45663c2008-06-24 19:28:02 -04001302 errors++;
1303 dfprintk(MOUNT, "NFS: unrecognized mount option "
1304 "'%s'\n", p);
Chuck Leverbf0fd762007-07-01 12:13:44 -04001305 }
1306 }
1307
Chuck Leveraf904de2008-09-08 11:58:13 -04001308 if (errors > 0) {
1309 dfprintk(MOUNT, "NFS: parsing encountered %d error%s\n",
1310 errors, (errors == 1 ? "" : "s"));
1311 if (!sloppy)
1312 return 0;
1313 }
Chuck Leverbf0fd762007-07-01 12:13:44 -04001314 return 1;
1315
1316out_nomem:
1317 printk(KERN_INFO "NFS: not enough memory to parse option\n");
1318 return 0;
Eric Parisf9c3a382008-03-05 14:20:18 -05001319out_security_failure:
1320 free_secdata(secdata);
1321 printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1322 return 0;
Chuck Leverbf0fd762007-07-01 12:13:44 -04001323}
1324
1325/*
Chuck Lever0076d7b2007-07-01 12:13:49 -04001326 * Use the remote server's MOUNT service to request the NFS file handle
1327 * corresponding to the provided path.
1328 */
1329static int nfs_try_mount(struct nfs_parsed_mount_data *args,
1330 struct nfs_fh *root_fh)
1331{
Chuck Lever4c568012007-12-10 14:59:28 -05001332 struct sockaddr *sap = (struct sockaddr *)&args->mount_server.address;
Chuck Lever33832032007-12-10 14:59:13 -05001333 char *hostname;
Chuck Lever4c568012007-12-10 14:59:28 -05001334 int status;
Chuck Lever0076d7b2007-07-01 12:13:49 -04001335
1336 if (args->mount_server.version == 0) {
1337 if (args->flags & NFS_MOUNT_VER3)
1338 args->mount_server.version = NFS_MNT3_VERSION;
1339 else
1340 args->mount_server.version = NFS_MNT_VERSION;
1341 }
1342
Chuck Lever33832032007-12-10 14:59:13 -05001343 if (args->mount_server.hostname)
1344 hostname = args->mount_server.hostname;
1345 else
1346 hostname = args->nfs_server.hostname;
1347
Chuck Lever0076d7b2007-07-01 12:13:49 -04001348 /*
1349 * Construct the mount server's address.
1350 */
Chuck Lever4c568012007-12-10 14:59:28 -05001351 if (args->mount_server.address.ss_family == AF_UNSPEC) {
1352 memcpy(sap, &args->nfs_server.address,
1353 args->nfs_server.addrlen);
1354 args->mount_server.addrlen = args->nfs_server.addrlen;
1355 }
1356
James Lentiniaad70002007-09-24 17:32:49 -04001357 /*
1358 * autobind will be used if mount_server.port == 0
1359 */
Chuck Lever4c568012007-12-10 14:59:28 -05001360 nfs_set_port(sap, args->mount_server.port);
Chuck Lever0076d7b2007-07-01 12:13:49 -04001361
1362 /*
1363 * Now ask the mount server to map our export path
1364 * to a file handle.
1365 */
Chuck Lever4c568012007-12-10 14:59:28 -05001366 status = nfs_mount(sap,
1367 args->mount_server.addrlen,
Chuck Lever33832032007-12-10 14:59:13 -05001368 hostname,
Chuck Lever0076d7b2007-07-01 12:13:49 -04001369 args->nfs_server.export_path,
1370 args->mount_server.version,
1371 args->mount_server.protocol,
1372 root_fh);
Chuck Leverefd83402007-09-11 18:00:58 -04001373 if (status == 0)
1374 return 0;
Chuck Lever0076d7b2007-07-01 12:13:49 -04001375
Chuck Lever396cee92008-06-12 12:37:49 -04001376 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
Chuck Lever33832032007-12-10 14:59:13 -05001377 hostname, status);
Chuck Lever0076d7b2007-07-01 12:13:49 -04001378 return status;
1379}
1380
Chuck Leverd1aa0822008-06-23 12:36:45 -04001381static int nfs_parse_simple_hostname(const char *dev_name,
1382 char **hostname, size_t maxnamlen,
1383 char **export_path, size_t maxpathlen)
Chuck Leverdc045892008-06-23 12:36:37 -04001384{
1385 size_t len;
1386 char *colon, *comma;
1387
1388 colon = strchr(dev_name, ':');
1389 if (colon == NULL)
1390 goto out_bad_devname;
1391
1392 len = colon - dev_name;
1393 if (len > maxnamlen)
1394 goto out_hostname;
1395
1396 /* N.B. caller will free nfs_server.hostname in all cases */
1397 *hostname = kstrndup(dev_name, len, GFP_KERNEL);
1398 if (!*hostname)
1399 goto out_nomem;
1400
1401 /* kill possible hostname list: not supported */
1402 comma = strchr(*hostname, ',');
1403 if (comma != NULL) {
1404 if (comma == *hostname)
1405 goto out_bad_devname;
1406 *comma = '\0';
1407 }
1408
1409 colon++;
1410 len = strlen(colon);
1411 if (len > maxpathlen)
1412 goto out_path;
1413 *export_path = kstrndup(colon, len, GFP_KERNEL);
1414 if (!*export_path)
1415 goto out_nomem;
1416
1417 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1418 return 0;
1419
1420out_bad_devname:
1421 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1422 return -EINVAL;
1423
1424out_nomem:
1425 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1426 return -ENOMEM;
1427
1428out_hostname:
1429 dfprintk(MOUNT, "NFS: server hostname too long\n");
1430 return -ENAMETOOLONG;
1431
1432out_path:
1433 dfprintk(MOUNT, "NFS: export pathname too long\n");
1434 return -ENAMETOOLONG;
1435}
1436
1437/*
Chuck Leverd1aa0822008-06-23 12:36:45 -04001438 * Hostname has square brackets around it because it contains one or
1439 * more colons. We look for the first closing square bracket, and a
1440 * colon must follow it.
1441 */
1442static int nfs_parse_protected_hostname(const char *dev_name,
1443 char **hostname, size_t maxnamlen,
1444 char **export_path, size_t maxpathlen)
1445{
1446 size_t len;
1447 char *start, *end;
1448
1449 start = (char *)(dev_name + 1);
1450
1451 end = strchr(start, ']');
1452 if (end == NULL)
1453 goto out_bad_devname;
1454 if (*(end + 1) != ':')
1455 goto out_bad_devname;
1456
1457 len = end - start;
1458 if (len > maxnamlen)
1459 goto out_hostname;
1460
1461 /* N.B. caller will free nfs_server.hostname in all cases */
1462 *hostname = kstrndup(start, len, GFP_KERNEL);
1463 if (*hostname == NULL)
1464 goto out_nomem;
1465
1466 end += 2;
1467 len = strlen(end);
1468 if (len > maxpathlen)
1469 goto out_path;
1470 *export_path = kstrndup(end, len, GFP_KERNEL);
1471 if (!*export_path)
1472 goto out_nomem;
1473
1474 return 0;
1475
1476out_bad_devname:
1477 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1478 return -EINVAL;
1479
1480out_nomem:
1481 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1482 return -ENOMEM;
1483
1484out_hostname:
1485 dfprintk(MOUNT, "NFS: server hostname too long\n");
1486 return -ENAMETOOLONG;
1487
1488out_path:
1489 dfprintk(MOUNT, "NFS: export pathname too long\n");
1490 return -ENAMETOOLONG;
1491}
1492
1493/*
1494 * Split "dev_name" into "hostname:export_path".
1495 *
1496 * The leftmost colon demarks the split between the server's hostname
1497 * and the export path. If the hostname starts with a left square
1498 * bracket, then it may contain colons.
1499 *
1500 * Note: caller frees hostname and export path, even on error.
1501 */
1502static int nfs_parse_devname(const char *dev_name,
1503 char **hostname, size_t maxnamlen,
1504 char **export_path, size_t maxpathlen)
1505{
1506 if (*dev_name == '[')
1507 return nfs_parse_protected_hostname(dev_name,
1508 hostname, maxnamlen,
1509 export_path, maxpathlen);
1510
1511 return nfs_parse_simple_hostname(dev_name,
1512 hostname, maxnamlen,
1513 export_path, maxpathlen);
1514}
1515
1516/*
David Howells54ceac42006-08-22 20:06:13 -04001517 * Validate the NFS2/NFS3 mount data
1518 * - fills in the mount root filehandle
Chuck Lever136d5582007-07-01 12:13:54 -04001519 *
1520 * For option strings, user space handles the following behaviors:
1521 *
1522 * + DNS: mapping server host name to IP address ("addr=" option)
1523 *
1524 * + failure mode: how to behave if a mount request can't be handled
1525 * immediately ("fg/bg" option)
1526 *
1527 * + retry: how often to retry a mount request ("retry=" option)
1528 *
1529 * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
1530 * mountproto=tcp after mountproto=udp, and so on
David Howellsf7b422b2006-06-09 09:34:33 -04001531 */
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001532static int nfs_validate_mount_data(void *options,
1533 struct nfs_parsed_mount_data *args,
Chuck Lever136d5582007-07-01 12:13:54 -04001534 struct nfs_fh *mntfh,
1535 const char *dev_name)
David Howellsf7b422b2006-06-09 09:34:33 -04001536{
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001537 struct nfs_mount_data *data = (struct nfs_mount_data *)options;
Chuck Lever136d5582007-07-01 12:13:54 -04001538
Chuck Lever5df36e72007-07-01 12:12:56 -04001539 if (data == NULL)
1540 goto out_no_data;
David Howells54ceac42006-08-22 20:06:13 -04001541
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001542 args->flags = (NFS_MOUNT_VER3 | NFS_MOUNT_TCP);
1543 args->rsize = NFS_MAX_FILE_IO_SIZE;
1544 args->wsize = NFS_MAX_FILE_IO_SIZE;
Chuck Lever0e0cab72008-06-26 17:47:12 -04001545 args->acregmin = NFS_DEF_ACREGMIN;
1546 args->acregmax = NFS_DEF_ACREGMAX;
1547 args->acdirmin = NFS_DEF_ACDIRMIN;
1548 args->acdirmax = NFS_DEF_ACDIRMAX;
Chuck Leverf22d6d72008-03-14 14:10:22 -04001549 args->mount_server.port = 0; /* autobind unless user sets port */
Chuck Leverf22d6d72008-03-14 14:10:22 -04001550 args->nfs_server.port = 0; /* autobind unless user sets port */
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001551 args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
Chuck Leverdd07c942008-06-24 16:33:46 -04001552 args->auth_flavors[0] = RPC_AUTH_UNIX;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001553
David Howellsf7b422b2006-06-09 09:34:33 -04001554 switch (data->version) {
Chuck Lever5df36e72007-07-01 12:12:56 -04001555 case 1:
1556 data->namlen = 0;
1557 case 2:
1558 data->bsize = 0;
1559 case 3:
1560 if (data->flags & NFS_MOUNT_VER3)
1561 goto out_no_v3;
1562 data->root.size = NFS2_FHSIZE;
1563 memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
1564 case 4:
1565 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1566 goto out_no_sec;
1567 case 5:
1568 memset(data->context, 0, sizeof(data->context));
1569 case 6:
Trond Myklebustb7e24452008-06-19 15:21:11 -04001570 if (data->flags & NFS_MOUNT_VER3) {
1571 if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
1572 goto out_invalid_fh;
Chuck Lever5df36e72007-07-01 12:12:56 -04001573 mntfh->size = data->root.size;
Trond Myklebustb7e24452008-06-19 15:21:11 -04001574 } else
Chuck Lever5df36e72007-07-01 12:12:56 -04001575 mntfh->size = NFS2_FHSIZE;
1576
Chuck Lever5df36e72007-07-01 12:12:56 -04001577
1578 memcpy(mntfh->data, data->root.data, mntfh->size);
1579 if (mntfh->size < sizeof(mntfh->data))
1580 memset(mntfh->data + mntfh->size, 0,
1581 sizeof(mntfh->data) - mntfh->size);
Chuck Lever6e88e062007-09-24 15:39:50 -04001582
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001583 /*
1584 * Translate to nfs_parsed_mount_data, which nfs_fill_super
1585 * can deal with.
1586 */
Trond Myklebustff3525a2008-08-15 16:59:14 -04001587 args->flags = data->flags & NFS_MOUNT_FLAGMASK;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001588 args->rsize = data->rsize;
1589 args->wsize = data->wsize;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001590 args->timeo = data->timeo;
1591 args->retrans = data->retrans;
1592 args->acregmin = data->acregmin;
1593 args->acregmax = data->acregmax;
1594 args->acdirmin = data->acdirmin;
1595 args->acdirmax = data->acdirmax;
Chuck Lever4c568012007-12-10 14:59:28 -05001596
1597 memcpy(&args->nfs_server.address, &data->addr,
1598 sizeof(data->addr));
1599 args->nfs_server.addrlen = sizeof(data->addr);
1600 if (!nfs_verify_server_address((struct sockaddr *)
1601 &args->nfs_server.address))
1602 goto out_no_address;
1603
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001604 if (!(data->flags & NFS_MOUNT_TCP))
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -04001605 args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001606 /* N.B. caller will free nfs_server.hostname in all cases */
1607 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
1608 args->namlen = data->namlen;
1609 args->bsize = data->bsize;
Chuck Leverdd07c942008-06-24 16:33:46 -04001610
1611 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1612 args->auth_flavors[0] = data->pseudoflavor;
Cyrill Gorcunov63649bd2008-04-17 20:42:09 +04001613 if (!args->nfs_server.hostname)
1614 goto out_nomem;
Eric Parisf9c3a382008-03-05 14:20:18 -05001615
1616 /*
1617 * The legacy version 6 binary mount data from userspace has a
1618 * field used only to transport selinux information into the
1619 * the kernel. To continue to support that functionality we
1620 * have a touch of selinux knowledge here in the NFS code. The
1621 * userspace code converted context=blah to just blah so we are
1622 * converting back to the full string selinux understands.
1623 */
1624 if (data->context[0]){
1625#ifdef CONFIG_SECURITY_SELINUX
1626 int rc;
1627 char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
1628 if (!opts_str)
1629 return -ENOMEM;
1630 strcpy(opts_str, "context=");
1631 data->context[NFS_MAX_CONTEXT_LEN] = '\0';
1632 strcat(opts_str, &data->context[0]);
1633 rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
1634 kfree(opts_str);
1635 if (rc)
1636 return rc;
1637#else
1638 return -EINVAL;
1639#endif
1640 }
1641
Chuck Lever5df36e72007-07-01 12:12:56 -04001642 break;
Chuck Lever136d5582007-07-01 12:13:54 -04001643 default: {
Chuck Lever136d5582007-07-01 12:13:54 -04001644 int status;
Chuck Lever136d5582007-07-01 12:13:54 -04001645
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001646 if (nfs_parse_mount_options((char *)options, args) == 0)
Chuck Lever136d5582007-07-01 12:13:54 -04001647 return -EINVAL;
1648
Chuck Lever6e88e062007-09-24 15:39:50 -04001649 if (!nfs_verify_server_address((struct sockaddr *)
1650 &args->nfs_server.address))
1651 goto out_no_address;
1652
Chuck Levered596a82008-06-26 17:47:05 -04001653 nfs_set_port((struct sockaddr *)&args->nfs_server.address,
1654 args->nfs_server.port);
1655
Trond Myklebust259875e2008-07-02 14:43:47 -04001656 nfs_set_mount_transport_protocol(args);
1657
Chuck Leverdc045892008-06-23 12:36:37 -04001658 status = nfs_parse_devname(dev_name,
1659 &args->nfs_server.hostname,
1660 PAGE_SIZE,
1661 &args->nfs_server.export_path,
1662 NFS_MAXPATHLEN);
1663 if (!status)
1664 status = nfs_try_mount(args, mntfh);
Chuck Lever136d5582007-07-01 12:13:54 -04001665
Chuck Leverdc045892008-06-23 12:36:37 -04001666 kfree(args->nfs_server.export_path);
1667 args->nfs_server.export_path = NULL;
Chuck Lever136d5582007-07-01 12:13:54 -04001668
Chuck Lever136d5582007-07-01 12:13:54 -04001669 if (status)
Chuck Leverfdc6e2c2007-08-29 17:58:59 -04001670 return status;
Chuck Lever136d5582007-07-01 12:13:54 -04001671
Chuck Lever136d5582007-07-01 12:13:54 -04001672 break;
1673 }
David Howellsf7b422b2006-06-09 09:34:33 -04001674 }
David Howells54ceac42006-08-22 20:06:13 -04001675
David Howellsf7b422b2006-06-09 09:34:33 -04001676#ifndef CONFIG_NFS_V3
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001677 if (args->flags & NFS_MOUNT_VER3)
Chuck Lever5df36e72007-07-01 12:12:56 -04001678 goto out_v3_not_compiled;
1679#endif /* !CONFIG_NFS_V3 */
David Howells54ceac42006-08-22 20:06:13 -04001680
David Howells54ceac42006-08-22 20:06:13 -04001681 return 0;
Chuck Lever5df36e72007-07-01 12:12:56 -04001682
1683out_no_data:
1684 dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
1685 return -EINVAL;
1686
1687out_no_v3:
1688 dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
1689 data->version);
1690 return -EINVAL;
1691
1692out_no_sec:
1693 dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
1694 return -EINVAL;
1695
Chuck Lever5df36e72007-07-01 12:12:56 -04001696#ifndef CONFIG_NFS_V3
1697out_v3_not_compiled:
1698 dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
1699 return -EPROTONOSUPPORT;
1700#endif /* !CONFIG_NFS_V3 */
1701
Cyrill Gorcunov63649bd2008-04-17 20:42:09 +04001702out_nomem:
1703 dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
1704 return -ENOMEM;
1705
Chuck Lever5df36e72007-07-01 12:12:56 -04001706out_no_address:
1707 dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
1708 return -EINVAL;
1709
1710out_invalid_fh:
1711 dfprintk(MOUNT, "NFS: invalid root filehandle\n");
1712 return -EINVAL;
David Howells54ceac42006-08-22 20:06:13 -04001713}
1714
Jeff Layton48b605f2008-06-10 15:38:39 -04001715static int
1716nfs_compare_remount_data(struct nfs_server *nfss,
1717 struct nfs_parsed_mount_data *data)
1718{
1719 if (data->flags != nfss->flags ||
1720 data->rsize != nfss->rsize ||
1721 data->wsize != nfss->wsize ||
1722 data->retrans != nfss->client->cl_timeout->to_retries ||
1723 data->auth_flavors[0] != nfss->client->cl_auth->au_flavor ||
1724 data->acregmin != nfss->acregmin / HZ ||
1725 data->acregmax != nfss->acregmax / HZ ||
1726 data->acdirmin != nfss->acdirmin / HZ ||
1727 data->acdirmax != nfss->acdirmax / HZ ||
1728 data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
1729 data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
1730 memcmp(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
1731 data->nfs_server.addrlen) != 0)
1732 return -EINVAL;
1733
1734 return 0;
1735}
1736
1737static int
1738nfs_remount(struct super_block *sb, int *flags, char *raw_data)
1739{
1740 int error;
1741 struct nfs_server *nfss = sb->s_fs_info;
1742 struct nfs_parsed_mount_data *data;
1743 struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
1744 struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
Trond Myklebustcd100722008-06-17 16:12:00 -04001745 u32 nfsvers = nfss->nfs_client->rpc_ops->version;
Jeff Layton48b605f2008-06-10 15:38:39 -04001746
1747 /*
1748 * Userspace mount programs that send binary options generally send
1749 * them populated with default values. We have no way to know which
1750 * ones were explicitly specified. Fall back to legacy behavior and
1751 * just return success.
1752 */
Marc Zyngier31c94462008-07-17 13:21:55 +02001753 if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
1754 (nfsvers <= 3 && (!options || (options->version >= 1 &&
1755 options->version <= 6))))
Jeff Layton48b605f2008-06-10 15:38:39 -04001756 return 0;
1757
1758 data = kzalloc(sizeof(*data), GFP_KERNEL);
1759 if (data == NULL)
1760 return -ENOMEM;
1761
1762 /* fill out struct with values from existing mount */
1763 data->flags = nfss->flags;
1764 data->rsize = nfss->rsize;
1765 data->wsize = nfss->wsize;
1766 data->retrans = nfss->client->cl_timeout->to_retries;
1767 data->auth_flavors[0] = nfss->client->cl_auth->au_flavor;
1768 data->acregmin = nfss->acregmin / HZ;
1769 data->acregmax = nfss->acregmax / HZ;
1770 data->acdirmin = nfss->acdirmin / HZ;
1771 data->acdirmax = nfss->acdirmax / HZ;
1772 data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
1773 data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
1774 memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
1775 data->nfs_server.addrlen);
1776
1777 /* overwrite those values with any that were specified */
1778 error = nfs_parse_mount_options((char *)options, data);
1779 if (error < 0)
1780 goto out;
1781
1782 /* compare new mount options with old ones */
1783 error = nfs_compare_remount_data(nfss, data);
1784out:
1785 kfree(data);
1786 return error;
1787}
1788
David Howells54ceac42006-08-22 20:06:13 -04001789/*
1790 * Initialise the common bits of the superblock
1791 */
1792static inline void nfs_initialise_sb(struct super_block *sb)
1793{
1794 struct nfs_server *server = NFS_SB(sb);
1795
1796 sb->s_magic = NFS_SUPER_MAGIC;
1797
1798 /* We probably want something more informative here */
1799 snprintf(sb->s_id, sizeof(sb->s_id),
1800 "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
1801
1802 if (sb->s_blocksize == 0)
1803 sb->s_blocksize = nfs_block_bits(server->wsize,
1804 &sb->s_blocksize_bits);
1805
1806 if (server->flags & NFS_MOUNT_NOAC)
1807 sb->s_flags |= MS_SYNCHRONOUS;
1808
1809 nfs_super_set_maxbytes(sb, server->maxfilesize);
1810}
1811
1812/*
1813 * Finish setting up an NFS2/3 superblock
1814 */
\"Talpey, Thomas\2283f8d2007-09-10 13:43:56 -04001815static void nfs_fill_super(struct super_block *sb,
1816 struct nfs_parsed_mount_data *data)
David Howells54ceac42006-08-22 20:06:13 -04001817{
1818 struct nfs_server *server = NFS_SB(sb);
1819
1820 sb->s_blocksize_bits = 0;
1821 sb->s_blocksize = 0;
1822 if (data->bsize)
1823 sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
1824
1825 if (server->flags & NFS_MOUNT_VER3) {
1826 /* The VFS shouldn't apply the umask to mode bits. We will do
1827 * so ourselves when necessary.
1828 */
1829 sb->s_flags |= MS_POSIXACL;
1830 sb->s_time_gran = 1;
1831 }
1832
1833 sb->s_op = &nfs_sops;
1834 nfs_initialise_sb(sb);
1835}
1836
1837/*
1838 * Finish setting up a cloned NFS2/3 superblock
1839 */
1840static void nfs_clone_super(struct super_block *sb,
1841 const struct super_block *old_sb)
1842{
1843 struct nfs_server *server = NFS_SB(sb);
1844
1845 sb->s_blocksize_bits = old_sb->s_blocksize_bits;
1846 sb->s_blocksize = old_sb->s_blocksize;
1847 sb->s_maxbytes = old_sb->s_maxbytes;
1848
1849 if (server->flags & NFS_MOUNT_VER3) {
1850 /* The VFS shouldn't apply the umask to mode bits. We will do
1851 * so ourselves when necessary.
1852 */
1853 sb->s_flags |= MS_POSIXACL;
1854 sb->s_time_gran = 1;
1855 }
1856
1857 sb->s_op = old_sb->s_op;
1858 nfs_initialise_sb(sb);
1859}
1860
Trond Myklebust275a5d22007-05-16 16:53:28 -04001861#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
1862
1863static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
1864{
1865 const struct nfs_server *a = s->s_fs_info;
1866 const struct rpc_clnt *clnt_a = a->client;
1867 const struct rpc_clnt *clnt_b = b->client;
1868
1869 if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
1870 goto Ebusy;
1871 if (a->nfs_client != b->nfs_client)
1872 goto Ebusy;
1873 if (a->flags != b->flags)
1874 goto Ebusy;
1875 if (a->wsize != b->wsize)
1876 goto Ebusy;
1877 if (a->rsize != b->rsize)
1878 goto Ebusy;
1879 if (a->acregmin != b->acregmin)
1880 goto Ebusy;
1881 if (a->acregmax != b->acregmax)
1882 goto Ebusy;
1883 if (a->acdirmin != b->acdirmin)
1884 goto Ebusy;
1885 if (a->acdirmax != b->acdirmax)
1886 goto Ebusy;
1887 if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
1888 goto Ebusy;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04001889 return 1;
Trond Myklebust275a5d22007-05-16 16:53:28 -04001890Ebusy:
Trond Myklebuste89a5a42007-08-31 10:45:17 -04001891 return 0;
1892}
1893
1894struct nfs_sb_mountdata {
1895 struct nfs_server *server;
1896 int mntflags;
1897};
1898
1899static int nfs_set_super(struct super_block *s, void *data)
1900{
1901 struct nfs_sb_mountdata *sb_mntdata = data;
1902 struct nfs_server *server = sb_mntdata->server;
1903 int ret;
1904
1905 s->s_flags = sb_mntdata->mntflags;
1906 s->s_fs_info = server;
1907 ret = set_anon_super(s, server);
1908 if (ret == 0)
1909 server->s_dev = s->s_dev;
1910 return ret;
1911}
1912
Chuck Leverfd00a8f2007-12-10 14:57:38 -05001913static int nfs_compare_super_address(struct nfs_server *server1,
1914 struct nfs_server *server2)
1915{
1916 struct sockaddr *sap1, *sap2;
1917
1918 sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
1919 sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
1920
1921 if (sap1->sa_family != sap2->sa_family)
1922 return 0;
1923
1924 switch (sap1->sa_family) {
1925 case AF_INET: {
1926 struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
1927 struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
1928 if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
1929 return 0;
1930 if (sin1->sin_port != sin2->sin_port)
1931 return 0;
1932 break;
1933 }
1934 case AF_INET6: {
1935 struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
1936 struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
1937 if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
1938 return 0;
1939 if (sin1->sin6_port != sin2->sin6_port)
1940 return 0;
1941 break;
1942 }
1943 default:
1944 return 0;
1945 }
1946
1947 return 1;
1948}
1949
Trond Myklebuste89a5a42007-08-31 10:45:17 -04001950static int nfs_compare_super(struct super_block *sb, void *data)
1951{
1952 struct nfs_sb_mountdata *sb_mntdata = data;
1953 struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
1954 int mntflags = sb_mntdata->mntflags;
1955
Chuck Leverfd00a8f2007-12-10 14:57:38 -05001956 if (!nfs_compare_super_address(old, server))
Trond Myklebuste89a5a42007-08-31 10:45:17 -04001957 return 0;
1958 /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
1959 if (old->flags & NFS_MOUNT_UNSHARED)
1960 return 0;
1961 if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
1962 return 0;
1963 return nfs_compare_mount_options(sb, server, mntflags);
Trond Myklebust275a5d22007-05-16 16:53:28 -04001964}
1965
Miklos Szeredifa799752008-04-30 00:54:33 -07001966static int nfs_bdi_register(struct nfs_server *server)
1967{
1968 return bdi_register_dev(&server->backing_dev_info, server->s_dev);
1969}
1970
David Howells54ceac42006-08-22 20:06:13 -04001971static int nfs_get_sb(struct file_system_type *fs_type,
1972 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
1973{
1974 struct nfs_server *server = NULL;
1975 struct super_block *s;
Trond Myklebust33852a12008-06-19 14:20:11 -04001976 struct nfs_parsed_mount_data *data;
1977 struct nfs_fh *mntfh;
David Howells54ceac42006-08-22 20:06:13 -04001978 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04001979 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04001980 struct nfs_sb_mountdata sb_mntdata = {
1981 .mntflags = flags,
1982 };
Trond Myklebust33852a12008-06-19 14:20:11 -04001983 int error = -ENOMEM;
David Howells54ceac42006-08-22 20:06:13 -04001984
Trond Myklebust33852a12008-06-19 14:20:11 -04001985 data = kzalloc(sizeof(*data), GFP_KERNEL);
1986 mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
1987 if (data == NULL || mntfh == NULL)
1988 goto out_free_fh;
1989
1990 security_init_mnt_opts(&data->lsm_opts);
Eric Parisf9c3a382008-03-05 14:20:18 -05001991
David Howells54ceac42006-08-22 20:06:13 -04001992 /* Validate the mount data */
Trond Myklebust33852a12008-06-19 14:20:11 -04001993 error = nfs_validate_mount_data(raw_data, data, mntfh, dev_name);
David Howells54ceac42006-08-22 20:06:13 -04001994 if (error < 0)
Chuck Lever06559602007-07-01 12:12:35 -04001995 goto out;
David Howells54ceac42006-08-22 20:06:13 -04001996
1997 /* Get a volume representation */
Trond Myklebust33852a12008-06-19 14:20:11 -04001998 server = nfs_create_server(data, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04001999 if (IS_ERR(server)) {
2000 error = PTR_ERR(server);
Chuck Lever06559602007-07-01 12:12:35 -04002001 goto out;
David Howells54ceac42006-08-22 20:06:13 -04002002 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002003 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002004
Trond Myklebust75180df2007-05-16 16:53:28 -04002005 if (server->flags & NFS_MOUNT_UNSHARED)
2006 compare_super = NULL;
2007
David Howells54ceac42006-08-22 20:06:13 -04002008 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002009 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
Trond Myklebust816724e2006-06-24 08:41:41 -04002010 if (IS_ERR(s)) {
2011 error = PTR_ERR(s);
David Howells54ceac42006-08-22 20:06:13 -04002012 goto out_err_nosb;
Trond Myklebust816724e2006-06-24 08:41:41 -04002013 }
2014
David Howells54ceac42006-08-22 20:06:13 -04002015 if (s->s_fs_info != server) {
2016 nfs_free_server(server);
2017 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002018 } else {
2019 error = nfs_bdi_register(server);
2020 if (error)
2021 goto error_splat_super;
David Howellsf7b422b2006-06-09 09:34:33 -04002022 }
David Howells54ceac42006-08-22 20:06:13 -04002023
2024 if (!s->s_root) {
2025 /* initial superblock/root creation */
Trond Myklebust33852a12008-06-19 14:20:11 -04002026 nfs_fill_super(s, data);
David Howells54ceac42006-08-22 20:06:13 -04002027 }
2028
Trond Myklebust33852a12008-06-19 14:20:11 -04002029 mntroot = nfs_get_root(s, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002030 if (IS_ERR(mntroot)) {
2031 error = PTR_ERR(mntroot);
2032 goto error_splat_super;
2033 }
2034
Trond Myklebust33852a12008-06-19 14:20:11 -04002035 error = security_sb_set_mnt_opts(s, &data->lsm_opts);
Eric Parisf9c3a382008-03-05 14:20:18 -05002036 if (error)
2037 goto error_splat_root;
2038
David Howellsf7b422b2006-06-09 09:34:33 -04002039 s->s_flags |= MS_ACTIVE;
David Howells54ceac42006-08-22 20:06:13 -04002040 mnt->mnt_sb = s;
2041 mnt->mnt_root = mntroot;
Chuck Lever06559602007-07-01 12:12:35 -04002042 error = 0;
2043
2044out:
Trond Myklebust33852a12008-06-19 14:20:11 -04002045 kfree(data->nfs_server.hostname);
2046 kfree(data->mount_server.hostname);
2047 security_free_mnt_opts(&data->lsm_opts);
2048out_free_fh:
2049 kfree(mntfh);
2050 kfree(data);
Chuck Lever06559602007-07-01 12:12:35 -04002051 return error;
Trond Myklebust816724e2006-06-24 08:41:41 -04002052
David Howells54ceac42006-08-22 20:06:13 -04002053out_err_nosb:
2054 nfs_free_server(server);
Chuck Lever06559602007-07-01 12:12:35 -04002055 goto out;
David Howells54ceac42006-08-22 20:06:13 -04002056
Eric Parisf9c3a382008-03-05 14:20:18 -05002057error_splat_root:
2058 dput(mntroot);
David Howells54ceac42006-08-22 20:06:13 -04002059error_splat_super:
2060 up_write(&s->s_umount);
2061 deactivate_super(s);
Chuck Lever06559602007-07-01 12:12:35 -04002062 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002063}
2064
David Howells54ceac42006-08-22 20:06:13 -04002065/*
2066 * Destroy an NFS2/3 superblock
2067 */
David Howellsf7b422b2006-06-09 09:34:33 -04002068static void nfs_kill_super(struct super_block *s)
2069{
2070 struct nfs_server *server = NFS_SB(s);
2071
Miklos Szeredifa799752008-04-30 00:54:33 -07002072 bdi_unregister(&server->backing_dev_info);
David Howellsf7b422b2006-06-09 09:34:33 -04002073 kill_anon_super(s);
David Howells54ceac42006-08-22 20:06:13 -04002074 nfs_free_server(server);
David Howellsf7b422b2006-06-09 09:34:33 -04002075}
2076
David Howells54ceac42006-08-22 20:06:13 -04002077/*
2078 * Clone an NFS2/3 server record on xdev traversal (FSID-change)
2079 */
2080static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
2081 const char *dev_name, void *raw_data,
2082 struct vfsmount *mnt)
David Howellsf7b422b2006-06-09 09:34:33 -04002083{
2084 struct nfs_clone_mount *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002085 struct super_block *s;
2086 struct nfs_server *server;
2087 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04002088 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002089 struct nfs_sb_mountdata sb_mntdata = {
2090 .mntflags = flags,
2091 };
David Howells54ceac42006-08-22 20:06:13 -04002092 int error;
2093
2094 dprintk("--> nfs_xdev_get_sb()\n");
2095
2096 /* create a new volume representation */
2097 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
2098 if (IS_ERR(server)) {
2099 error = PTR_ERR(server);
2100 goto out_err_noserver;
2101 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002102 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002103
Trond Myklebust75180df2007-05-16 16:53:28 -04002104 if (server->flags & NFS_MOUNT_UNSHARED)
2105 compare_super = NULL;
2106
David Howells54ceac42006-08-22 20:06:13 -04002107 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002108 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
David Howells54ceac42006-08-22 20:06:13 -04002109 if (IS_ERR(s)) {
2110 error = PTR_ERR(s);
2111 goto out_err_nosb;
2112 }
2113
2114 if (s->s_fs_info != server) {
2115 nfs_free_server(server);
2116 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002117 } else {
2118 error = nfs_bdi_register(server);
2119 if (error)
2120 goto error_splat_super;
David Howells54ceac42006-08-22 20:06:13 -04002121 }
2122
2123 if (!s->s_root) {
2124 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002125 nfs_clone_super(s, data->sb);
2126 }
2127
2128 mntroot = nfs_get_root(s, data->fh);
2129 if (IS_ERR(mntroot)) {
2130 error = PTR_ERR(mntroot);
2131 goto error_splat_super;
2132 }
Trond Myklebuste9cc6c22008-01-02 13:28:57 -05002133 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
Neil Brown4c1fe2f2007-11-01 16:50:20 +11002134 dput(mntroot);
2135 error = -ESTALE;
2136 goto error_splat_super;
2137 }
David Howells54ceac42006-08-22 20:06:13 -04002138
2139 s->s_flags |= MS_ACTIVE;
2140 mnt->mnt_sb = s;
2141 mnt->mnt_root = mntroot;
2142
Eric Parisf9c3a382008-03-05 14:20:18 -05002143 /* clone any lsm security options from the parent to the new sb */
2144 security_sb_clone_mnt_opts(data->sb, s);
2145
David Howells54ceac42006-08-22 20:06:13 -04002146 dprintk("<-- nfs_xdev_get_sb() = 0\n");
2147 return 0;
2148
2149out_err_nosb:
2150 nfs_free_server(server);
2151out_err_noserver:
2152 dprintk("<-- nfs_xdev_get_sb() = %d [error]\n", error);
2153 return error;
2154
2155error_splat_super:
2156 up_write(&s->s_umount);
2157 deactivate_super(s);
2158 dprintk("<-- nfs_xdev_get_sb() = %d [splat]\n", error);
2159 return error;
David Howellsf7b422b2006-06-09 09:34:33 -04002160}
2161
2162#ifdef CONFIG_NFS_V4
David Howells54ceac42006-08-22 20:06:13 -04002163
2164/*
2165 * Finish setting up a cloned NFS4 superblock
2166 */
2167static void nfs4_clone_super(struct super_block *sb,
2168 const struct super_block *old_sb)
David Howellsf7b422b2006-06-09 09:34:33 -04002169{
David Howells54ceac42006-08-22 20:06:13 -04002170 sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2171 sb->s_blocksize = old_sb->s_blocksize;
2172 sb->s_maxbytes = old_sb->s_maxbytes;
2173 sb->s_time_gran = 1;
2174 sb->s_op = old_sb->s_op;
2175 nfs_initialise_sb(sb);
David Howellsf7b422b2006-06-09 09:34:33 -04002176}
2177
2178/*
2179 * Set up an NFS4 superblock
2180 */
David Howells54ceac42006-08-22 20:06:13 -04002181static void nfs4_fill_super(struct super_block *sb)
David Howellsf7b422b2006-06-09 09:34:33 -04002182{
David Howellsf7b422b2006-06-09 09:34:33 -04002183 sb->s_time_gran = 1;
David Howellsf7b422b2006-06-09 09:34:33 -04002184 sb->s_op = &nfs4_sops;
David Howells54ceac42006-08-22 20:06:13 -04002185 nfs_initialise_sb(sb);
David Howellsf7b422b2006-06-09 09:34:33 -04002186}
2187
David Howells54ceac42006-08-22 20:06:13 -04002188/*
Chuck Leverf0768eb2007-07-01 12:13:01 -04002189 * Validate NFSv4 mount options
2190 */
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002191static int nfs4_validate_mount_data(void *options,
2192 struct nfs_parsed_mount_data *args,
2193 const char *dev_name)
Chuck Leverf0768eb2007-07-01 12:13:01 -04002194{
Chuck Lever4c568012007-12-10 14:59:28 -05002195 struct sockaddr_in *ap;
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002196 struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002197 char *c;
2198
2199 if (data == NULL)
2200 goto out_no_data;
2201
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002202 args->rsize = NFS_MAX_FILE_IO_SIZE;
2203 args->wsize = NFS_MAX_FILE_IO_SIZE;
Chuck Lever0e0cab72008-06-26 17:47:12 -04002204 args->acregmin = NFS_DEF_ACREGMIN;
2205 args->acregmax = NFS_DEF_ACREGMAX;
2206 args->acdirmin = NFS_DEF_ACDIRMIN;
2207 args->acdirmax = NFS_DEF_ACDIRMAX;
Chuck Leverf22d6d72008-03-14 14:10:22 -04002208 args->nfs_server.port = NFS_PORT; /* 2049 unless user set port= */
Chuck Lever6738b252008-06-24 16:33:54 -04002209 args->auth_flavors[0] = RPC_AUTH_UNIX;
2210 args->auth_flavor_len = 0;
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002211
Chuck Leverf0768eb2007-07-01 12:13:01 -04002212 switch (data->version) {
2213 case 1:
Chuck Lever4c568012007-12-10 14:59:28 -05002214 ap = (struct sockaddr_in *)&args->nfs_server.address;
2215 if (data->host_addrlen > sizeof(args->nfs_server.address))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002216 goto out_no_address;
Chuck Lever4c568012007-12-10 14:59:28 -05002217 if (data->host_addrlen == 0)
2218 goto out_no_address;
2219 args->nfs_server.addrlen = data->host_addrlen;
2220 if (copy_from_user(ap, data->host_addr, data->host_addrlen))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002221 return -EFAULT;
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002222 if (!nfs_verify_server_address((struct sockaddr *)
2223 &args->nfs_server.address))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002224 goto out_no_address;
2225
Chuck Lever6738b252008-06-24 16:33:54 -04002226 if (data->auth_flavourlen) {
2227 if (data->auth_flavourlen > 1)
2228 goto out_inval_auth;
Trond Myklebust20c71f52007-09-20 20:23:51 -04002229 if (copy_from_user(&args->auth_flavors[0],
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002230 data->auth_flavours,
Trond Myklebust20c71f52007-09-20 20:23:51 -04002231 sizeof(args->auth_flavors[0])))
Chuck Leverf0768eb2007-07-01 12:13:01 -04002232 return -EFAULT;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002233 }
2234
2235 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
2236 if (IS_ERR(c))
2237 return PTR_ERR(c);
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002238 args->nfs_server.hostname = c;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002239
2240 c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
2241 if (IS_ERR(c))
2242 return PTR_ERR(c);
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002243 args->nfs_server.export_path = c;
2244 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
Chuck Leverf0768eb2007-07-01 12:13:01 -04002245
2246 c = strndup_user(data->client_addr.data, 16);
2247 if (IS_ERR(c))
2248 return PTR_ERR(c);
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002249 args->client_address = c;
2250
2251 /*
2252 * Translate to nfs_parsed_mount_data, which nfs4_fill_super
2253 * can deal with.
2254 */
2255
2256 args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
2257 args->rsize = data->rsize;
2258 args->wsize = data->wsize;
2259 args->timeo = data->timeo;
2260 args->retrans = data->retrans;
2261 args->acregmin = data->acregmin;
2262 args->acregmax = data->acregmax;
2263 args->acdirmin = data->acdirmin;
2264 args->acdirmax = data->acdirmax;
2265 args->nfs_server.protocol = data->proto;
Trond Myklebust259875e2008-07-02 14:43:47 -04002266 nfs_validate_transport_protocol(args);
Chuck Leverf0768eb2007-07-01 12:13:01 -04002267
2268 break;
Chuck Lever80071222007-07-01 12:13:59 -04002269 default: {
Chuck Leverdc045892008-06-23 12:36:37 -04002270 int status;
Chuck Lever80071222007-07-01 12:13:59 -04002271
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002272 if (nfs_parse_mount_options((char *)options, args) == 0)
Chuck Lever80071222007-07-01 12:13:59 -04002273 return -EINVAL;
2274
2275 if (!nfs_verify_server_address((struct sockaddr *)
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002276 &args->nfs_server.address))
Chuck Lever80071222007-07-01 12:13:59 -04002277 return -EINVAL;
Chuck Lever80071222007-07-01 12:13:59 -04002278
Chuck Levered596a82008-06-26 17:47:05 -04002279 nfs_set_port((struct sockaddr *)&args->nfs_server.address,
2280 args->nfs_server.port);
2281
Trond Myklebust259875e2008-07-02 14:43:47 -04002282 nfs_validate_transport_protocol(args);
2283
Chuck Lever6738b252008-06-24 16:33:54 -04002284 if (args->auth_flavor_len > 1)
Chuck Lever80071222007-07-01 12:13:59 -04002285 goto out_inval_auth;
Chuck Lever80071222007-07-01 12:13:59 -04002286
\"Talpey, Thomas\91ea40b2007-09-10 13:44:33 -04002287 if (args->client_address == NULL)
Jeff Layton0a87cf12007-07-18 11:28:43 -04002288 goto out_no_client_address;
2289
Chuck Leverdc045892008-06-23 12:36:37 -04002290 status = nfs_parse_devname(dev_name,
2291 &args->nfs_server.hostname,
2292 NFS4_MAXNAMLEN,
2293 &args->nfs_server.export_path,
2294 NFS4_MAXPATHLEN);
2295 if (status < 0)
2296 return status;
2297
Chuck Lever80071222007-07-01 12:13:59 -04002298 break;
2299 }
Chuck Leverf0768eb2007-07-01 12:13:01 -04002300 }
2301
2302 return 0;
2303
2304out_no_data:
2305 dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
2306 return -EINVAL;
2307
2308out_inval_auth:
2309 dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
2310 data->auth_flavourlen);
2311 return -EINVAL;
2312
2313out_no_address:
2314 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
2315 return -EINVAL;
Jeff Layton0a87cf12007-07-18 11:28:43 -04002316
2317out_no_client_address:
2318 dfprintk(MOUNT, "NFS4: mount program didn't pass callback address\n");
2319 return -EINVAL;
Chuck Leverf0768eb2007-07-01 12:13:01 -04002320}
2321
2322/*
David Howells54ceac42006-08-22 20:06:13 -04002323 * Get the superblock for an NFS4 mountpoint
2324 */
Trond Myklebust816724e2006-06-24 08:41:41 -04002325static int nfs4_get_sb(struct file_system_type *fs_type,
2326 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
David Howellsf7b422b2006-06-09 09:34:33 -04002327{
Trond Myklebust33852a12008-06-19 14:20:11 -04002328 struct nfs_parsed_mount_data *data;
David Howells54ceac42006-08-22 20:06:13 -04002329 struct super_block *s;
2330 struct nfs_server *server;
Trond Myklebust33852a12008-06-19 14:20:11 -04002331 struct nfs_fh *mntfh;
David Howells54ceac42006-08-22 20:06:13 -04002332 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04002333 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002334 struct nfs_sb_mountdata sb_mntdata = {
2335 .mntflags = flags,
2336 };
Trond Myklebust33852a12008-06-19 14:20:11 -04002337 int error = -ENOMEM;
David Howellsf7b422b2006-06-09 09:34:33 -04002338
Trond Myklebust33852a12008-06-19 14:20:11 -04002339 data = kzalloc(sizeof(*data), GFP_KERNEL);
2340 mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
2341 if (data == NULL || mntfh == NULL)
2342 goto out_free_fh;
2343
2344 security_init_mnt_opts(&data->lsm_opts);
Eric Parisf9c3a382008-03-05 14:20:18 -05002345
Chuck Leverf0768eb2007-07-01 12:13:01 -04002346 /* Validate the mount data */
Trond Myklebust33852a12008-06-19 14:20:11 -04002347 error = nfs4_validate_mount_data(raw_data, data, dev_name);
Chuck Leverf0768eb2007-07-01 12:13:01 -04002348 if (error < 0)
2349 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002350
David Howells54ceac42006-08-22 20:06:13 -04002351 /* Get a volume representation */
Trond Myklebust33852a12008-06-19 14:20:11 -04002352 server = nfs4_create_server(data, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002353 if (IS_ERR(server)) {
2354 error = PTR_ERR(server);
Chuck Lever29eb9812007-07-01 12:12:30 -04002355 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002356 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002357 sb_mntdata.server = server;
David Howellsf7b422b2006-06-09 09:34:33 -04002358
Trond Myklebust75180df2007-05-16 16:53:28 -04002359 if (server->flags & NFS4_MOUNT_UNSHARED)
2360 compare_super = NULL;
2361
David Howells54ceac42006-08-22 20:06:13 -04002362 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002363 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
Trond Myklebust816724e2006-06-24 08:41:41 -04002364 if (IS_ERR(s)) {
2365 error = PTR_ERR(s);
David Howellsf7b422b2006-06-09 09:34:33 -04002366 goto out_free;
Trond Myklebust816724e2006-06-24 08:41:41 -04002367 }
2368
Trond Myklebust5dd31772006-08-24 01:03:05 -04002369 if (s->s_fs_info != server) {
2370 nfs_free_server(server);
2371 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002372 } else {
2373 error = nfs_bdi_register(server);
2374 if (error)
2375 goto error_splat_super;
Trond Myklebust5dd31772006-08-24 01:03:05 -04002376 }
2377
David Howells54ceac42006-08-22 20:06:13 -04002378 if (!s->s_root) {
2379 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002380 nfs4_fill_super(s);
Trond Myklebust816724e2006-06-24 08:41:41 -04002381 }
David Howellsf7b422b2006-06-09 09:34:33 -04002382
Trond Myklebust33852a12008-06-19 14:20:11 -04002383 mntroot = nfs4_get_root(s, mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002384 if (IS_ERR(mntroot)) {
2385 error = PTR_ERR(mntroot);
2386 goto error_splat_super;
David Howellsf7b422b2006-06-09 09:34:33 -04002387 }
David Howells54ceac42006-08-22 20:06:13 -04002388
Trond Myklebust33852a12008-06-19 14:20:11 -04002389 error = security_sb_set_mnt_opts(s, &data->lsm_opts);
Eric Paris46c8ac72008-05-02 13:42:42 -07002390 if (error)
2391 goto error_splat_root;
2392
David Howellsf7b422b2006-06-09 09:34:33 -04002393 s->s_flags |= MS_ACTIVE;
David Howells54ceac42006-08-22 20:06:13 -04002394 mnt->mnt_sb = s;
2395 mnt->mnt_root = mntroot;
Chuck Lever29eb9812007-07-01 12:12:30 -04002396 error = 0;
David Howells54ceac42006-08-22 20:06:13 -04002397
Chuck Lever29eb9812007-07-01 12:12:30 -04002398out:
Trond Myklebust33852a12008-06-19 14:20:11 -04002399 kfree(data->client_address);
2400 kfree(data->nfs_server.export_path);
2401 kfree(data->nfs_server.hostname);
2402 security_free_mnt_opts(&data->lsm_opts);
2403out_free_fh:
2404 kfree(mntfh);
2405 kfree(data);
Trond Myklebust816724e2006-06-24 08:41:41 -04002406 return error;
David Howells54ceac42006-08-22 20:06:13 -04002407
Chuck Lever29eb9812007-07-01 12:12:30 -04002408out_free:
2409 nfs_free_server(server);
2410 goto out;
2411
Eric Paris46c8ac72008-05-02 13:42:42 -07002412error_splat_root:
2413 dput(mntroot);
David Howells54ceac42006-08-22 20:06:13 -04002414error_splat_super:
2415 up_write(&s->s_umount);
2416 deactivate_super(s);
Chuck Lever29eb9812007-07-01 12:12:30 -04002417 goto out;
David Howellsf7b422b2006-06-09 09:34:33 -04002418}
2419
2420static void nfs4_kill_super(struct super_block *sb)
2421{
2422 struct nfs_server *server = NFS_SB(sb);
2423
2424 nfs_return_all_delegations(sb);
2425 kill_anon_super(sb);
2426
2427 nfs4_renewd_prepare_shutdown(server);
David Howells54ceac42006-08-22 20:06:13 -04002428 nfs_free_server(server);
David Howellsf7b422b2006-06-09 09:34:33 -04002429}
2430
2431/*
David Howells54ceac42006-08-22 20:06:13 -04002432 * Clone an NFS4 server record on xdev traversal (FSID-change)
David Howellsf7b422b2006-06-09 09:34:33 -04002433 */
David Howells54ceac42006-08-22 20:06:13 -04002434static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
2435 const char *dev_name, void *raw_data,
2436 struct vfsmount *mnt)
David Howellsf7b422b2006-06-09 09:34:33 -04002437{
2438 struct nfs_clone_mount *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002439 struct super_block *s;
2440 struct nfs_server *server;
2441 struct dentry *mntroot;
Trond Myklebust75180df2007-05-16 16:53:28 -04002442 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002443 struct nfs_sb_mountdata sb_mntdata = {
2444 .mntflags = flags,
2445 };
David Howells54ceac42006-08-22 20:06:13 -04002446 int error;
2447
2448 dprintk("--> nfs4_xdev_get_sb()\n");
2449
2450 /* create a new volume representation */
2451 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
2452 if (IS_ERR(server)) {
2453 error = PTR_ERR(server);
2454 goto out_err_noserver;
2455 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002456 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002457
Trond Myklebust75180df2007-05-16 16:53:28 -04002458 if (server->flags & NFS4_MOUNT_UNSHARED)
2459 compare_super = NULL;
2460
David Howells54ceac42006-08-22 20:06:13 -04002461 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002462 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
David Howells54ceac42006-08-22 20:06:13 -04002463 if (IS_ERR(s)) {
2464 error = PTR_ERR(s);
2465 goto out_err_nosb;
2466 }
2467
2468 if (s->s_fs_info != server) {
2469 nfs_free_server(server);
2470 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002471 } else {
2472 error = nfs_bdi_register(server);
2473 if (error)
2474 goto error_splat_super;
David Howells54ceac42006-08-22 20:06:13 -04002475 }
2476
2477 if (!s->s_root) {
2478 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002479 nfs4_clone_super(s, data->sb);
2480 }
2481
2482 mntroot = nfs4_get_root(s, data->fh);
2483 if (IS_ERR(mntroot)) {
2484 error = PTR_ERR(mntroot);
2485 goto error_splat_super;
2486 }
Trond Myklebuste9cc6c22008-01-02 13:28:57 -05002487 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
2488 dput(mntroot);
2489 error = -ESTALE;
2490 goto error_splat_super;
2491 }
David Howells54ceac42006-08-22 20:06:13 -04002492
2493 s->s_flags |= MS_ACTIVE;
2494 mnt->mnt_sb = s;
2495 mnt->mnt_root = mntroot;
2496
Eric Paris46c8ac72008-05-02 13:42:42 -07002497 security_sb_clone_mnt_opts(data->sb, s);
2498
David Howells54ceac42006-08-22 20:06:13 -04002499 dprintk("<-- nfs4_xdev_get_sb() = 0\n");
2500 return 0;
2501
2502out_err_nosb:
2503 nfs_free_server(server);
2504out_err_noserver:
2505 dprintk("<-- nfs4_xdev_get_sb() = %d [error]\n", error);
2506 return error;
2507
2508error_splat_super:
2509 up_write(&s->s_umount);
2510 deactivate_super(s);
2511 dprintk("<-- nfs4_xdev_get_sb() = %d [splat]\n", error);
2512 return error;
David Howellsf7b422b2006-06-09 09:34:33 -04002513}
2514
David Howells54ceac42006-08-22 20:06:13 -04002515/*
2516 * Create an NFS4 server record on referral traversal
2517 */
2518static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
2519 const char *dev_name, void *raw_data,
2520 struct vfsmount *mnt)
David Howellsf7b422b2006-06-09 09:34:33 -04002521{
2522 struct nfs_clone_mount *data = raw_data;
David Howells54ceac42006-08-22 20:06:13 -04002523 struct super_block *s;
2524 struct nfs_server *server;
2525 struct dentry *mntroot;
2526 struct nfs_fh mntfh;
Trond Myklebust75180df2007-05-16 16:53:28 -04002527 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002528 struct nfs_sb_mountdata sb_mntdata = {
2529 .mntflags = flags,
2530 };
David Howells54ceac42006-08-22 20:06:13 -04002531 int error;
2532
2533 dprintk("--> nfs4_referral_get_sb()\n");
2534
2535 /* create a new volume representation */
2536 server = nfs4_create_referral_server(data, &mntfh);
2537 if (IS_ERR(server)) {
2538 error = PTR_ERR(server);
2539 goto out_err_noserver;
2540 }
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002541 sb_mntdata.server = server;
David Howells54ceac42006-08-22 20:06:13 -04002542
Trond Myklebust75180df2007-05-16 16:53:28 -04002543 if (server->flags & NFS4_MOUNT_UNSHARED)
2544 compare_super = NULL;
2545
David Howells54ceac42006-08-22 20:06:13 -04002546 /* Get a superblock - note that we may end up sharing one that already exists */
Trond Myklebuste89a5a42007-08-31 10:45:17 -04002547 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
David Howells54ceac42006-08-22 20:06:13 -04002548 if (IS_ERR(s)) {
2549 error = PTR_ERR(s);
2550 goto out_err_nosb;
2551 }
2552
2553 if (s->s_fs_info != server) {
2554 nfs_free_server(server);
2555 server = NULL;
Miklos Szeredifa799752008-04-30 00:54:33 -07002556 } else {
2557 error = nfs_bdi_register(server);
2558 if (error)
2559 goto error_splat_super;
David Howells54ceac42006-08-22 20:06:13 -04002560 }
2561
2562 if (!s->s_root) {
2563 /* initial superblock/root creation */
David Howells54ceac42006-08-22 20:06:13 -04002564 nfs4_fill_super(s);
2565 }
2566
Trond Myklebustf2d0d852007-02-02 14:46:09 -08002567 mntroot = nfs4_get_root(s, &mntfh);
David Howells54ceac42006-08-22 20:06:13 -04002568 if (IS_ERR(mntroot)) {
2569 error = PTR_ERR(mntroot);
2570 goto error_splat_super;
2571 }
Trond Myklebuste9cc6c22008-01-02 13:28:57 -05002572 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
2573 dput(mntroot);
2574 error = -ESTALE;
2575 goto error_splat_super;
2576 }
David Howells54ceac42006-08-22 20:06:13 -04002577
2578 s->s_flags |= MS_ACTIVE;
2579 mnt->mnt_sb = s;
2580 mnt->mnt_root = mntroot;
2581
Eric Paris46c8ac72008-05-02 13:42:42 -07002582 security_sb_clone_mnt_opts(data->sb, s);
2583
David Howells54ceac42006-08-22 20:06:13 -04002584 dprintk("<-- nfs4_referral_get_sb() = 0\n");
2585 return 0;
2586
2587out_err_nosb:
2588 nfs_free_server(server);
2589out_err_noserver:
2590 dprintk("<-- nfs4_referral_get_sb() = %d [error]\n", error);
2591 return error;
2592
2593error_splat_super:
2594 up_write(&s->s_umount);
2595 deactivate_super(s);
2596 dprintk("<-- nfs4_referral_get_sb() = %d [splat]\n", error);
2597 return error;
David Howellsf7b422b2006-06-09 09:34:33 -04002598}
2599
David Howells54ceac42006-08-22 20:06:13 -04002600#endif /* CONFIG_NFS_V4 */