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