?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.28-rc5
[cris-mirror.git] / fs / nfs / super.c
blobf48db679a1c681aecdfef6ed2eb662fec9d7d2bc
1 /*
2 * linux/fs/nfs/super.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs superblock handling functions
7 *
8 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, 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 *
16 * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
17 * particular server are held in the same superblock
18 * - NFS superblocks can have several effective roots to the dentry tree
19 * - directory type roots are spliced into the tree when a path from one root reaches the root
20 * of another (see nfs_lookup())
21 */
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25
26 #include <linux/time.h>
27 #include <linux/kernel.h>
28 #include <linux/mm.h>
29 #include <linux/string.h>
30 #include <linux/stat.h>
31 #include <linux/errno.h>
32 #include <linux/unistd.h>
33 #include <linux/sunrpc/clnt.h>
34 #include <linux/sunrpc/stats.h>
35 #include <linux/sunrpc/metrics.h>
36 #include <linux/sunrpc/xprtsock.h>
37 #include <linux/sunrpc/xprtrdma.h>
38 #include <linux/nfs_fs.h>
39 #include <linux/nfs_mount.h>
40 #include <linux/nfs4_mount.h>
41 #include <linux/lockd/bind.h>
42 #include <linux/smp_lock.h>
43 #include <linux/seq_file.h>
44 #include <linux/mount.h>
45 #include <linux/nfs_idmap.h>
46 #include <linux/vfs.h>
47 #include <linux/inet.h>
48 #include <linux/in6.h>
49 #include <net/ipv6.h>
50 #include <linux/netdevice.h>
51 #include <linux/nfs_xdr.h>
52 #include <linux/magic.h>
53 #include <linux/parser.h>
54
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
66 enum {
67 /* Mount options that take no arguments */
68 Opt_soft, Opt_hard,
69 Opt_posix, Opt_noposix,
70 Opt_cto, Opt_nocto,
71 Opt_ac, Opt_noac,
72 Opt_lock, Opt_nolock,
73 Opt_v2, Opt_v3,
74 Opt_udp, Opt_tcp, Opt_rdma,
75 Opt_acl, Opt_noacl,
76 Opt_rdirplus, Opt_nordirplus,
77 Opt_sharecache, Opt_nosharecache,
78
79 /* Mount options that take integer arguments */
80 Opt_port,
81 Opt_rsize, Opt_wsize, Opt_bsize,
82 Opt_timeo, Opt_retrans,
83 Opt_acregmin, Opt_acregmax,
84 Opt_acdirmin, Opt_acdirmax,
85 Opt_actimeo,
86 Opt_namelen,
87 Opt_mountport,
88 Opt_mountvers,
89 Opt_nfsvers,
90
91 /* Mount options that take string arguments */
92 Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
93 Opt_addr, Opt_mountaddr, Opt_clientaddr,
94 Opt_lookupcache,
95
96 /* Special mount options */
97 Opt_userspace, Opt_deprecated, Opt_sloppy,
98
99 Opt_err
100 };
101
102 static const match_table_t nfs_mount_option_tokens = {
103 { Opt_userspace, "bg" },
104 { Opt_userspace, "fg" },
105 { Opt_userspace, "retry=%s" },
106
107 { Opt_sloppy, "sloppy" },
108
109 { Opt_soft, "soft" },
110 { Opt_hard, "hard" },
111 { Opt_deprecated, "intr" },
112 { Opt_deprecated, "nointr" },
113 { 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" },
125 { Opt_rdma, "rdma" },
126 { Opt_acl, "acl" },
127 { Opt_noacl, "noacl" },
128 { Opt_rdirplus, "rdirplus" },
129 { Opt_nordirplus, "nordirplus" },
130 { Opt_sharecache, "sharecache" },
131 { Opt_nosharecache, "nosharecache" },
132
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" },
144 { Opt_namelen, "namlen=%u" },
145 { Opt_mountport, "mountport=%u" },
146 { Opt_mountvers, "mountvers=%u" },
147 { 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" },
155 { Opt_mounthost, "mounthost=%s" },
156 { Opt_mountaddr, "mountaddr=%s" },
157
158 { Opt_lookupcache, "lookupcache=%s" },
159
160 { Opt_err, NULL }
161 };
162
163 enum {
164 Opt_xprt_udp, Opt_xprt_tcp, Opt_xprt_rdma,
165
166 Opt_xprt_err
167 };
168
169 static const match_table_t nfs_xprt_protocol_tokens = {
170 { Opt_xprt_udp, "udp" },
171 { Opt_xprt_tcp, "tcp" },
172 { Opt_xprt_rdma, "rdma" },
173
174 { Opt_xprt_err, NULL }
175 };
176
177 enum {
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
186 static const match_table_t nfs_secflavor_tokens = {
187 { 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
199 { Opt_sec_spkm, "spkm3" },
200 { Opt_sec_spkmi, "spkm3i" },
201 { Opt_sec_spkmp, "spkm3p" },
202
203 { Opt_sec_err, NULL }
204 };
205
206 enum {
207 Opt_lookupcache_all, Opt_lookupcache_positive,
208 Opt_lookupcache_none,
209
210 Opt_lookupcache_err
211 };
212
213 static 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
222
223 static void nfs_umount_begin(struct super_block *);
224 static int nfs_statfs(struct dentry *, struct kstatfs *);
225 static int nfs_show_options(struct seq_file *, struct vfsmount *);
226 static int nfs_show_stats(struct seq_file *, struct vfsmount *);
227 static int nfs_get_sb(struct file_system_type *, int, const char *, void *, struct vfsmount *);
228 static int nfs_xdev_get_sb(struct file_system_type *fs_type,
229 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
230 static void nfs_kill_super(struct super_block *);
231 static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
232
233 static 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,
238 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
239 };
240
241 struct file_system_type nfs_xdev_fs_type = {
242 .owner = THIS_MODULE,
243 .name = "nfs",
244 .get_sb = nfs_xdev_get_sb,
245 .kill_sb = nfs_kill_super,
246 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
247 };
248
249 static const struct super_operations nfs_sops = {
250 .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,
258 .remount_fs = nfs_remount,
259 };
260
261 #ifdef CONFIG_NFS_V4
262 static int nfs4_get_sb(struct file_system_type *fs_type,
263 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
264 static int nfs4_xdev_get_sb(struct file_system_type *fs_type,
265 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
266 static int nfs4_referral_get_sb(struct file_system_type *fs_type,
267 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
268 static void nfs4_kill_super(struct super_block *sb);
269
270 static 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,
275 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
276 };
277
278 struct file_system_type nfs4_xdev_fs_type = {
279 .owner = THIS_MODULE,
280 .name = "nfs4",
281 .get_sb = nfs4_xdev_get_sb,
282 .kill_sb = nfs4_kill_super,
283 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
284 };
285
286 struct file_system_type nfs4_referral_fs_type = {
287 .owner = THIS_MODULE,
288 .name = "nfs4",
289 .get_sb = nfs4_referral_get_sb,
290 .kill_sb = nfs4_kill_super,
291 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
292 };
293
294 static const struct super_operations nfs4_sops = {
295 .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,
303 .remount_fs = nfs_remount,
304 };
305 #endif
306
307 static struct shrinker acl_shrinker = {
308 .shrink = nfs_access_cache_shrinker,
309 .seeks = DEFAULT_SEEKS,
310 };
311
312 /*
313 * Register the NFS filesystems
314 */
315 int __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
323 ret = nfs_register_sysctl();
324 if (ret < 0)
325 goto error_1;
326 #ifdef CONFIG_NFS_V4
327 ret = register_filesystem(&nfs4_fs_type);
328 if (ret < 0)
329 goto error_2;
330 #endif
331 register_shrinker(&acl_shrinker);
332 return 0;
333
334 #ifdef CONFIG_NFS_V4
335 error_2:
336 nfs_unregister_sysctl();
337 #endif
338 error_1:
339 unregister_filesystem(&nfs_fs_type);
340 error_0:
341 return ret;
342 }
343
344 /*
345 * Unregister the NFS filesystems
346 */
347 void __exit unregister_nfs_fs(void)
348 {
349 unregister_shrinker(&acl_shrinker);
350 #ifdef CONFIG_NFS_V4
351 unregister_filesystem(&nfs4_fs_type);
352 #endif
353 nfs_unregister_sysctl();
354 unregister_filesystem(&nfs_fs_type);
355 }
356
357 void nfs_sb_active(struct super_block *sb)
358 {
359 struct nfs_server *server = NFS_SB(sb);
360
361 if (atomic_inc_return(&server->active) == 1)
362 atomic_inc(&sb->s_active);
363 }
364
365 void 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);
371 }
372
373 /*
374 * Deliver file system statistics to userspace
375 */
376 static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
377 {
378 struct nfs_server *server = NFS_SB(dentry->d_sb);
379 unsigned char blockbits;
380 unsigned long blockres;
381 struct nfs_fh *fh = NFS_FH(dentry->d_inode);
382 struct nfs_fattr fattr;
383 struct nfs_fsstat res = {
384 .fattr = &fattr,
385 };
386 int error;
387
388 error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
389 if (error < 0)
390 goto out_err;
391 buf->f_type = NFS_SUPER_MAGIC;
392
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 */
398 buf->f_frsize = dentry->d_sb->s_blocksize;
399
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 */
407 buf->f_bsize = dentry->d_sb->s_blocksize;
408 blockbits = dentry->d_sb->s_blocksize_bits;
409 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;
418
419 return 0;
420
421 out_err:
422 dprintk("%s: statfs error = %d\n", __func__, -error);
423 return error;
424 }
425
426 /*
427 * Map the security flavour number to a name
428 */
429 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
430 {
431 static const struct {
432 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" },
446 { UINT_MAX, "unknown" }
447 };
448 int i;
449
450 for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
451 if (sec_flavours[i].flavour == flavour)
452 break;
453 }
454 return sec_flavours[i].str;
455 }
456
457 static 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
498 /*
499 * Describe the mount options in force on this server representation
500 */
501 static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
502 int showdefaults)
503 {
504 static const struct proc_nfs_info {
505 int flag;
506 const char *str;
507 const char *nostr;
508 } nfs_info[] = {
509 { NFS_MOUNT_SOFT, ",soft", ",hard" },
510 { NFS_MOUNT_INTR, ",intr", ",nointr" },
511 { NFS_MOUNT_POSIX, ",posix", "" },
512 { NFS_MOUNT_NOCTO, ",nocto", "" },
513 { NFS_MOUNT_NOAC, ",noac", "" },
514 { NFS_MOUNT_NONLM, ",nolock", "" },
515 { NFS_MOUNT_NOACL, ",noacl", "" },
516 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
517 { NFS_MOUNT_UNSHARED, ",nosharecache", ""},
518 { 0, NULL, NULL }
519 };
520 const struct proc_nfs_info *nfs_infop;
521 struct nfs_client *clp = nfss->nfs_client;
522 u32 version = clp->rpc_ops->version;
523
524 seq_printf(m, ",vers=%u", version);
525 seq_printf(m, ",rsize=%u", nfss->rsize);
526 seq_printf(m, ",wsize=%u", nfss->wsize);
527 if (nfss->bsize != 0)
528 seq_printf(m, ",bsize=%u", nfss->bsize);
529 seq_printf(m, ",namlen=%u", nfss->namelen);
530 if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
531 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
532 if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
533 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
534 if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
535 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
536 if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
537 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
538 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 }
544 seq_printf(m, ",proto=%s",
545 rpc_peeraddr2str(nfss->client, RPC_DISPLAY_PROTO));
546 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
553 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);
555 seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
556
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
564 }
565
566 /*
567 * Describe the mount options on this VFS mountpoint
568 */
569 static 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
575 seq_printf(m, ",addr=%s",
576 rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
577 RPC_DISPLAY_ADDR));
578
579 return 0;
580 }
581
582 /*
583 * Present statistical information for this VFS mountpoint
584 */
585 static 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);
608 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);
612
613 #ifdef CONFIG_NFS_V4
614 if (nfss->nfs_client->rpc_ops->version == 4) {
615 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 */
625 seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
626 if (auth->au_flavor)
627 seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
628
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
661 * in response to xdev traversals and referrals
662 */
663 static void nfs_umount_begin(struct super_block *sb)
664 {
665 struct nfs_server *server = NFS_SB(sb);
666 struct rpc_clnt *rpc;
667
668 /* -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);
675 }
676
677 /*
678 * 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.
682 */
683 static int nfs_verify_server_address(struct sockaddr *addr)
684 {
685 switch (addr->sa_family) {
686 case AF_INET: {
687 struct sockaddr_in *sa = (struct sockaddr_in *)addr;
688 return sa->sin_addr.s_addr != htonl(INADDR_ANY);
689 }
690 case AF_INET6: {
691 struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
692 return !ipv6_addr_any(sa);
693 }
694 }
695
696 return 0;
697 }
698
699 static void nfs_parse_ipv4_address(char *string, size_t str_len,
700 struct sockaddr *sap, size_t *addr_len)
701 {
702 struct sockaddr_in *sin = (struct sockaddr_in *)sap;
703 u8 *addr = (u8 *)&sin->sin_addr.s_addr;
704
705 if (str_len <= INET_ADDRSTRLEN) {
706 dfprintk(MOUNT, "NFS: parsing IPv4 address %*s\n",
707 (int)str_len, string);
708
709 sin->sin_family = AF_INET;
710 *addr_len = sizeof(*sin);
711 if (in4_pton(string, str_len, addr, '\0', NULL))
712 return;
713 }
714
715 sap->sa_family = AF_UNSPEC;
716 *addr_len = 0;
717 }
718
719 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
720 static int nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
721 const char *delim,
722 struct sockaddr_in6 *sin6)
723 {
724 char *p;
725 size_t len;
726
727 if ((string + str_len) == delim)
728 return 1;
729
730 if (*delim != IPV6_SCOPE_DELIMITER)
731 return 0;
732
733 if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
734 return 0;
735
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 {
747 if (strict_strtoul(p, 10, &scope_id) == 0) {
748 kfree(p);
749 return 0;
750 }
751 }
752
753 kfree(p);
754
755 sin6->sin6_scope_id = scope_id;
756 dfprintk(MOUNT, "NFS: IPv6 scope ID = %lu\n", scope_id);
757 return 1;
758 }
759
760 return 0;
761 }
762
763 static 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;
768 const char *delim;
769
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);
776 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;
781 }
782 }
783
784 sap->sa_family = AF_UNSPEC;
785 *addr_len = 0;
786 }
787 #else
788 static 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 */
803 void nfs_parse_ip_address(char *string, size_t str_len,
804 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);
817 }
818
819 /*
820 * Sanity check the NFS transport protocol.
821 *
822 */
823 static 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 */
839 static 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 /*
857 * Parse the value of the 'sec=' option.
858 *
859 * The flavor_len setting is for v4 mounts.
860 */
861 static 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:
870 mnt->auth_flavor_len = 0;
871 mnt->auth_flavors[0] = RPC_AUTH_NULL;
872 break;
873 case Opt_sec_sys:
874 mnt->auth_flavor_len = 0;
875 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
876 break;
877 case Opt_sec_krb5:
878 mnt->auth_flavor_len = 1;
879 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
880 break;
881 case Opt_sec_krb5i:
882 mnt->auth_flavor_len = 1;
883 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
884 break;
885 case Opt_sec_krb5p:
886 mnt->auth_flavor_len = 1;
887 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
888 break;
889 case Opt_sec_lkey:
890 mnt->auth_flavor_len = 1;
891 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
892 break;
893 case Opt_sec_lkeyi:
894 mnt->auth_flavor_len = 1;
895 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
896 break;
897 case Opt_sec_lkeyp:
898 mnt->auth_flavor_len = 1;
899 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
900 break;
901 case Opt_sec_spkm:
902 mnt->auth_flavor_len = 1;
903 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
904 break;
905 case Opt_sec_spkmi:
906 mnt->auth_flavor_len = 1;
907 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
908 break;
909 case Opt_sec_spkmp:
910 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
920 static void nfs_parse_invalid_value(const char *option)
921 {
922 dfprintk(MOUNT, "NFS: bad value specified for %s option\n", option);
923 }
924
925 /*
926 * Error-check and convert a string of mount options from user space into
927 * 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).
930 */
931 static int nfs_parse_mount_options(char *raw,
932 struct nfs_parsed_mount_data *mnt)
933 {
934 char *p, *string, *secdata;
935 int rc, sloppy = 0, errors = 0;
936
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
943 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
957 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) {
968
969 /*
970 * boolean options: foo/nofoo
971 */
972 case Opt_soft:
973 mnt->flags |= NFS_MOUNT_SOFT;
974 break;
975 case Opt_hard:
976 mnt->flags &= ~NFS_MOUNT_SOFT;
977 break;
978 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;
1010 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1011 break;
1012 case Opt_tcp:
1013 mnt->flags |= NFS_MOUNT_TCP;
1014 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1015 break;
1016 case Opt_rdma:
1017 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
1018 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1019 break;
1020 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;
1032 case Opt_sharecache:
1033 mnt->flags &= ~NFS_MOUNT_UNSHARED;
1034 break;
1035 case Opt_nosharecache:
1036 mnt->flags |= NFS_MOUNT_UNSHARED;
1037 break;
1038
1039 /*
1040 * options that take numeric values
1041 */
1042 case Opt_port:
1043 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;
1049 break;
1050 case Opt_rsize:
1051 if (match_int(args, &option) || option < 0) {
1052 errors++;
1053 nfs_parse_invalid_value("rsize");
1054 } else
1055 mnt->rsize = option;
1056 break;
1057 case Opt_wsize:
1058 if (match_int(args, &option) || option < 0) {
1059 errors++;
1060 nfs_parse_invalid_value("wsize");
1061 } else
1062 mnt->wsize = option;
1063 break;
1064 case Opt_bsize:
1065 if (match_int(args, &option) || option < 0) {
1066 errors++;
1067 nfs_parse_invalid_value("bsize");
1068 } else
1069 mnt->bsize = option;
1070 break;
1071 case Opt_timeo:
1072 if (match_int(args, &option) || option <= 0) {
1073 errors++;
1074 nfs_parse_invalid_value("timeo");
1075 } else
1076 mnt->timeo = option;
1077 break;
1078 case Opt_retrans:
1079 if (match_int(args, &option) || option <= 0) {
1080 errors++;
1081 nfs_parse_invalid_value("retrans");
1082 } else
1083 mnt->retrans = option;
1084 break;
1085 case Opt_acregmin:
1086 if (match_int(args, &option) || option < 0) {
1087 errors++;
1088 nfs_parse_invalid_value("acregmin");
1089 } else
1090 mnt->acregmin = option;
1091 break;
1092 case Opt_acregmax:
1093 if (match_int(args, &option) || option < 0) {
1094 errors++;
1095 nfs_parse_invalid_value("acregmax");
1096 } else
1097 mnt->acregmax = option;
1098 break;
1099 case Opt_acdirmin:
1100 if (match_int(args, &option) || option < 0) {
1101 errors++;
1102 nfs_parse_invalid_value("acdirmin");
1103 } else
1104 mnt->acdirmin = option;
1105 break;
1106 case Opt_acdirmax:
1107 if (match_int(args, &option) || option < 0) {
1108 errors++;
1109 nfs_parse_invalid_value("acdirmax");
1110 } else
1111 mnt->acdirmax = option;
1112 break;
1113 case Opt_actimeo:
1114 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;
1120 break;
1121 case Opt_namelen:
1122 if (match_int(args, &option) || option < 0) {
1123 errors++;
1124 nfs_parse_invalid_value("namlen");
1125 } else
1126 mnt->namlen = option;
1127 break;
1128 case Opt_mountport:
1129 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;
1135 break;
1136 case Opt_mountvers:
1137 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;
1144 break;
1145 case Opt_nfsvers:
1146 if (match_int(args, &option)) {
1147 errors++;
1148 nfs_parse_invalid_value("nfsvers");
1149 break;
1150 }
1151 switch (option) {
1152 case NFS2_VERSION:
1153 mnt->flags &= ~NFS_MOUNT_VER3;
1154 break;
1155 case NFS3_VERSION:
1156 mnt->flags |= NFS_MOUNT_VER3;
1157 break;
1158 default:
1159 errors++;
1160 nfs_parse_invalid_value("nfsvers");
1161 }
1162 break;
1163
1164 /*
1165 * options that take text values
1166 */
1167 case Opt_sec:
1168 string = match_strdup(args);
1169 if (string == NULL)
1170 goto out_nomem;
1171 rc = nfs_parse_security_flavors(string, mnt);
1172 kfree(string);
1173 if (!rc) {
1174 errors++;
1175 dfprintk(MOUNT, "NFS: unrecognized "
1176 "security flavor\n");
1177 }
1178 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) {
1188 case Opt_xprt_udp:
1189 mnt->flags &= ~NFS_MOUNT_TCP;
1190 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1191 break;
1192 case Opt_xprt_tcp:
1193 mnt->flags |= NFS_MOUNT_TCP;
1194 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1195 break;
1196 case Opt_xprt_rdma:
1197 /* vector side protocols to TCP */
1198 mnt->flags |= NFS_MOUNT_TCP;
1199 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1200 break;
1201 default:
1202 errors++;
1203 dfprintk(MOUNT, "NFS: unrecognized "
1204 "transport protocol\n");
1205 }
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) {
1216 case Opt_xprt_udp:
1217 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1218 break;
1219 case Opt_xprt_tcp:
1220 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1221 break;
1222 case Opt_xprt_rdma: /* not used for side protocols */
1223 default:
1224 errors++;
1225 dfprintk(MOUNT, "NFS: unrecognized "
1226 "transport protocol\n");
1227 }
1228 break;
1229 case Opt_addr:
1230 string = match_strdup(args);
1231 if (string == NULL)
1232 goto out_nomem;
1233 nfs_parse_ip_address(string, strlen(string),
1234 (struct sockaddr *)
1235 &mnt->nfs_server.address,
1236 &mnt->nfs_server.addrlen);
1237 kfree(string);
1238 break;
1239 case Opt_clientaddr:
1240 string = match_strdup(args);
1241 if (string == NULL)
1242 goto out_nomem;
1243 kfree(mnt->client_address);
1244 mnt->client_address = string;
1245 break;
1246 case Opt_mounthost:
1247 string = match_strdup(args);
1248 if (string == NULL)
1249 goto out_nomem;
1250 kfree(mnt->mount_server.hostname);
1251 mnt->mount_server.hostname = string;
1252 break;
1253 case Opt_mountaddr:
1254 string = match_strdup(args);
1255 if (string == NULL)
1256 goto out_nomem;
1257 nfs_parse_ip_address(string, strlen(string),
1258 (struct sockaddr *)
1259 &mnt->mount_server.address,
1260 &mnt->mount_server.addrlen);
1261 kfree(string);
1262 break;
1263 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;
1287
1288 /*
1289 * Special options
1290 */
1291 case Opt_sloppy:
1292 sloppy = 1;
1293 dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
1294 break;
1295 case Opt_userspace:
1296 case Opt_deprecated:
1297 dfprintk(MOUNT, "NFS: ignoring mount option "
1298 "'%s'\n", p);
1299 break;
1300
1301 default:
1302 errors++;
1303 dfprintk(MOUNT, "NFS: unrecognized mount option "
1304 "'%s'\n", p);
1305 }
1306 }
1307
1308 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 }
1314 return 1;
1315
1316 out_nomem:
1317 printk(KERN_INFO "NFS: not enough memory to parse option\n");
1318 return 0;
1319 out_security_failure:
1320 free_secdata(secdata);
1321 printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1322 return 0;
1323 }
1324
1325 /*
1326 * Use the remote server's MOUNT service to request the NFS file handle
1327 * corresponding to the provided path.
1328 */
1329 static int nfs_try_mount(struct nfs_parsed_mount_data *args,
1330 struct nfs_fh *root_fh)
1331 {
1332 struct sockaddr *sap = (struct sockaddr *)&args->mount_server.address;
1333 char *hostname;
1334 int status;
1335
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
1343 if (args->mount_server.hostname)
1344 hostname = args->mount_server.hostname;
1345 else
1346 hostname = args->nfs_server.hostname;
1347
1348 /*
1349 * Construct the mount server's address.
1350 */
1351 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
1357 /*
1358 * autobind will be used if mount_server.port == 0
1359 */
1360 nfs_set_port(sap, args->mount_server.port);
1361
1362 /*
1363 * Now ask the mount server to map our export path
1364 * to a file handle.
1365 */
1366 status = nfs_mount(sap,
1367 args->mount_server.addrlen,
1368 hostname,
1369 args->nfs_server.export_path,
1370 args->mount_server.version,
1371 args->mount_server.protocol,
1372 root_fh);
1373 if (status == 0)
1374 return 0;
1375
1376 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
1377 hostname, status);
1378 return status;
1379 }
1380
1381 static int nfs_parse_simple_hostname(const char *dev_name,
1382 char **hostname, size_t maxnamlen,
1383 char **export_path, size_t maxpathlen)
1384 {
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
1420 out_bad_devname:
1421 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1422 return -EINVAL;
1423
1424 out_nomem:
1425 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1426 return -ENOMEM;
1427
1428 out_hostname:
1429 dfprintk(MOUNT, "NFS: server hostname too long\n");
1430 return -ENAMETOOLONG;
1431
1432 out_path:
1433 dfprintk(MOUNT, "NFS: export pathname too long\n");
1434 return -ENAMETOOLONG;
1435 }
1436
1437 /*
1438 * 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 */
1442 static 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
1476 out_bad_devname:
1477 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1478 return -EINVAL;
1479
1480 out_nomem:
1481 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1482 return -ENOMEM;
1483
1484 out_hostname:
1485 dfprintk(MOUNT, "NFS: server hostname too long\n");
1486 return -ENAMETOOLONG;
1487
1488 out_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 */
1502 static 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 /*
1517 * Validate the NFS2/NFS3 mount data
1518 * - fills in the mount root filehandle
1519 *
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
1531 */
1532 static int nfs_validate_mount_data(void *options,
1533 struct nfs_parsed_mount_data *args,
1534 struct nfs_fh *mntfh,
1535 const char *dev_name)
1536 {
1537 struct nfs_mount_data *data = (struct nfs_mount_data *)options;
1538
1539 if (data == NULL)
1540 goto out_no_data;
1541
1542 args->flags = (NFS_MOUNT_VER3 | NFS_MOUNT_TCP);
1543 args->rsize = NFS_MAX_FILE_IO_SIZE;
1544 args->wsize = NFS_MAX_FILE_IO_SIZE;
1545 args->acregmin = NFS_DEF_ACREGMIN;
1546 args->acregmax = NFS_DEF_ACREGMAX;
1547 args->acdirmin = NFS_DEF_ACDIRMIN;
1548 args->acdirmax = NFS_DEF_ACDIRMAX;
1549 args->mount_server.port = 0; /* autobind unless user sets port */
1550 args->nfs_server.port = 0; /* autobind unless user sets port */
1551 args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1552 args->auth_flavors[0] = RPC_AUTH_UNIX;
1553
1554 switch (data->version) {
1555 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:
1570 if (data->flags & NFS_MOUNT_VER3) {
1571 if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
1572 goto out_invalid_fh;
1573 mntfh->size = data->root.size;
1574 } else
1575 mntfh->size = NFS2_FHSIZE;
1576
1577
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);
1582
1583 /*
1584 * Translate to nfs_parsed_mount_data, which nfs_fill_super
1585 * can deal with.
1586 */
1587 args->flags = data->flags & NFS_MOUNT_FLAGMASK;
1588 args->rsize = data->rsize;
1589 args->wsize = data->wsize;
1590 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;
1596
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
1604 if (!(data->flags & NFS_MOUNT_TCP))
1605 args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1606 /* 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;
1610
1611 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1612 args->auth_flavors[0] = data->pseudoflavor;
1613 if (!args->nfs_server.hostname)
1614 goto out_nomem;
1615
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
1642 break;
1643 default: {
1644 int status;
1645
1646 if (nfs_parse_mount_options((char *)options, args) == 0)
1647 return -EINVAL;
1648
1649 if (!nfs_verify_server_address((struct sockaddr *)
1650 &args->nfs_server.address))
1651 goto out_no_address;
1652
1653 nfs_set_port((struct sockaddr *)&args->nfs_server.address,
1654 args->nfs_server.port);
1655
1656 nfs_set_mount_transport_protocol(args);
1657
1658 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);
1665
1666 kfree(args->nfs_server.export_path);
1667 args->nfs_server.export_path = NULL;
1668
1669 if (status)
1670 return status;
1671
1672 break;
1673 }
1674 }
1675
1676 #ifndef CONFIG_NFS_V3
1677 if (args->flags & NFS_MOUNT_VER3)
1678 goto out_v3_not_compiled;
1679 #endif /* !CONFIG_NFS_V3 */
1680
1681 return 0;
1682
1683 out_no_data:
1684 dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
1685 return -EINVAL;
1686
1687 out_no_v3:
1688 dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
1689 data->version);
1690 return -EINVAL;
1691
1692 out_no_sec:
1693 dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
1694 return -EINVAL;
1695
1696 #ifndef CONFIG_NFS_V3
1697 out_v3_not_compiled:
1698 dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
1699 return -EPROTONOSUPPORT;
1700 #endif /* !CONFIG_NFS_V3 */
1701
1702 out_nomem:
1703 dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
1704 return -ENOMEM;
1705
1706 out_no_address:
1707 dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
1708 return -EINVAL;
1709
1710 out_invalid_fh:
1711 dfprintk(MOUNT, "NFS: invalid root filehandle\n");
1712 return -EINVAL;
1713 }
1714
1715 static int
1716 nfs_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
1737 static int
1738 nfs_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;
1745 u32 nfsvers = nfss->nfs_client->rpc_ops->version;
1746
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 */
1753 if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
1754 (nfsvers <= 3 && (!options || (options->version >= 1 &&
1755 options->version <= 6))))
1756 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);
1784 out:
1785 kfree(data);
1786 return error;
1787 }
1788
1789 /*
1790 * Initialise the common bits of the superblock
1791 */
1792 static 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 */
1815 static void nfs_fill_super(struct super_block *sb,
1816 struct nfs_parsed_mount_data *data)
1817 {
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 */
1840 static 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
1861 #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
1862
1863 static 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;
1889 return 1;
1890 Ebusy:
1891 return 0;
1892 }
1893
1894 struct nfs_sb_mountdata {
1895 struct nfs_server *server;
1896 int mntflags;
1897 };
1898
1899 static 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
1913 static 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
1950 static 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
1956 if (!nfs_compare_super_address(old, server))
1957 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);
1964 }
1965
1966 static int nfs_bdi_register(struct nfs_server *server)
1967 {
1968 return bdi_register_dev(&server->backing_dev_info, server->s_dev);
1969 }
1970
1971 static 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;
1976 struct nfs_parsed_mount_data *data;
1977 struct nfs_fh *mntfh;
1978 struct dentry *mntroot;
1979 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
1980 struct nfs_sb_mountdata sb_mntdata = {
1981 .mntflags = flags,
1982 };
1983 int error = -ENOMEM;
1984
1985 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);
1991
1992 /* Validate the mount data */
1993 error = nfs_validate_mount_data(raw_data, data, mntfh, dev_name);
1994 if (error < 0)
1995 goto out;
1996
1997 /* Get a volume representation */
1998 server = nfs_create_server(data, mntfh);
1999 if (IS_ERR(server)) {
2000 error = PTR_ERR(server);
2001 goto out;
2002 }
2003 sb_mntdata.server = server;
2004
2005 if (server->flags & NFS_MOUNT_UNSHARED)
2006 compare_super = NULL;
2007
2008 /* Get a superblock - note that we may end up sharing one that already exists */
2009 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
2010 if (IS_ERR(s)) {
2011 error = PTR_ERR(s);
2012 goto out_err_nosb;
2013 }
2014
2015 if (s->s_fs_info != server) {
2016 nfs_free_server(server);
2017 server = NULL;
2018 } else {
2019 error = nfs_bdi_register(server);
2020 if (error)
2021 goto error_splat_super;
2022 }
2023
2024 if (!s->s_root) {
2025 /* initial superblock/root creation */
2026 nfs_fill_super(s, data);
2027 }
2028
2029 mntroot = nfs_get_root(s, mntfh);
2030 if (IS_ERR(mntroot)) {
2031 error = PTR_ERR(mntroot);
2032 goto error_splat_super;
2033 }
2034
2035 error = security_sb_set_mnt_opts(s, &data->lsm_opts);
2036 if (error)
2037 goto error_splat_root;
2038
2039 s->s_flags |= MS_ACTIVE;
2040 mnt->mnt_sb = s;
2041 mnt->mnt_root = mntroot;
2042 error = 0;
2043
2044 out:
2045 kfree(data->nfs_server.hostname);
2046 kfree(data->mount_server.hostname);
2047 security_free_mnt_opts(&data->lsm_opts);
2048 out_free_fh:
2049 kfree(mntfh);
2050 kfree(data);
2051 return error;
2052
2053 out_err_nosb:
2054 nfs_free_server(server);
2055 goto out;
2056
2057 error_splat_root:
2058 dput(mntroot);
2059 error_splat_super:
2060 up_write(&s->s_umount);
2061 deactivate_super(s);
2062 goto out;
2063 }
2064
2065 /*
2066 * Destroy an NFS2/3 superblock
2067 */
2068 static void nfs_kill_super(struct super_block *s)
2069 {
2070 struct nfs_server *server = NFS_SB(s);
2071
2072 bdi_unregister(&server->backing_dev_info);
2073 kill_anon_super(s);
2074 nfs_free_server(server);
2075 }
2076
2077 /*
2078 * Clone an NFS2/3 server record on xdev traversal (FSID-change)
2079 */
2080 static 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)
2083 {
2084 struct nfs_clone_mount *data = raw_data;
2085 struct super_block *s;
2086 struct nfs_server *server;
2087 struct dentry *mntroot;
2088 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2089 struct nfs_sb_mountdata sb_mntdata = {
2090 .mntflags = flags,
2091 };
2092 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 }
2102 sb_mntdata.server = server;
2103
2104 if (server->flags & NFS_MOUNT_UNSHARED)
2105 compare_super = NULL;
2106
2107 /* Get a superblock - note that we may end up sharing one that already exists */
2108 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
2109 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;
2117 } else {
2118 error = nfs_bdi_register(server);
2119 if (error)
2120 goto error_splat_super;
2121 }
2122
2123 if (!s->s_root) {
2124 /* initial superblock/root creation */
2125 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 }
2133 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
2134 dput(mntroot);
2135 error = -ESTALE;
2136 goto error_splat_super;
2137 }
2138
2139 s->s_flags |= MS_ACTIVE;
2140 mnt->mnt_sb = s;
2141 mnt->mnt_root = mntroot;
2142
2143 /* clone any lsm security options from the parent to the new sb */
2144 security_sb_clone_mnt_opts(data->sb, s);
2145
2146 dprintk("<-- nfs_xdev_get_sb() = 0\n");
2147 return 0;
2148
2149 out_err_nosb:
2150 nfs_free_server(server);
2151 out_err_noserver:
2152 dprintk("<-- nfs_xdev_get_sb() = %d [error]\n", error);
2153 return error;
2154
2155 error_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;
2160 }
2161
2162 #ifdef CONFIG_NFS_V4
2163
2164 /*
2165 * Finish setting up a cloned NFS4 superblock
2166 */
2167 static void nfs4_clone_super(struct super_block *sb,
2168 const struct super_block *old_sb)
2169 {
2170 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);
2176 }
2177
2178 /*
2179 * Set up an NFS4 superblock
2180 */
2181 static void nfs4_fill_super(struct super_block *sb)
2182 {
2183 sb->s_time_gran = 1;
2184 sb->s_op = &nfs4_sops;
2185 nfs_initialise_sb(sb);
2186 }
2187
2188 /*
2189 * Validate NFSv4 mount options
2190 */
2191 static int nfs4_validate_mount_data(void *options,
2192 struct nfs_parsed_mount_data *args,
2193 const char *dev_name)
2194 {
2195 struct sockaddr_in *ap;
2196 struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
2197 char *c;
2198
2199 if (data == NULL)
2200 goto out_no_data;
2201
2202 args->rsize = NFS_MAX_FILE_IO_SIZE;
2203 args->wsize = NFS_MAX_FILE_IO_SIZE;
2204 args->acregmin = NFS_DEF_ACREGMIN;
2205 args->acregmax = NFS_DEF_ACREGMAX;
2206 args->acdirmin = NFS_DEF_ACDIRMIN;
2207 args->acdirmax = NFS_DEF_ACDIRMAX;
2208 args->nfs_server.port = NFS_PORT; /* 2049 unless user set port= */
2209 args->auth_flavors[0] = RPC_AUTH_UNIX;
2210 args->auth_flavor_len = 0;
2211
2212 switch (data->version) {
2213 case 1:
2214 ap = (struct sockaddr_in *)&args->nfs_server.address;
2215 if (data->host_addrlen > sizeof(args->nfs_server.address))
2216 goto out_no_address;
2217 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))
2221 return -EFAULT;
2222 if (!nfs_verify_server_address((struct sockaddr *)
2223 &args->nfs_server.address))
2224 goto out_no_address;
2225
2226 if (data->auth_flavourlen) {
2227 if (data->auth_flavourlen > 1)
2228 goto out_inval_auth;
2229 if (copy_from_user(&args->auth_flavors[0],
2230 data->auth_flavours,
2231 sizeof(args->auth_flavors[0])))
2232 return -EFAULT;
2233 }
2234
2235 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
2236 if (IS_ERR(c))
2237 return PTR_ERR(c);
2238 args->nfs_server.hostname = c;
2239
2240 c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
2241 if (IS_ERR(c))
2242 return PTR_ERR(c);
2243 args->nfs_server.export_path = c;
2244 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
2245
2246 c = strndup_user(data->client_addr.data, 16);
2247 if (IS_ERR(c))
2248 return PTR_ERR(c);
2249 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;
2266 nfs_validate_transport_protocol(args);
2267
2268 break;
2269 default: {
2270 int status;
2271
2272 if (nfs_parse_mount_options((char *)options, args) == 0)
2273 return -EINVAL;
2274
2275 if (!nfs_verify_server_address((struct sockaddr *)
2276 &args->nfs_server.address))
2277 return -EINVAL;
2278
2279 nfs_set_port((struct sockaddr *)&args->nfs_server.address,
2280 args->nfs_server.port);
2281
2282 nfs_validate_transport_protocol(args);
2283
2284 if (args->auth_flavor_len > 1)
2285 goto out_inval_auth;
2286
2287 if (args->client_address == NULL)
2288 goto out_no_client_address;
2289
2290 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
2298 break;
2299 }
2300 }
2301
2302 return 0;
2303
2304 out_no_data:
2305 dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
2306 return -EINVAL;
2307
2308 out_inval_auth:
2309 dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
2310 data->auth_flavourlen);
2311 return -EINVAL;
2312
2313 out_no_address:
2314 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
2315 return -EINVAL;
2316
2317 out_no_client_address:
2318 dfprintk(MOUNT, "NFS4: mount program didn't pass callback address\n");
2319 return -EINVAL;
2320 }
2321
2322 /*
2323 * Get the superblock for an NFS4 mountpoint
2324 */
2325 static int nfs4_get_sb(struct file_system_type *fs_type,
2326 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
2327 {
2328 struct nfs_parsed_mount_data *data;
2329 struct super_block *s;
2330 struct nfs_server *server;
2331 struct nfs_fh *mntfh;
2332 struct dentry *mntroot;
2333 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2334 struct nfs_sb_mountdata sb_mntdata = {
2335 .mntflags = flags,
2336 };
2337 int error = -ENOMEM;
2338
2339 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);
2345
2346 /* Validate the mount data */
2347 error = nfs4_validate_mount_data(raw_data, data, dev_name);
2348 if (error < 0)
2349 goto out;
2350
2351 /* Get a volume representation */
2352 server = nfs4_create_server(data, mntfh);
2353 if (IS_ERR(server)) {
2354 error = PTR_ERR(server);
2355 goto out;
2356 }
2357 sb_mntdata.server = server;
2358
2359 if (server->flags & NFS4_MOUNT_UNSHARED)
2360 compare_super = NULL;
2361
2362 /* Get a superblock - note that we may end up sharing one that already exists */
2363 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
2364 if (IS_ERR(s)) {
2365 error = PTR_ERR(s);
2366 goto out_free;
2367 }
2368
2369 if (s->s_fs_info != server) {
2370 nfs_free_server(server);
2371 server = NULL;
2372 } else {
2373 error = nfs_bdi_register(server);
2374 if (error)
2375 goto error_splat_super;
2376 }
2377
2378 if (!s->s_root) {
2379 /* initial superblock/root creation */
2380 nfs4_fill_super(s);
2381 }
2382
2383 mntroot = nfs4_get_root(s, mntfh);
2384 if (IS_ERR(mntroot)) {
2385 error = PTR_ERR(mntroot);
2386 goto error_splat_super;
2387 }
2388
2389 error = security_sb_set_mnt_opts(s, &data->lsm_opts);
2390 if (error)
2391 goto error_splat_root;
2392
2393 s->s_flags |= MS_ACTIVE;
2394 mnt->mnt_sb = s;
2395 mnt->mnt_root = mntroot;
2396 error = 0;
2397
2398 out:
2399 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);
2403 out_free_fh:
2404 kfree(mntfh);
2405 kfree(data);
2406 return error;
2407
2408 out_free:
2409 nfs_free_server(server);
2410 goto out;
2411
2412 error_splat_root:
2413 dput(mntroot);
2414 error_splat_super:
2415 up_write(&s->s_umount);
2416 deactivate_super(s);
2417 goto out;
2418 }
2419
2420 static 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);
2428 nfs_free_server(server);
2429 }
2430
2431 /*
2432 * Clone an NFS4 server record on xdev traversal (FSID-change)
2433 */
2434 static 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)
2437 {
2438 struct nfs_clone_mount *data = raw_data;
2439 struct super_block *s;
2440 struct nfs_server *server;
2441 struct dentry *mntroot;
2442 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2443 struct nfs_sb_mountdata sb_mntdata = {
2444 .mntflags = flags,
2445 };
2446 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 }
2456 sb_mntdata.server = server;
2457
2458 if (server->flags & NFS4_MOUNT_UNSHARED)
2459 compare_super = NULL;
2460
2461 /* Get a superblock - note that we may end up sharing one that already exists */
2462 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
2463 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;
2471 } else {
2472 error = nfs_bdi_register(server);
2473 if (error)
2474 goto error_splat_super;
2475 }
2476
2477 if (!s->s_root) {
2478 /* initial superblock/root creation */
2479 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 }
2487 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 }
2492
2493 s->s_flags |= MS_ACTIVE;
2494 mnt->mnt_sb = s;
2495 mnt->mnt_root = mntroot;
2496
2497 security_sb_clone_mnt_opts(data->sb, s);
2498
2499 dprintk("<-- nfs4_xdev_get_sb() = 0\n");
2500 return 0;
2501
2502 out_err_nosb:
2503 nfs_free_server(server);
2504 out_err_noserver:
2505 dprintk("<-- nfs4_xdev_get_sb() = %d [error]\n", error);
2506 return error;
2507
2508 error_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;
2513 }
2514
2515 /*
2516 * Create an NFS4 server record on referral traversal
2517 */
2518 static 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)
2521 {
2522 struct nfs_clone_mount *data = raw_data;
2523 struct super_block *s;
2524 struct nfs_server *server;
2525 struct dentry *mntroot;
2526 struct nfs_fh mntfh;
2527 int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2528 struct nfs_sb_mountdata sb_mntdata = {
2529 .mntflags = flags,
2530 };
2531 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 }
2541 sb_mntdata.server = server;
2542
2543 if (server->flags & NFS4_MOUNT_UNSHARED)
2544 compare_super = NULL;
2545
2546 /* Get a superblock - note that we may end up sharing one that already exists */
2547 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
2548 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;
2556 } else {
2557 error = nfs_bdi_register(server);
2558 if (error)
2559 goto error_splat_super;
2560 }
2561
2562 if (!s->s_root) {
2563 /* initial superblock/root creation */
2564 nfs4_fill_super(s);
2565 }
2566
2567 mntroot = nfs4_get_root(s, &mntfh);
2568 if (IS_ERR(mntroot)) {
2569 error = PTR_ERR(mntroot);
2570 goto error_splat_super;
2571 }
2572 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 }
2577
2578 s->s_flags |= MS_ACTIVE;
2579 mnt->mnt_sb = s;
2580 mnt->mnt_root = mntroot;
2581
2582 security_sb_clone_mnt_opts(data->sb, s);
2583
2584 dprintk("<-- nfs4_referral_get_sb() = 0\n");
2585 return 0;
2586
2587 out_err_nosb:
2588 nfs_free_server(server);
2589 out_err_noserver:
2590 dprintk("<-- nfs4_referral_get_sb() = %d [error]\n", error);
2591 return error;
2592
2593 error_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;
2598 }
2599
2600 #endif /* CONFIG_NFS_V4 */
CRIS linux kernel tree