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/seq_file.h> 43 #include <linux/mount.h> 44 #include <linux/mnt_namespace.h> 45 #include <linux/namei.h> 46 #include <linux/nfs_idmap.h> 47 #include <linux/vfs.h> 48 #include <linux/inet.h> 49 #include <linux/in6.h> 50 #include <linux/slab.h> 51 #include <net/ipv6.h> 52 #include <linux/netdevice.h> 53 #include <linux/nfs_xdr.h> 54 #include <linux/magic.h> 55 #include <linux/parser.h> 56 57 #include <asm/system.h> 58 #include <asm/uaccess.h> 59 60 #include "nfs4_fs.h" 61 #include "callback.h" 62 #include "delegation.h" 63 #include "iostat.h" 64 #include "internal.h" 65 #include "fscache.h" 66 #include "pnfs.h" 67 68 #define NFSDBG_FACILITY NFSDBG_VFS 69 70 #ifdef CONFIG_NFS_V3 71 #define NFS_DEFAULT_VERSION 3 72 #else 73 #define NFS_DEFAULT_VERSION 2 74 #endif 75 76 enum { 77 /* Mount options that take no arguments */ 78 Opt_soft, Opt_hard, 79 Opt_posix, Opt_noposix, 80 Opt_cto, Opt_nocto, 81 Opt_ac, Opt_noac, 82 Opt_lock, Opt_nolock, 83 Opt_v2, Opt_v3, Opt_v4, 84 Opt_udp, Opt_tcp, Opt_rdma, 85 Opt_acl, Opt_noacl, 86 Opt_rdirplus, Opt_nordirplus, 87 Opt_sharecache, Opt_nosharecache, 88 Opt_resvport, Opt_noresvport, 89 Opt_fscache, Opt_nofscache, 90 91 /* Mount options that take integer arguments */ 92 Opt_port, 93 Opt_rsize, Opt_wsize, Opt_bsize, 94 Opt_timeo, Opt_retrans, 95 Opt_acregmin, Opt_acregmax, 96 Opt_acdirmin, Opt_acdirmax, 97 Opt_actimeo, 98 Opt_namelen, 99 Opt_mountport, 100 Opt_mountvers, 101 Opt_nfsvers, 102 Opt_minorversion, 103 104 /* Mount options that take string arguments */ 105 Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost, 106 Opt_addr, Opt_mountaddr, Opt_clientaddr, 107 Opt_lookupcache, 108 Opt_fscache_uniq, 109 Opt_local_lock, 110 111 /* Special mount options */ 112 Opt_userspace, Opt_deprecated, Opt_sloppy, 113 114 Opt_err 115 }; 116 117 static const match_table_t nfs_mount_option_tokens = { 118 { Opt_userspace, "bg" }, 119 { Opt_userspace, "fg" }, 120 { Opt_userspace, "retry=%s" }, 121 122 { Opt_sloppy, "sloppy" }, 123 124 { Opt_soft, "soft" }, 125 { Opt_hard, "hard" }, 126 { Opt_deprecated, "intr" }, 127 { Opt_deprecated, "nointr" }, 128 { Opt_posix, "posix" }, 129 { Opt_noposix, "noposix" }, 130 { Opt_cto, "cto" }, 131 { Opt_nocto, "nocto" }, 132 { Opt_ac, "ac" }, 133 { Opt_noac, "noac" }, 134 { Opt_lock, "lock" }, 135 { Opt_nolock, "nolock" }, 136 { Opt_v2, "v2" }, 137 { Opt_v3, "v3" }, 138 { Opt_v4, "v4" }, 139 { Opt_udp, "udp" }, 140 { Opt_tcp, "tcp" }, 141 { Opt_rdma, "rdma" }, 142 { Opt_acl, "acl" }, 143 { Opt_noacl, "noacl" }, 144 { Opt_rdirplus, "rdirplus" }, 145 { Opt_nordirplus, "nordirplus" }, 146 { Opt_sharecache, "sharecache" }, 147 { Opt_nosharecache, "nosharecache" }, 148 { Opt_resvport, "resvport" }, 149 { Opt_noresvport, "noresvport" }, 150 { Opt_fscache, "fsc" }, 151 { Opt_nofscache, "nofsc" }, 152 153 { Opt_port, "port=%s" }, 154 { Opt_rsize, "rsize=%s" }, 155 { Opt_wsize, "wsize=%s" }, 156 { Opt_bsize, "bsize=%s" }, 157 { Opt_timeo, "timeo=%s" }, 158 { Opt_retrans, "retrans=%s" }, 159 { Opt_acregmin, "acregmin=%s" }, 160 { Opt_acregmax, "acregmax=%s" }, 161 { Opt_acdirmin, "acdirmin=%s" }, 162 { Opt_acdirmax, "acdirmax=%s" }, 163 { Opt_actimeo, "actimeo=%s" }, 164 { Opt_namelen, "namlen=%s" }, 165 { Opt_mountport, "mountport=%s" }, 166 { Opt_mountvers, "mountvers=%s" }, 167 { Opt_nfsvers, "nfsvers=%s" }, 168 { Opt_nfsvers, "vers=%s" }, 169 { Opt_minorversion, "minorversion=%s" }, 170 171 { Opt_sec, "sec=%s" }, 172 { Opt_proto, "proto=%s" }, 173 { Opt_mountproto, "mountproto=%s" }, 174 { Opt_addr, "addr=%s" }, 175 { Opt_clientaddr, "clientaddr=%s" }, 176 { Opt_mounthost, "mounthost=%s" }, 177 { Opt_mountaddr, "mountaddr=%s" }, 178 179 { Opt_lookupcache, "lookupcache=%s" }, 180 { Opt_fscache_uniq, "fsc=%s" }, 181 { Opt_local_lock, "local_lock=%s" }, 182 183 { Opt_err, NULL } 184 }; 185 186 enum { 187 Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma, 188 189 Opt_xprt_err 190 }; 191 192 static const match_table_t nfs_xprt_protocol_tokens = { 193 { Opt_xprt_udp, "udp" }, 194 { Opt_xprt_udp6, "udp6" }, 195 { Opt_xprt_tcp, "tcp" }, 196 { Opt_xprt_tcp6, "tcp6" }, 197 { Opt_xprt_rdma, "rdma" }, 198 199 { Opt_xprt_err, NULL } 200 }; 201 202 enum { 203 Opt_sec_none, Opt_sec_sys, 204 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p, 205 Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp, 206 Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp, 207 208 Opt_sec_err 209 }; 210 211 static const match_table_t nfs_secflavor_tokens = { 212 { Opt_sec_none, "none" }, 213 { Opt_sec_none, "null" }, 214 { Opt_sec_sys, "sys" }, 215 216 { Opt_sec_krb5, "krb5" }, 217 { Opt_sec_krb5i, "krb5i" }, 218 { Opt_sec_krb5p, "krb5p" }, 219 220 { Opt_sec_lkey, "lkey" }, 221 { Opt_sec_lkeyi, "lkeyi" }, 222 { Opt_sec_lkeyp, "lkeyp" }, 223 224 { Opt_sec_spkm, "spkm3" }, 225 { Opt_sec_spkmi, "spkm3i" }, 226 { Opt_sec_spkmp, "spkm3p" }, 227 228 { Opt_sec_err, NULL } 229 }; 230 231 enum { 232 Opt_lookupcache_all, Opt_lookupcache_positive, 233 Opt_lookupcache_none, 234 235 Opt_lookupcache_err 236 }; 237 238 static match_table_t nfs_lookupcache_tokens = { 239 { Opt_lookupcache_all, "all" }, 240 { Opt_lookupcache_positive, "pos" }, 241 { Opt_lookupcache_positive, "positive" }, 242 { Opt_lookupcache_none, "none" }, 243 244 { Opt_lookupcache_err, NULL } 245 }; 246 247 enum { 248 Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix, 249 Opt_local_lock_none, 250 251 Opt_local_lock_err 252 }; 253 254 static match_table_t nfs_local_lock_tokens = { 255 { Opt_local_lock_all, "all" }, 256 { Opt_local_lock_flock, "flock" }, 257 { Opt_local_lock_posix, "posix" }, 258 { Opt_local_lock_none, "none" }, 259 260 { Opt_local_lock_err, NULL } 261 }; 262 263 264 static void nfs_umount_begin(struct super_block *); 265 static int nfs_statfs(struct dentry *, struct kstatfs *); 266 static int nfs_show_options(struct seq_file *, struct vfsmount *); 267 static int nfs_show_devname(struct seq_file *, struct vfsmount *); 268 static int nfs_show_path(struct seq_file *, struct vfsmount *); 269 static int nfs_show_stats(struct seq_file *, struct vfsmount *); 270 static struct dentry *nfs_fs_mount(struct file_system_type *, 271 int, const char *, void *); 272 static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type, 273 int flags, const char *dev_name, void *raw_data); 274 static void nfs_put_super(struct super_block *); 275 static void nfs_kill_super(struct super_block *); 276 static int nfs_remount(struct super_block *sb, int *flags, char *raw_data); 277 278 static struct file_system_type nfs_fs_type = { 279 .owner = THIS_MODULE, 280 .name = "nfs", 281 .mount = nfs_fs_mount, 282 .kill_sb = nfs_kill_super, 283 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 284 }; 285 286 struct file_system_type nfs_xdev_fs_type = { 287 .owner = THIS_MODULE, 288 .name = "nfs", 289 .mount = nfs_xdev_mount, 290 .kill_sb = nfs_kill_super, 291 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 292 }; 293 294 static const struct super_operations nfs_sops = { 295 .alloc_inode = nfs_alloc_inode, 296 .destroy_inode = nfs_destroy_inode, 297 .write_inode = nfs_write_inode, 298 .put_super = nfs_put_super, 299 .statfs = nfs_statfs, 300 .evict_inode = nfs_evict_inode, 301 .umount_begin = nfs_umount_begin, 302 .show_options = nfs_show_options, 303 .show_devname = nfs_show_devname, 304 .show_path = nfs_show_path, 305 .show_stats = nfs_show_stats, 306 .remount_fs = nfs_remount, 307 }; 308 309 #ifdef CONFIG_NFS_V4 310 static int nfs4_validate_text_mount_data(void *options, 311 struct nfs_parsed_mount_data *args, const char *dev_name); 312 static struct dentry *nfs4_try_mount(int flags, const char *dev_name, 313 struct nfs_parsed_mount_data *data); 314 static struct dentry *nfs4_mount(struct file_system_type *fs_type, 315 int flags, const char *dev_name, void *raw_data); 316 static struct dentry *nfs4_remote_mount(struct file_system_type *fs_type, 317 int flags, const char *dev_name, void *raw_data); 318 static struct dentry *nfs4_xdev_mount(struct file_system_type *fs_type, 319 int flags, const char *dev_name, void *raw_data); 320 static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type, 321 int flags, const char *dev_name, void *raw_data); 322 static struct dentry *nfs4_remote_referral_mount(struct file_system_type *fs_type, 323 int flags, const char *dev_name, void *raw_data); 324 static void nfs4_kill_super(struct super_block *sb); 325 326 static struct file_system_type nfs4_fs_type = { 327 .owner = THIS_MODULE, 328 .name = "nfs4", 329 .mount = nfs4_mount, 330 .kill_sb = nfs4_kill_super, 331 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 332 }; 333 334 static struct file_system_type nfs4_remote_fs_type = { 335 .owner = THIS_MODULE, 336 .name = "nfs4", 337 .mount = nfs4_remote_mount, 338 .kill_sb = nfs4_kill_super, 339 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 340 }; 341 342 struct file_system_type nfs4_xdev_fs_type = { 343 .owner = THIS_MODULE, 344 .name = "nfs4", 345 .mount = nfs4_xdev_mount, 346 .kill_sb = nfs4_kill_super, 347 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 348 }; 349 350 static struct file_system_type nfs4_remote_referral_fs_type = { 351 .owner = THIS_MODULE, 352 .name = "nfs4", 353 .mount = nfs4_remote_referral_mount, 354 .kill_sb = nfs4_kill_super, 355 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 356 }; 357 358 struct file_system_type nfs4_referral_fs_type = { 359 .owner = THIS_MODULE, 360 .name = "nfs4", 361 .mount = nfs4_referral_mount, 362 .kill_sb = nfs4_kill_super, 363 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA, 364 }; 365 366 static const struct super_operations nfs4_sops = { 367 .alloc_inode = nfs_alloc_inode, 368 .destroy_inode = nfs_destroy_inode, 369 .write_inode = nfs_write_inode, 370 .put_super = nfs_put_super, 371 .statfs = nfs_statfs, 372 .evict_inode = nfs4_evict_inode, 373 .umount_begin = nfs_umount_begin, 374 .show_options = nfs_show_options, 375 .show_devname = nfs_show_devname, 376 .show_path = nfs_show_path, 377 .show_stats = nfs_show_stats, 378 .remount_fs = nfs_remount, 379 }; 380 #endif 381 382 static struct shrinker acl_shrinker = { 383 .shrink = nfs_access_cache_shrinker, 384 .seeks = DEFAULT_SEEKS, 385 }; 386 387 /* 388 * Register the NFS filesystems 389 */ 390 int __init register_nfs_fs(void) 391 { 392 int ret; 393 394 ret = register_filesystem(&nfs_fs_type); 395 if (ret < 0) 396 goto error_0; 397 398 ret = nfs_register_sysctl(); 399 if (ret < 0) 400 goto error_1; 401 #ifdef CONFIG_NFS_V4 402 ret = register_filesystem(&nfs4_fs_type); 403 if (ret < 0) 404 goto error_2; 405 #endif 406 register_shrinker(&acl_shrinker); 407 return 0; 408 409 #ifdef CONFIG_NFS_V4 410 error_2: 411 nfs_unregister_sysctl(); 412 #endif 413 error_1: 414 unregister_filesystem(&nfs_fs_type); 415 error_0: 416 return ret; 417 } 418 419 /* 420 * Unregister the NFS filesystems 421 */ 422 void __exit unregister_nfs_fs(void) 423 { 424 unregister_shrinker(&acl_shrinker); 425 #ifdef CONFIG_NFS_V4 426 unregister_filesystem(&nfs4_fs_type); 427 #endif 428 nfs_unregister_sysctl(); 429 unregister_filesystem(&nfs_fs_type); 430 } 431 432 void nfs_sb_active(struct super_block *sb) 433 { 434 struct nfs_server *server = NFS_SB(sb); 435 436 if (atomic_inc_return(&server->active) == 1) 437 atomic_inc(&sb->s_active); 438 } 439 440 void nfs_sb_deactive(struct super_block *sb) 441 { 442 struct nfs_server *server = NFS_SB(sb); 443 444 if (atomic_dec_and_test(&server->active)) 445 deactivate_super(sb); 446 } 447 448 /* 449 * Deliver file system statistics to userspace 450 */ 451 static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf) 452 { 453 struct nfs_server *server = NFS_SB(dentry->d_sb); 454 unsigned char blockbits; 455 unsigned long blockres; 456 struct nfs_fh *fh = NFS_FH(dentry->d_inode); 457 struct nfs_fsstat res; 458 int error = -ENOMEM; 459 460 res.fattr = nfs_alloc_fattr(); 461 if (res.fattr == NULL) 462 goto out_err; 463 464 error = server->nfs_client->rpc_ops->statfs(server, fh, &res); 465 if (unlikely(error == -ESTALE)) { 466 struct dentry *pd_dentry; 467 468 pd_dentry = dget_parent(dentry); 469 if (pd_dentry != NULL) { 470 nfs_zap_caches(pd_dentry->d_inode); 471 dput(pd_dentry); 472 } 473 } 474 nfs_free_fattr(res.fattr); 475 if (error < 0) 476 goto out_err; 477 478 buf->f_type = NFS_SUPER_MAGIC; 479 480 /* 481 * Current versions of glibc do not correctly handle the 482 * case where f_frsize != f_bsize. Eventually we want to 483 * report the value of wtmult in this field. 484 */ 485 buf->f_frsize = dentry->d_sb->s_blocksize; 486 487 /* 488 * On most *nix systems, f_blocks, f_bfree, and f_bavail 489 * are reported in units of f_frsize. Linux hasn't had 490 * an f_frsize field in its statfs struct until recently, 491 * thus historically Linux's sys_statfs reports these 492 * fields in units of f_bsize. 493 */ 494 buf->f_bsize = dentry->d_sb->s_blocksize; 495 blockbits = dentry->d_sb->s_blocksize_bits; 496 blockres = (1 << blockbits) - 1; 497 buf->f_blocks = (res.tbytes + blockres) >> blockbits; 498 buf->f_bfree = (res.fbytes + blockres) >> blockbits; 499 buf->f_bavail = (res.abytes + blockres) >> blockbits; 500 501 buf->f_files = res.tfiles; 502 buf->f_ffree = res.afiles; 503 504 buf->f_namelen = server->namelen; 505 506 return 0; 507 508 out_err: 509 dprintk("%s: statfs error = %d\n", __func__, -error); 510 return error; 511 } 512 513 /* 514 * Map the security flavour number to a name 515 */ 516 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour) 517 { 518 static const struct { 519 rpc_authflavor_t flavour; 520 const char *str; 521 } sec_flavours[] = { 522 { RPC_AUTH_NULL, "null" }, 523 { RPC_AUTH_UNIX, "sys" }, 524 { RPC_AUTH_GSS_KRB5, "krb5" }, 525 { RPC_AUTH_GSS_KRB5I, "krb5i" }, 526 { RPC_AUTH_GSS_KRB5P, "krb5p" }, 527 { RPC_AUTH_GSS_LKEY, "lkey" }, 528 { RPC_AUTH_GSS_LKEYI, "lkeyi" }, 529 { RPC_AUTH_GSS_LKEYP, "lkeyp" }, 530 { RPC_AUTH_GSS_SPKM, "spkm" }, 531 { RPC_AUTH_GSS_SPKMI, "spkmi" }, 532 { RPC_AUTH_GSS_SPKMP, "spkmp" }, 533 { UINT_MAX, "unknown" } 534 }; 535 int i; 536 537 for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) { 538 if (sec_flavours[i].flavour == flavour) 539 break; 540 } 541 return sec_flavours[i].str; 542 } 543 544 static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss, 545 int showdefaults) 546 { 547 struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address; 548 549 seq_printf(m, ",mountproto="); 550 switch (sap->sa_family) { 551 case AF_INET: 552 switch (nfss->mountd_protocol) { 553 case IPPROTO_UDP: 554 seq_printf(m, RPCBIND_NETID_UDP); 555 break; 556 case IPPROTO_TCP: 557 seq_printf(m, RPCBIND_NETID_TCP); 558 break; 559 default: 560 if (showdefaults) 561 seq_printf(m, "auto"); 562 } 563 break; 564 case AF_INET6: 565 switch (nfss->mountd_protocol) { 566 case IPPROTO_UDP: 567 seq_printf(m, RPCBIND_NETID_UDP6); 568 break; 569 case IPPROTO_TCP: 570 seq_printf(m, RPCBIND_NETID_TCP6); 571 break; 572 default: 573 if (showdefaults) 574 seq_printf(m, "auto"); 575 } 576 break; 577 default: 578 if (showdefaults) 579 seq_printf(m, "auto"); 580 } 581 } 582 583 static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss, 584 int showdefaults) 585 { 586 struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address; 587 588 if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE) 589 return; 590 591 switch (sap->sa_family) { 592 case AF_INET: { 593 struct sockaddr_in *sin = (struct sockaddr_in *)sap; 594 seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr); 595 break; 596 } 597 case AF_INET6: { 598 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; 599 seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr); 600 break; 601 } 602 default: 603 if (showdefaults) 604 seq_printf(m, ",mountaddr=unspecified"); 605 } 606 607 if (nfss->mountd_version || showdefaults) 608 seq_printf(m, ",mountvers=%u", nfss->mountd_version); 609 if ((nfss->mountd_port && 610 nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) || 611 showdefaults) 612 seq_printf(m, ",mountport=%u", nfss->mountd_port); 613 614 nfs_show_mountd_netid(m, nfss, showdefaults); 615 } 616 617 #ifdef CONFIG_NFS_V4 618 static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss, 619 int showdefaults) 620 { 621 struct nfs_client *clp = nfss->nfs_client; 622 623 seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr); 624 seq_printf(m, ",minorversion=%u", clp->cl_minorversion); 625 } 626 #else 627 static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss, 628 int showdefaults) 629 { 630 } 631 #endif 632 633 /* 634 * Describe the mount options in force on this server representation 635 */ 636 static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss, 637 int showdefaults) 638 { 639 static const struct proc_nfs_info { 640 int flag; 641 const char *str; 642 const char *nostr; 643 } nfs_info[] = { 644 { NFS_MOUNT_SOFT, ",soft", ",hard" }, 645 { NFS_MOUNT_POSIX, ",posix", "" }, 646 { NFS_MOUNT_NOCTO, ",nocto", "" }, 647 { NFS_MOUNT_NOAC, ",noac", "" }, 648 { NFS_MOUNT_NONLM, ",nolock", "" }, 649 { NFS_MOUNT_NOACL, ",noacl", "" }, 650 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" }, 651 { NFS_MOUNT_UNSHARED, ",nosharecache", "" }, 652 { NFS_MOUNT_NORESVPORT, ",noresvport", "" }, 653 { 0, NULL, NULL } 654 }; 655 const struct proc_nfs_info *nfs_infop; 656 struct nfs_client *clp = nfss->nfs_client; 657 u32 version = clp->rpc_ops->version; 658 int local_flock, local_fcntl; 659 660 seq_printf(m, ",vers=%u", version); 661 seq_printf(m, ",rsize=%u", nfss->rsize); 662 seq_printf(m, ",wsize=%u", nfss->wsize); 663 if (nfss->bsize != 0) 664 seq_printf(m, ",bsize=%u", nfss->bsize); 665 seq_printf(m, ",namlen=%u", nfss->namelen); 666 if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults) 667 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ); 668 if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults) 669 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ); 670 if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults) 671 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ); 672 if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults) 673 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ); 674 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) { 675 if (nfss->flags & nfs_infop->flag) 676 seq_puts(m, nfs_infop->str); 677 else 678 seq_puts(m, nfs_infop->nostr); 679 } 680 seq_printf(m, ",proto=%s", 681 rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID)); 682 if (version == 4) { 683 if (nfss->port != NFS_PORT) 684 seq_printf(m, ",port=%u", nfss->port); 685 } else 686 if (nfss->port) 687 seq_printf(m, ",port=%u", nfss->port); 688 689 seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ); 690 seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries); 691 seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor)); 692 693 if (version != 4) 694 nfs_show_mountd_options(m, nfss, showdefaults); 695 else 696 nfs_show_nfsv4_options(m, nfss, showdefaults); 697 698 if (nfss->options & NFS_OPTION_FSCACHE) 699 seq_printf(m, ",fsc"); 700 701 if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) { 702 if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 703 seq_printf(m, ",lookupcache=none"); 704 else 705 seq_printf(m, ",lookupcache=pos"); 706 } 707 708 local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK; 709 local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL; 710 711 if (!local_flock && !local_fcntl) 712 seq_printf(m, ",local_lock=none"); 713 else if (local_flock && local_fcntl) 714 seq_printf(m, ",local_lock=all"); 715 else if (local_flock) 716 seq_printf(m, ",local_lock=flock"); 717 else 718 seq_printf(m, ",local_lock=posix"); 719 } 720 721 /* 722 * Describe the mount options on this VFS mountpoint 723 */ 724 static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt) 725 { 726 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb); 727 728 nfs_show_mount_options(m, nfss, 0); 729 730 seq_printf(m, ",addr=%s", 731 rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient, 732 RPC_DISPLAY_ADDR)); 733 734 return 0; 735 } 736 737 #ifdef CONFIG_NFS_V4 738 #ifdef CONFIG_NFS_V4_1 739 static void show_sessions(struct seq_file *m, struct nfs_server *server) 740 { 741 if (nfs4_has_session(server->nfs_client)) 742 seq_printf(m, ",sessions"); 743 } 744 #else 745 static void show_sessions(struct seq_file *m, struct nfs_server *server) {} 746 #endif 747 #endif 748 749 #ifdef CONFIG_NFS_V4 750 #ifdef CONFIG_NFS_V4_1 751 static void show_pnfs(struct seq_file *m, struct nfs_server *server) 752 { 753 seq_printf(m, ",pnfs="); 754 if (server->pnfs_curr_ld) 755 seq_printf(m, "%s", server->pnfs_curr_ld->name); 756 else 757 seq_printf(m, "not configured"); 758 } 759 #else 760 static void show_pnfs(struct seq_file *m, struct nfs_server *server) {} 761 #endif 762 #endif 763 764 static int nfs_show_devname(struct seq_file *m, struct vfsmount *mnt) 765 { 766 char *page = (char *) __get_free_page(GFP_KERNEL); 767 char *devname, *dummy; 768 int err = 0; 769 if (!page) 770 return -ENOMEM; 771 devname = nfs_path(&dummy, mnt->mnt_root, page, PAGE_SIZE); 772 if (IS_ERR(devname)) 773 err = PTR_ERR(devname); 774 else 775 seq_escape(m, devname, " \t\n\\"); 776 free_page((unsigned long)page); 777 return err; 778 } 779 780 static int nfs_show_path(struct seq_file *m, struct vfsmount *mnt) 781 { 782 seq_puts(m, "/"); 783 return 0; 784 } 785 786 /* 787 * Present statistical information for this VFS mountpoint 788 */ 789 static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt) 790 { 791 int i, cpu; 792 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb); 793 struct rpc_auth *auth = nfss->client->cl_auth; 794 struct nfs_iostats totals = { }; 795 796 seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS); 797 798 /* 799 * Display all mount option settings 800 */ 801 seq_printf(m, "\n\topts:\t"); 802 seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw"); 803 seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : ""); 804 seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : ""); 805 seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : ""); 806 nfs_show_mount_options(m, nfss, 1); 807 808 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ); 809 810 seq_printf(m, "\n\tcaps:\t"); 811 seq_printf(m, "caps=0x%x", nfss->caps); 812 seq_printf(m, ",wtmult=%u", nfss->wtmult); 813 seq_printf(m, ",dtsize=%u", nfss->dtsize); 814 seq_printf(m, ",bsize=%u", nfss->bsize); 815 seq_printf(m, ",namlen=%u", nfss->namelen); 816 817 #ifdef CONFIG_NFS_V4 818 if (nfss->nfs_client->rpc_ops->version == 4) { 819 seq_printf(m, "\n\tnfsv4:\t"); 820 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]); 821 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]); 822 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask); 823 show_sessions(m, nfss); 824 show_pnfs(m, nfss); 825 } 826 #endif 827 828 /* 829 * Display security flavor in effect for this mount 830 */ 831 seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor); 832 if (auth->au_flavor) 833 seq_printf(m, ",pseudoflavor=%u", auth->au_flavor); 834 835 /* 836 * Display superblock I/O counters 837 */ 838 for_each_possible_cpu(cpu) { 839 struct nfs_iostats *stats; 840 841 preempt_disable(); 842 stats = per_cpu_ptr(nfss->io_stats, cpu); 843 844 for (i = 0; i < __NFSIOS_COUNTSMAX; i++) 845 totals.events[i] += stats->events[i]; 846 for (i = 0; i < __NFSIOS_BYTESMAX; i++) 847 totals.bytes[i] += stats->bytes[i]; 848 #ifdef CONFIG_NFS_FSCACHE 849 for (i = 0; i < __NFSIOS_FSCACHEMAX; i++) 850 totals.fscache[i] += stats->fscache[i]; 851 #endif 852 853 preempt_enable(); 854 } 855 856 seq_printf(m, "\n\tevents:\t"); 857 for (i = 0; i < __NFSIOS_COUNTSMAX; i++) 858 seq_printf(m, "%lu ", totals.events[i]); 859 seq_printf(m, "\n\tbytes:\t"); 860 for (i = 0; i < __NFSIOS_BYTESMAX; i++) 861 seq_printf(m, "%Lu ", totals.bytes[i]); 862 #ifdef CONFIG_NFS_FSCACHE 863 if (nfss->options & NFS_OPTION_FSCACHE) { 864 seq_printf(m, "\n\tfsc:\t"); 865 for (i = 0; i < __NFSIOS_FSCACHEMAX; i++) 866 seq_printf(m, "%Lu ", totals.bytes[i]); 867 } 868 #endif 869 seq_printf(m, "\n"); 870 871 rpc_print_iostats(m, nfss->client); 872 873 return 0; 874 } 875 876 /* 877 * Begin unmount by attempting to remove all automounted mountpoints we added 878 * in response to xdev traversals and referrals 879 */ 880 static void nfs_umount_begin(struct super_block *sb) 881 { 882 struct nfs_server *server; 883 struct rpc_clnt *rpc; 884 885 server = NFS_SB(sb); 886 /* -EIO all pending I/O */ 887 rpc = server->client_acl; 888 if (!IS_ERR(rpc)) 889 rpc_killall_tasks(rpc); 890 rpc = server->client; 891 if (!IS_ERR(rpc)) 892 rpc_killall_tasks(rpc); 893 } 894 895 static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(unsigned int version) 896 { 897 struct nfs_parsed_mount_data *data; 898 899 data = kzalloc(sizeof(*data), GFP_KERNEL); 900 if (data) { 901 data->acregmin = NFS_DEF_ACREGMIN; 902 data->acregmax = NFS_DEF_ACREGMAX; 903 data->acdirmin = NFS_DEF_ACDIRMIN; 904 data->acdirmax = NFS_DEF_ACDIRMAX; 905 data->mount_server.port = NFS_UNSPEC_PORT; 906 data->nfs_server.port = NFS_UNSPEC_PORT; 907 data->nfs_server.protocol = XPRT_TRANSPORT_TCP; 908 data->auth_flavors[0] = RPC_AUTH_UNIX; 909 data->auth_flavor_len = 1; 910 data->version = version; 911 data->minorversion = 0; 912 } 913 return data; 914 } 915 916 /* 917 * Sanity-check a server address provided by the mount command. 918 * 919 * Address family must be initialized, and address must not be 920 * the ANY address for that family. 921 */ 922 static int nfs_verify_server_address(struct sockaddr *addr) 923 { 924 switch (addr->sa_family) { 925 case AF_INET: { 926 struct sockaddr_in *sa = (struct sockaddr_in *)addr; 927 return sa->sin_addr.s_addr != htonl(INADDR_ANY); 928 } 929 case AF_INET6: { 930 struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr; 931 return !ipv6_addr_any(sa); 932 } 933 } 934 935 dfprintk(MOUNT, "NFS: Invalid IP address specified\n"); 936 return 0; 937 } 938 939 /* 940 * Select between a default port value and a user-specified port value. 941 * If a zero value is set, then autobind will be used. 942 */ 943 static void nfs_set_port(struct sockaddr *sap, int *port, 944 const unsigned short default_port) 945 { 946 if (*port == NFS_UNSPEC_PORT) 947 *port = default_port; 948 949 rpc_set_port(sap, *port); 950 } 951 952 /* 953 * Sanity check the NFS transport protocol. 954 * 955 */ 956 static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt) 957 { 958 switch (mnt->nfs_server.protocol) { 959 case XPRT_TRANSPORT_UDP: 960 case XPRT_TRANSPORT_TCP: 961 case XPRT_TRANSPORT_RDMA: 962 break; 963 default: 964 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; 965 } 966 } 967 968 /* 969 * For text based NFSv2/v3 mounts, the mount protocol transport default 970 * settings should depend upon the specified NFS transport. 971 */ 972 static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt) 973 { 974 nfs_validate_transport_protocol(mnt); 975 976 if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP || 977 mnt->mount_server.protocol == XPRT_TRANSPORT_TCP) 978 return; 979 switch (mnt->nfs_server.protocol) { 980 case XPRT_TRANSPORT_UDP: 981 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP; 982 break; 983 case XPRT_TRANSPORT_TCP: 984 case XPRT_TRANSPORT_RDMA: 985 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP; 986 } 987 } 988 989 /* 990 * Parse the value of the 'sec=' option. 991 */ 992 static int nfs_parse_security_flavors(char *value, 993 struct nfs_parsed_mount_data *mnt) 994 { 995 substring_t args[MAX_OPT_ARGS]; 996 997 dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value); 998 999 switch (match_token(value, nfs_secflavor_tokens, args)) { 1000 case Opt_sec_none: 1001 mnt->auth_flavors[0] = RPC_AUTH_NULL; 1002 break; 1003 case Opt_sec_sys: 1004 mnt->auth_flavors[0] = RPC_AUTH_UNIX; 1005 break; 1006 case Opt_sec_krb5: 1007 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5; 1008 break; 1009 case Opt_sec_krb5i: 1010 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I; 1011 break; 1012 case Opt_sec_krb5p: 1013 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P; 1014 break; 1015 case Opt_sec_lkey: 1016 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY; 1017 break; 1018 case Opt_sec_lkeyi: 1019 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI; 1020 break; 1021 case Opt_sec_lkeyp: 1022 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP; 1023 break; 1024 case Opt_sec_spkm: 1025 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM; 1026 break; 1027 case Opt_sec_spkmi: 1028 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI; 1029 break; 1030 case Opt_sec_spkmp: 1031 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP; 1032 break; 1033 default: 1034 return 0; 1035 } 1036 1037 mnt->flags |= NFS_MOUNT_SECFLAVOUR; 1038 mnt->auth_flavor_len = 1; 1039 return 1; 1040 } 1041 1042 static int nfs_get_option_str(substring_t args[], char **option) 1043 { 1044 kfree(*option); 1045 *option = match_strdup(args); 1046 return !option; 1047 } 1048 1049 static int nfs_get_option_ul(substring_t args[], unsigned long *option) 1050 { 1051 int rc; 1052 char *string; 1053 1054 string = match_strdup(args); 1055 if (string == NULL) 1056 return -ENOMEM; 1057 rc = strict_strtoul(string, 10, option); 1058 kfree(string); 1059 1060 return rc; 1061 } 1062 1063 /* 1064 * Error-check and convert a string of mount options from user space into 1065 * a data structure. The whole mount string is processed; bad options are 1066 * skipped as they are encountered. If there were no errors, return 1; 1067 * otherwise return 0 (zero). 1068 */ 1069 static int nfs_parse_mount_options(char *raw, 1070 struct nfs_parsed_mount_data *mnt) 1071 { 1072 char *p, *string, *secdata; 1073 int rc, sloppy = 0, invalid_option = 0; 1074 unsigned short protofamily = AF_UNSPEC; 1075 unsigned short mountfamily = AF_UNSPEC; 1076 1077 if (!raw) { 1078 dfprintk(MOUNT, "NFS: mount options string was NULL.\n"); 1079 return 1; 1080 } 1081 dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw); 1082 1083 secdata = alloc_secdata(); 1084 if (!secdata) 1085 goto out_nomem; 1086 1087 rc = security_sb_copy_data(raw, secdata); 1088 if (rc) 1089 goto out_security_failure; 1090 1091 rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts); 1092 if (rc) 1093 goto out_security_failure; 1094 1095 free_secdata(secdata); 1096 1097 while ((p = strsep(&raw, ",")) != NULL) { 1098 substring_t args[MAX_OPT_ARGS]; 1099 unsigned long option; 1100 int token; 1101 1102 if (!*p) 1103 continue; 1104 1105 dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p); 1106 1107 token = match_token(p, nfs_mount_option_tokens, args); 1108 switch (token) { 1109 1110 /* 1111 * boolean options: foo/nofoo 1112 */ 1113 case Opt_soft: 1114 mnt->flags |= NFS_MOUNT_SOFT; 1115 break; 1116 case Opt_hard: 1117 mnt->flags &= ~NFS_MOUNT_SOFT; 1118 break; 1119 case Opt_posix: 1120 mnt->flags |= NFS_MOUNT_POSIX; 1121 break; 1122 case Opt_noposix: 1123 mnt->flags &= ~NFS_MOUNT_POSIX; 1124 break; 1125 case Opt_cto: 1126 mnt->flags &= ~NFS_MOUNT_NOCTO; 1127 break; 1128 case Opt_nocto: 1129 mnt->flags |= NFS_MOUNT_NOCTO; 1130 break; 1131 case Opt_ac: 1132 mnt->flags &= ~NFS_MOUNT_NOAC; 1133 break; 1134 case Opt_noac: 1135 mnt->flags |= NFS_MOUNT_NOAC; 1136 break; 1137 case Opt_lock: 1138 mnt->flags &= ~NFS_MOUNT_NONLM; 1139 mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | 1140 NFS_MOUNT_LOCAL_FCNTL); 1141 break; 1142 case Opt_nolock: 1143 mnt->flags |= NFS_MOUNT_NONLM; 1144 mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK | 1145 NFS_MOUNT_LOCAL_FCNTL); 1146 break; 1147 case Opt_v2: 1148 mnt->flags &= ~NFS_MOUNT_VER3; 1149 mnt->version = 2; 1150 break; 1151 case Opt_v3: 1152 mnt->flags |= NFS_MOUNT_VER3; 1153 mnt->version = 3; 1154 break; 1155 case Opt_v4: 1156 mnt->flags &= ~NFS_MOUNT_VER3; 1157 mnt->version = 4; 1158 break; 1159 case Opt_udp: 1160 mnt->flags &= ~NFS_MOUNT_TCP; 1161 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; 1162 break; 1163 case Opt_tcp: 1164 mnt->flags |= NFS_MOUNT_TCP; 1165 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; 1166 break; 1167 case Opt_rdma: 1168 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */ 1169 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA; 1170 xprt_load_transport(p); 1171 break; 1172 case Opt_acl: 1173 mnt->flags &= ~NFS_MOUNT_NOACL; 1174 break; 1175 case Opt_noacl: 1176 mnt->flags |= NFS_MOUNT_NOACL; 1177 break; 1178 case Opt_rdirplus: 1179 mnt->flags &= ~NFS_MOUNT_NORDIRPLUS; 1180 break; 1181 case Opt_nordirplus: 1182 mnt->flags |= NFS_MOUNT_NORDIRPLUS; 1183 break; 1184 case Opt_sharecache: 1185 mnt->flags &= ~NFS_MOUNT_UNSHARED; 1186 break; 1187 case Opt_nosharecache: 1188 mnt->flags |= NFS_MOUNT_UNSHARED; 1189 break; 1190 case Opt_resvport: 1191 mnt->flags &= ~NFS_MOUNT_NORESVPORT; 1192 break; 1193 case Opt_noresvport: 1194 mnt->flags |= NFS_MOUNT_NORESVPORT; 1195 break; 1196 case Opt_fscache: 1197 mnt->options |= NFS_OPTION_FSCACHE; 1198 kfree(mnt->fscache_uniq); 1199 mnt->fscache_uniq = NULL; 1200 break; 1201 case Opt_nofscache: 1202 mnt->options &= ~NFS_OPTION_FSCACHE; 1203 kfree(mnt->fscache_uniq); 1204 mnt->fscache_uniq = NULL; 1205 break; 1206 1207 /* 1208 * options that take numeric values 1209 */ 1210 case Opt_port: 1211 if (nfs_get_option_ul(args, &option) || 1212 option > USHRT_MAX) 1213 goto out_invalid_value; 1214 mnt->nfs_server.port = option; 1215 break; 1216 case Opt_rsize: 1217 if (nfs_get_option_ul(args, &option)) 1218 goto out_invalid_value; 1219 mnt->rsize = option; 1220 break; 1221 case Opt_wsize: 1222 if (nfs_get_option_ul(args, &option)) 1223 goto out_invalid_value; 1224 mnt->wsize = option; 1225 break; 1226 case Opt_bsize: 1227 if (nfs_get_option_ul(args, &option)) 1228 goto out_invalid_value; 1229 mnt->bsize = option; 1230 break; 1231 case Opt_timeo: 1232 if (nfs_get_option_ul(args, &option) || option == 0) 1233 goto out_invalid_value; 1234 mnt->timeo = option; 1235 break; 1236 case Opt_retrans: 1237 if (nfs_get_option_ul(args, &option) || option == 0) 1238 goto out_invalid_value; 1239 mnt->retrans = option; 1240 break; 1241 case Opt_acregmin: 1242 if (nfs_get_option_ul(args, &option)) 1243 goto out_invalid_value; 1244 mnt->acregmin = option; 1245 break; 1246 case Opt_acregmax: 1247 if (nfs_get_option_ul(args, &option)) 1248 goto out_invalid_value; 1249 mnt->acregmax = option; 1250 break; 1251 case Opt_acdirmin: 1252 if (nfs_get_option_ul(args, &option)) 1253 goto out_invalid_value; 1254 mnt->acdirmin = option; 1255 break; 1256 case Opt_acdirmax: 1257 if (nfs_get_option_ul(args, &option)) 1258 goto out_invalid_value; 1259 mnt->acdirmax = option; 1260 break; 1261 case Opt_actimeo: 1262 if (nfs_get_option_ul(args, &option)) 1263 goto out_invalid_value; 1264 mnt->acregmin = mnt->acregmax = 1265 mnt->acdirmin = mnt->acdirmax = option; 1266 break; 1267 case Opt_namelen: 1268 if (nfs_get_option_ul(args, &option)) 1269 goto out_invalid_value; 1270 mnt->namlen = option; 1271 break; 1272 case Opt_mountport: 1273 if (nfs_get_option_ul(args, &option) || 1274 option > USHRT_MAX) 1275 goto out_invalid_value; 1276 mnt->mount_server.port = option; 1277 break; 1278 case Opt_mountvers: 1279 if (nfs_get_option_ul(args, &option) || 1280 option < NFS_MNT_VERSION || 1281 option > NFS_MNT3_VERSION) 1282 goto out_invalid_value; 1283 mnt->mount_server.version = option; 1284 break; 1285 case Opt_nfsvers: 1286 if (nfs_get_option_ul(args, &option)) 1287 goto out_invalid_value; 1288 switch (option) { 1289 case NFS2_VERSION: 1290 mnt->flags &= ~NFS_MOUNT_VER3; 1291 mnt->version = 2; 1292 break; 1293 case NFS3_VERSION: 1294 mnt->flags |= NFS_MOUNT_VER3; 1295 mnt->version = 3; 1296 break; 1297 case NFS4_VERSION: 1298 mnt->flags &= ~NFS_MOUNT_VER3; 1299 mnt->version = 4; 1300 break; 1301 default: 1302 goto out_invalid_value; 1303 } 1304 break; 1305 case Opt_minorversion: 1306 if (nfs_get_option_ul(args, &option)) 1307 goto out_invalid_value; 1308 if (option > NFS4_MAX_MINOR_VERSION) 1309 goto out_invalid_value; 1310 mnt->minorversion = option; 1311 break; 1312 1313 /* 1314 * options that take text values 1315 */ 1316 case Opt_sec: 1317 string = match_strdup(args); 1318 if (string == NULL) 1319 goto out_nomem; 1320 rc = nfs_parse_security_flavors(string, mnt); 1321 kfree(string); 1322 if (!rc) { 1323 dfprintk(MOUNT, "NFS: unrecognized " 1324 "security flavor\n"); 1325 return 0; 1326 } 1327 break; 1328 case Opt_proto: 1329 string = match_strdup(args); 1330 if (string == NULL) 1331 goto out_nomem; 1332 token = match_token(string, 1333 nfs_xprt_protocol_tokens, args); 1334 1335 protofamily = AF_INET; 1336 switch (token) { 1337 case Opt_xprt_udp6: 1338 protofamily = AF_INET6; 1339 case Opt_xprt_udp: 1340 mnt->flags &= ~NFS_MOUNT_TCP; 1341 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; 1342 break; 1343 case Opt_xprt_tcp6: 1344 protofamily = AF_INET6; 1345 case Opt_xprt_tcp: 1346 mnt->flags |= NFS_MOUNT_TCP; 1347 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; 1348 break; 1349 case Opt_xprt_rdma: 1350 /* vector side protocols to TCP */ 1351 mnt->flags |= NFS_MOUNT_TCP; 1352 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA; 1353 xprt_load_transport(string); 1354 break; 1355 default: 1356 dfprintk(MOUNT, "NFS: unrecognized " 1357 "transport protocol\n"); 1358 kfree(string); 1359 return 0; 1360 } 1361 kfree(string); 1362 break; 1363 case Opt_mountproto: 1364 string = match_strdup(args); 1365 if (string == NULL) 1366 goto out_nomem; 1367 token = match_token(string, 1368 nfs_xprt_protocol_tokens, args); 1369 kfree(string); 1370 1371 mountfamily = AF_INET; 1372 switch (token) { 1373 case Opt_xprt_udp6: 1374 mountfamily = AF_INET6; 1375 case Opt_xprt_udp: 1376 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP; 1377 break; 1378 case Opt_xprt_tcp6: 1379 mountfamily = AF_INET6; 1380 case Opt_xprt_tcp: 1381 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP; 1382 break; 1383 case Opt_xprt_rdma: /* not used for side protocols */ 1384 default: 1385 dfprintk(MOUNT, "NFS: unrecognized " 1386 "transport protocol\n"); 1387 return 0; 1388 } 1389 break; 1390 case Opt_addr: 1391 string = match_strdup(args); 1392 if (string == NULL) 1393 goto out_nomem; 1394 mnt->nfs_server.addrlen = 1395 rpc_pton(string, strlen(string), 1396 (struct sockaddr *) 1397 &mnt->nfs_server.address, 1398 sizeof(mnt->nfs_server.address)); 1399 kfree(string); 1400 if (mnt->nfs_server.addrlen == 0) 1401 goto out_invalid_address; 1402 break; 1403 case Opt_clientaddr: 1404 if (nfs_get_option_str(args, &mnt->client_address)) 1405 goto out_nomem; 1406 break; 1407 case Opt_mounthost: 1408 if (nfs_get_option_str(args, 1409 &mnt->mount_server.hostname)) 1410 goto out_nomem; 1411 break; 1412 case Opt_mountaddr: 1413 string = match_strdup(args); 1414 if (string == NULL) 1415 goto out_nomem; 1416 mnt->mount_server.addrlen = 1417 rpc_pton(string, strlen(string), 1418 (struct sockaddr *) 1419 &mnt->mount_server.address, 1420 sizeof(mnt->mount_server.address)); 1421 kfree(string); 1422 if (mnt->mount_server.addrlen == 0) 1423 goto out_invalid_address; 1424 break; 1425 case Opt_lookupcache: 1426 string = match_strdup(args); 1427 if (string == NULL) 1428 goto out_nomem; 1429 token = match_token(string, 1430 nfs_lookupcache_tokens, args); 1431 kfree(string); 1432 switch (token) { 1433 case Opt_lookupcache_all: 1434 mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE); 1435 break; 1436 case Opt_lookupcache_positive: 1437 mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE; 1438 mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG; 1439 break; 1440 case Opt_lookupcache_none: 1441 mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE; 1442 break; 1443 default: 1444 dfprintk(MOUNT, "NFS: invalid " 1445 "lookupcache argument\n"); 1446 return 0; 1447 }; 1448 break; 1449 case Opt_fscache_uniq: 1450 if (nfs_get_option_str(args, &mnt->fscache_uniq)) 1451 goto out_nomem; 1452 mnt->options |= NFS_OPTION_FSCACHE; 1453 break; 1454 case Opt_local_lock: 1455 string = match_strdup(args); 1456 if (string == NULL) 1457 goto out_nomem; 1458 token = match_token(string, nfs_local_lock_tokens, 1459 args); 1460 kfree(string); 1461 switch (token) { 1462 case Opt_local_lock_all: 1463 mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK | 1464 NFS_MOUNT_LOCAL_FCNTL); 1465 break; 1466 case Opt_local_lock_flock: 1467 mnt->flags |= NFS_MOUNT_LOCAL_FLOCK; 1468 break; 1469 case Opt_local_lock_posix: 1470 mnt->flags |= NFS_MOUNT_LOCAL_FCNTL; 1471 break; 1472 case Opt_local_lock_none: 1473 mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | 1474 NFS_MOUNT_LOCAL_FCNTL); 1475 break; 1476 default: 1477 dfprintk(MOUNT, "NFS: invalid " 1478 "local_lock argument\n"); 1479 return 0; 1480 }; 1481 break; 1482 1483 /* 1484 * Special options 1485 */ 1486 case Opt_sloppy: 1487 sloppy = 1; 1488 dfprintk(MOUNT, "NFS: relaxing parsing rules\n"); 1489 break; 1490 case Opt_userspace: 1491 case Opt_deprecated: 1492 dfprintk(MOUNT, "NFS: ignoring mount option " 1493 "'%s'\n", p); 1494 break; 1495 1496 default: 1497 invalid_option = 1; 1498 dfprintk(MOUNT, "NFS: unrecognized mount option " 1499 "'%s'\n", p); 1500 } 1501 } 1502 1503 if (!sloppy && invalid_option) 1504 return 0; 1505 1506 /* 1507 * verify that any proto=/mountproto= options match the address 1508 * familiies in the addr=/mountaddr= options. 1509 */ 1510 if (protofamily != AF_UNSPEC && 1511 protofamily != mnt->nfs_server.address.ss_family) 1512 goto out_proto_mismatch; 1513 1514 if (mountfamily != AF_UNSPEC) { 1515 if (mnt->mount_server.addrlen) { 1516 if (mountfamily != mnt->mount_server.address.ss_family) 1517 goto out_mountproto_mismatch; 1518 } else { 1519 if (mountfamily != mnt->nfs_server.address.ss_family) 1520 goto out_mountproto_mismatch; 1521 } 1522 } 1523 1524 return 1; 1525 1526 out_mountproto_mismatch: 1527 printk(KERN_INFO "NFS: mount server address does not match mountproto= " 1528 "option\n"); 1529 return 0; 1530 out_proto_mismatch: 1531 printk(KERN_INFO "NFS: server address does not match proto= option\n"); 1532 return 0; 1533 out_invalid_address: 1534 printk(KERN_INFO "NFS: bad IP address specified: %s\n", p); 1535 return 0; 1536 out_invalid_value: 1537 printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p); 1538 return 0; 1539 out_nomem: 1540 printk(KERN_INFO "NFS: not enough memory to parse option\n"); 1541 return 0; 1542 out_security_failure: 1543 free_secdata(secdata); 1544 printk(KERN_INFO "NFS: security options invalid: %d\n", rc); 1545 return 0; 1546 } 1547 1548 /* 1549 * Match the requested auth flavors with the list returned by 1550 * the server. Returns zero and sets the mount's authentication 1551 * flavor on success; returns -EACCES if server does not support 1552 * the requested flavor. 1553 */ 1554 static int nfs_walk_authlist(struct nfs_parsed_mount_data *args, 1555 struct nfs_mount_request *request) 1556 { 1557 unsigned int i, j, server_authlist_len = *(request->auth_flav_len); 1558 1559 /* 1560 * Certain releases of Linux's mountd return an empty 1561 * flavor list. To prevent behavioral regression with 1562 * these servers (ie. rejecting mounts that used to 1563 * succeed), revert to pre-2.6.32 behavior (no checking) 1564 * if the returned flavor list is empty. 1565 */ 1566 if (server_authlist_len == 0) 1567 return 0; 1568 1569 /* 1570 * We avoid sophisticated negotiating here, as there are 1571 * plenty of cases where we can get it wrong, providing 1572 * either too little or too much security. 1573 * 1574 * RFC 2623, section 2.7 suggests we SHOULD prefer the 1575 * flavor listed first. However, some servers list 1576 * AUTH_NULL first. Our caller plants AUTH_SYS, the 1577 * preferred default, in args->auth_flavors[0] if user 1578 * didn't specify sec= mount option. 1579 */ 1580 for (i = 0; i < args->auth_flavor_len; i++) 1581 for (j = 0; j < server_authlist_len; j++) 1582 if (args->auth_flavors[i] == request->auth_flavs[j]) { 1583 dfprintk(MOUNT, "NFS: using auth flavor %d\n", 1584 request->auth_flavs[j]); 1585 args->auth_flavors[0] = request->auth_flavs[j]; 1586 return 0; 1587 } 1588 1589 dfprintk(MOUNT, "NFS: server does not support requested auth flavor\n"); 1590 nfs_umount(request); 1591 return -EACCES; 1592 } 1593 1594 /* 1595 * Use the remote server's MOUNT service to request the NFS file handle 1596 * corresponding to the provided path. 1597 */ 1598 static int nfs_try_mount(struct nfs_parsed_mount_data *args, 1599 struct nfs_fh *root_fh) 1600 { 1601 rpc_authflavor_t server_authlist[NFS_MAX_SECFLAVORS]; 1602 unsigned int server_authlist_len = ARRAY_SIZE(server_authlist); 1603 struct nfs_mount_request request = { 1604 .sap = (struct sockaddr *) 1605 &args->mount_server.address, 1606 .dirpath = args->nfs_server.export_path, 1607 .protocol = args->mount_server.protocol, 1608 .fh = root_fh, 1609 .noresvport = args->flags & NFS_MOUNT_NORESVPORT, 1610 .auth_flav_len = &server_authlist_len, 1611 .auth_flavs = server_authlist, 1612 }; 1613 int status; 1614 1615 if (args->mount_server.version == 0) { 1616 switch (args->version) { 1617 default: 1618 args->mount_server.version = NFS_MNT3_VERSION; 1619 break; 1620 case 2: 1621 args->mount_server.version = NFS_MNT_VERSION; 1622 } 1623 } 1624 request.version = args->mount_server.version; 1625 1626 if (args->mount_server.hostname) 1627 request.hostname = args->mount_server.hostname; 1628 else 1629 request.hostname = args->nfs_server.hostname; 1630 1631 /* 1632 * Construct the mount server's address. 1633 */ 1634 if (args->mount_server.address.ss_family == AF_UNSPEC) { 1635 memcpy(request.sap, &args->nfs_server.address, 1636 args->nfs_server.addrlen); 1637 args->mount_server.addrlen = args->nfs_server.addrlen; 1638 } 1639 request.salen = args->mount_server.addrlen; 1640 nfs_set_port(request.sap, &args->mount_server.port, 0); 1641 1642 /* 1643 * Now ask the mount server to map our export path 1644 * to a file handle. 1645 */ 1646 status = nfs_mount(&request); 1647 if (status != 0) { 1648 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n", 1649 request.hostname, status); 1650 return status; 1651 } 1652 1653 /* 1654 * MNTv1 (NFSv2) does not support auth flavor negotiation. 1655 */ 1656 if (args->mount_server.version != NFS_MNT3_VERSION) 1657 return 0; 1658 return nfs_walk_authlist(args, &request); 1659 } 1660 1661 /* 1662 * Split "dev_name" into "hostname:export_path". 1663 * 1664 * The leftmost colon demarks the split between the server's hostname 1665 * and the export path. If the hostname starts with a left square 1666 * bracket, then it may contain colons. 1667 * 1668 * Note: caller frees hostname and export path, even on error. 1669 */ 1670 static int nfs_parse_devname(const char *dev_name, 1671 char **hostname, size_t maxnamlen, 1672 char **export_path, size_t maxpathlen) 1673 { 1674 size_t len; 1675 char *end; 1676 1677 /* Is the host name protected with square brakcets? */ 1678 if (*dev_name == '[') { 1679 end = strchr(++dev_name, ']'); 1680 if (end == NULL || end[1] != ':') 1681 goto out_bad_devname; 1682 1683 len = end - dev_name; 1684 end++; 1685 } else { 1686 char *comma; 1687 1688 end = strchr(dev_name, ':'); 1689 if (end == NULL) 1690 goto out_bad_devname; 1691 len = end - dev_name; 1692 1693 /* kill possible hostname list: not supported */ 1694 comma = strchr(dev_name, ','); 1695 if (comma != NULL && comma < end) 1696 *comma = 0; 1697 } 1698 1699 if (len > maxnamlen) 1700 goto out_hostname; 1701 1702 /* N.B. caller will free nfs_server.hostname in all cases */ 1703 *hostname = kstrndup(dev_name, len, GFP_KERNEL); 1704 if (*hostname == NULL) 1705 goto out_nomem; 1706 len = strlen(++end); 1707 if (len > maxpathlen) 1708 goto out_path; 1709 *export_path = kstrndup(end, len, GFP_KERNEL); 1710 if (!*export_path) 1711 goto out_nomem; 1712 1713 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path); 1714 return 0; 1715 1716 out_bad_devname: 1717 dfprintk(MOUNT, "NFS: device name not in host:path format\n"); 1718 return -EINVAL; 1719 1720 out_nomem: 1721 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n"); 1722 return -ENOMEM; 1723 1724 out_hostname: 1725 dfprintk(MOUNT, "NFS: server hostname too long\n"); 1726 return -ENAMETOOLONG; 1727 1728 out_path: 1729 dfprintk(MOUNT, "NFS: export pathname too long\n"); 1730 return -ENAMETOOLONG; 1731 } 1732 1733 /* 1734 * Validate the NFS2/NFS3 mount data 1735 * - fills in the mount root filehandle 1736 * 1737 * For option strings, user space handles the following behaviors: 1738 * 1739 * + DNS: mapping server host name to IP address ("addr=" option) 1740 * 1741 * + failure mode: how to behave if a mount request can't be handled 1742 * immediately ("fg/bg" option) 1743 * 1744 * + retry: how often to retry a mount request ("retry=" option) 1745 * 1746 * + breaking back: trying proto=udp after proto=tcp, v2 after v3, 1747 * mountproto=tcp after mountproto=udp, and so on 1748 */ 1749 static int nfs_validate_mount_data(void *options, 1750 struct nfs_parsed_mount_data *args, 1751 struct nfs_fh *mntfh, 1752 const char *dev_name) 1753 { 1754 struct nfs_mount_data *data = (struct nfs_mount_data *)options; 1755 struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; 1756 1757 if (data == NULL) 1758 goto out_no_data; 1759 1760 switch (data->version) { 1761 case 1: 1762 data->namlen = 0; 1763 case 2: 1764 data->bsize = 0; 1765 case 3: 1766 if (data->flags & NFS_MOUNT_VER3) 1767 goto out_no_v3; 1768 data->root.size = NFS2_FHSIZE; 1769 memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE); 1770 case 4: 1771 if (data->flags & NFS_MOUNT_SECFLAVOUR) 1772 goto out_no_sec; 1773 case 5: 1774 memset(data->context, 0, sizeof(data->context)); 1775 case 6: 1776 if (data->flags & NFS_MOUNT_VER3) { 1777 if (data->root.size > NFS3_FHSIZE || data->root.size == 0) 1778 goto out_invalid_fh; 1779 mntfh->size = data->root.size; 1780 args->version = 3; 1781 } else { 1782 mntfh->size = NFS2_FHSIZE; 1783 args->version = 2; 1784 } 1785 1786 1787 memcpy(mntfh->data, data->root.data, mntfh->size); 1788 if (mntfh->size < sizeof(mntfh->data)) 1789 memset(mntfh->data + mntfh->size, 0, 1790 sizeof(mntfh->data) - mntfh->size); 1791 1792 /* 1793 * Translate to nfs_parsed_mount_data, which nfs_fill_super 1794 * can deal with. 1795 */ 1796 args->flags = data->flags & NFS_MOUNT_FLAGMASK; 1797 args->flags |= NFS_MOUNT_LEGACY_INTERFACE; 1798 args->rsize = data->rsize; 1799 args->wsize = data->wsize; 1800 args->timeo = data->timeo; 1801 args->retrans = data->retrans; 1802 args->acregmin = data->acregmin; 1803 args->acregmax = data->acregmax; 1804 args->acdirmin = data->acdirmin; 1805 args->acdirmax = data->acdirmax; 1806 1807 memcpy(sap, &data->addr, sizeof(data->addr)); 1808 args->nfs_server.addrlen = sizeof(data->addr); 1809 if (!nfs_verify_server_address(sap)) 1810 goto out_no_address; 1811 1812 if (!(data->flags & NFS_MOUNT_TCP)) 1813 args->nfs_server.protocol = XPRT_TRANSPORT_UDP; 1814 /* N.B. caller will free nfs_server.hostname in all cases */ 1815 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL); 1816 args->namlen = data->namlen; 1817 args->bsize = data->bsize; 1818 1819 if (data->flags & NFS_MOUNT_SECFLAVOUR) 1820 args->auth_flavors[0] = data->pseudoflavor; 1821 if (!args->nfs_server.hostname) 1822 goto out_nomem; 1823 1824 if (!(data->flags & NFS_MOUNT_NONLM)) 1825 args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK| 1826 NFS_MOUNT_LOCAL_FCNTL); 1827 else 1828 args->flags |= (NFS_MOUNT_LOCAL_FLOCK| 1829 NFS_MOUNT_LOCAL_FCNTL); 1830 /* 1831 * The legacy version 6 binary mount data from userspace has a 1832 * field used only to transport selinux information into the 1833 * the kernel. To continue to support that functionality we 1834 * have a touch of selinux knowledge here in the NFS code. The 1835 * userspace code converted context=blah to just blah so we are 1836 * converting back to the full string selinux understands. 1837 */ 1838 if (data->context[0]){ 1839 #ifdef CONFIG_SECURITY_SELINUX 1840 int rc; 1841 char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL); 1842 if (!opts_str) 1843 return -ENOMEM; 1844 strcpy(opts_str, "context="); 1845 data->context[NFS_MAX_CONTEXT_LEN] = '\0'; 1846 strcat(opts_str, &data->context[0]); 1847 rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts); 1848 kfree(opts_str); 1849 if (rc) 1850 return rc; 1851 #else 1852 return -EINVAL; 1853 #endif 1854 } 1855 1856 break; 1857 default: { 1858 int status; 1859 1860 if (nfs_parse_mount_options((char *)options, args) == 0) 1861 return -EINVAL; 1862 1863 if (!nfs_verify_server_address(sap)) 1864 goto out_no_address; 1865 1866 if (args->version == 4) 1867 #ifdef CONFIG_NFS_V4 1868 return nfs4_validate_text_mount_data(options, 1869 args, dev_name); 1870 #else 1871 goto out_v4_not_compiled; 1872 #endif 1873 1874 nfs_set_port(sap, &args->nfs_server.port, 0); 1875 1876 nfs_set_mount_transport_protocol(args); 1877 1878 status = nfs_parse_devname(dev_name, 1879 &args->nfs_server.hostname, 1880 PAGE_SIZE, 1881 &args->nfs_server.export_path, 1882 NFS_MAXPATHLEN); 1883 if (!status) 1884 status = nfs_try_mount(args, mntfh); 1885 1886 kfree(args->nfs_server.export_path); 1887 args->nfs_server.export_path = NULL; 1888 1889 if (status) 1890 return status; 1891 1892 break; 1893 } 1894 } 1895 1896 #ifndef CONFIG_NFS_V3 1897 if (args->version == 3) 1898 goto out_v3_not_compiled; 1899 #endif /* !CONFIG_NFS_V3 */ 1900 1901 return 0; 1902 1903 out_no_data: 1904 dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n"); 1905 return -EINVAL; 1906 1907 out_no_v3: 1908 dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n", 1909 data->version); 1910 return -EINVAL; 1911 1912 out_no_sec: 1913 dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n"); 1914 return -EINVAL; 1915 1916 #ifndef CONFIG_NFS_V3 1917 out_v3_not_compiled: 1918 dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n"); 1919 return -EPROTONOSUPPORT; 1920 #endif /* !CONFIG_NFS_V3 */ 1921 1922 #ifndef CONFIG_NFS_V4 1923 out_v4_not_compiled: 1924 dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n"); 1925 return -EPROTONOSUPPORT; 1926 #endif /* !CONFIG_NFS_V4 */ 1927 1928 out_nomem: 1929 dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n"); 1930 return -ENOMEM; 1931 1932 out_no_address: 1933 dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n"); 1934 return -EINVAL; 1935 1936 out_invalid_fh: 1937 dfprintk(MOUNT, "NFS: invalid root filehandle\n"); 1938 return -EINVAL; 1939 } 1940 1941 static int 1942 nfs_compare_remount_data(struct nfs_server *nfss, 1943 struct nfs_parsed_mount_data *data) 1944 { 1945 if (data->flags != nfss->flags || 1946 data->rsize != nfss->rsize || 1947 data->wsize != nfss->wsize || 1948 data->retrans != nfss->client->cl_timeout->to_retries || 1949 data->auth_flavors[0] != nfss->client->cl_auth->au_flavor || 1950 data->acregmin != nfss->acregmin / HZ || 1951 data->acregmax != nfss->acregmax / HZ || 1952 data->acdirmin != nfss->acdirmin / HZ || 1953 data->acdirmax != nfss->acdirmax / HZ || 1954 data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) || 1955 data->nfs_server.port != nfss->port || 1956 data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen || 1957 !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address, 1958 (struct sockaddr *)&nfss->nfs_client->cl_addr)) 1959 return -EINVAL; 1960 1961 return 0; 1962 } 1963 1964 static int 1965 nfs_remount(struct super_block *sb, int *flags, char *raw_data) 1966 { 1967 int error; 1968 struct nfs_server *nfss = sb->s_fs_info; 1969 struct nfs_parsed_mount_data *data; 1970 struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data; 1971 struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data; 1972 u32 nfsvers = nfss->nfs_client->rpc_ops->version; 1973 1974 /* 1975 * Userspace mount programs that send binary options generally send 1976 * them populated with default values. We have no way to know which 1977 * ones were explicitly specified. Fall back to legacy behavior and 1978 * just return success. 1979 */ 1980 if ((nfsvers == 4 && (!options4 || options4->version == 1)) || 1981 (nfsvers <= 3 && (!options || (options->version >= 1 && 1982 options->version <= 6)))) 1983 return 0; 1984 1985 data = kzalloc(sizeof(*data), GFP_KERNEL); 1986 if (data == NULL) 1987 return -ENOMEM; 1988 1989 /* fill out struct with values from existing mount */ 1990 data->flags = nfss->flags; 1991 data->rsize = nfss->rsize; 1992 data->wsize = nfss->wsize; 1993 data->retrans = nfss->client->cl_timeout->to_retries; 1994 data->auth_flavors[0] = nfss->client->cl_auth->au_flavor; 1995 data->acregmin = nfss->acregmin / HZ; 1996 data->acregmax = nfss->acregmax / HZ; 1997 data->acdirmin = nfss->acdirmin / HZ; 1998 data->acdirmax = nfss->acdirmax / HZ; 1999 data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ; 2000 data->nfs_server.port = nfss->port; 2001 data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen; 2002 memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr, 2003 data->nfs_server.addrlen); 2004 2005 /* overwrite those values with any that were specified */ 2006 error = nfs_parse_mount_options((char *)options, data); 2007 if (error < 0) 2008 goto out; 2009 2010 /* 2011 * noac is a special case. It implies -o sync, but that's not 2012 * necessarily reflected in the mtab options. do_remount_sb 2013 * will clear MS_SYNCHRONOUS if -o sync wasn't specified in the 2014 * remount options, so we have to explicitly reset it. 2015 */ 2016 if (data->flags & NFS_MOUNT_NOAC) 2017 *flags |= MS_SYNCHRONOUS; 2018 2019 /* compare new mount options with old ones */ 2020 error = nfs_compare_remount_data(nfss, data); 2021 out: 2022 kfree(data); 2023 return error; 2024 } 2025 2026 /* 2027 * Initialise the common bits of the superblock 2028 */ 2029 static inline void nfs_initialise_sb(struct super_block *sb) 2030 { 2031 struct nfs_server *server = NFS_SB(sb); 2032 2033 sb->s_magic = NFS_SUPER_MAGIC; 2034 2035 /* We probably want something more informative here */ 2036 snprintf(sb->s_id, sizeof(sb->s_id), 2037 "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev)); 2038 2039 if (sb->s_blocksize == 0) 2040 sb->s_blocksize = nfs_block_bits(server->wsize, 2041 &sb->s_blocksize_bits); 2042 2043 sb->s_bdi = &server->backing_dev_info; 2044 2045 nfs_super_set_maxbytes(sb, server->maxfilesize); 2046 } 2047 2048 /* 2049 * Finish setting up an NFS2/3 superblock 2050 */ 2051 static void nfs_fill_super(struct super_block *sb, 2052 struct nfs_parsed_mount_data *data) 2053 { 2054 struct nfs_server *server = NFS_SB(sb); 2055 2056 sb->s_blocksize_bits = 0; 2057 sb->s_blocksize = 0; 2058 if (data->bsize) 2059 sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits); 2060 2061 if (server->nfs_client->rpc_ops->version == 3) { 2062 /* The VFS shouldn't apply the umask to mode bits. We will do 2063 * so ourselves when necessary. 2064 */ 2065 sb->s_flags |= MS_POSIXACL; 2066 sb->s_time_gran = 1; 2067 } 2068 2069 sb->s_op = &nfs_sops; 2070 nfs_initialise_sb(sb); 2071 } 2072 2073 /* 2074 * Finish setting up a cloned NFS2/3 superblock 2075 */ 2076 static void nfs_clone_super(struct super_block *sb, 2077 const struct super_block *old_sb) 2078 { 2079 struct nfs_server *server = NFS_SB(sb); 2080 2081 sb->s_blocksize_bits = old_sb->s_blocksize_bits; 2082 sb->s_blocksize = old_sb->s_blocksize; 2083 sb->s_maxbytes = old_sb->s_maxbytes; 2084 2085 if (server->nfs_client->rpc_ops->version == 3) { 2086 /* The VFS shouldn't apply the umask to mode bits. We will do 2087 * so ourselves when necessary. 2088 */ 2089 sb->s_flags |= MS_POSIXACL; 2090 sb->s_time_gran = 1; 2091 } 2092 2093 sb->s_op = old_sb->s_op; 2094 nfs_initialise_sb(sb); 2095 } 2096 2097 static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags) 2098 { 2099 const struct nfs_server *a = s->s_fs_info; 2100 const struct rpc_clnt *clnt_a = a->client; 2101 const struct rpc_clnt *clnt_b = b->client; 2102 2103 if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK)) 2104 goto Ebusy; 2105 if (a->nfs_client != b->nfs_client) 2106 goto Ebusy; 2107 if (a->flags != b->flags) 2108 goto Ebusy; 2109 if (a->wsize != b->wsize) 2110 goto Ebusy; 2111 if (a->rsize != b->rsize) 2112 goto Ebusy; 2113 if (a->acregmin != b->acregmin) 2114 goto Ebusy; 2115 if (a->acregmax != b->acregmax) 2116 goto Ebusy; 2117 if (a->acdirmin != b->acdirmin) 2118 goto Ebusy; 2119 if (a->acdirmax != b->acdirmax) 2120 goto Ebusy; 2121 if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor) 2122 goto Ebusy; 2123 return 1; 2124 Ebusy: 2125 return 0; 2126 } 2127 2128 struct nfs_sb_mountdata { 2129 struct nfs_server *server; 2130 int mntflags; 2131 }; 2132 2133 static int nfs_set_super(struct super_block *s, void *data) 2134 { 2135 struct nfs_sb_mountdata *sb_mntdata = data; 2136 struct nfs_server *server = sb_mntdata->server; 2137 int ret; 2138 2139 s->s_flags = sb_mntdata->mntflags; 2140 s->s_fs_info = server; 2141 s->s_d_op = server->nfs_client->rpc_ops->dentry_ops; 2142 ret = set_anon_super(s, server); 2143 if (ret == 0) 2144 server->s_dev = s->s_dev; 2145 return ret; 2146 } 2147 2148 static int nfs_compare_super_address(struct nfs_server *server1, 2149 struct nfs_server *server2) 2150 { 2151 struct sockaddr *sap1, *sap2; 2152 2153 sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr; 2154 sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr; 2155 2156 if (sap1->sa_family != sap2->sa_family) 2157 return 0; 2158 2159 switch (sap1->sa_family) { 2160 case AF_INET: { 2161 struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1; 2162 struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2; 2163 if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) 2164 return 0; 2165 if (sin1->sin_port != sin2->sin_port) 2166 return 0; 2167 break; 2168 } 2169 case AF_INET6: { 2170 struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1; 2171 struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2; 2172 if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr)) 2173 return 0; 2174 if (sin1->sin6_port != sin2->sin6_port) 2175 return 0; 2176 break; 2177 } 2178 default: 2179 return 0; 2180 } 2181 2182 return 1; 2183 } 2184 2185 static int nfs_compare_super(struct super_block *sb, void *data) 2186 { 2187 struct nfs_sb_mountdata *sb_mntdata = data; 2188 struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb); 2189 int mntflags = sb_mntdata->mntflags; 2190 2191 if (!nfs_compare_super_address(old, server)) 2192 return 0; 2193 /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */ 2194 if (old->flags & NFS_MOUNT_UNSHARED) 2195 return 0; 2196 if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0) 2197 return 0; 2198 return nfs_compare_mount_options(sb, server, mntflags); 2199 } 2200 2201 static int nfs_bdi_register(struct nfs_server *server) 2202 { 2203 return bdi_register_dev(&server->backing_dev_info, server->s_dev); 2204 } 2205 2206 static struct dentry *nfs_fs_mount(struct file_system_type *fs_type, 2207 int flags, const char *dev_name, void *raw_data) 2208 { 2209 struct nfs_server *server = NULL; 2210 struct super_block *s; 2211 struct nfs_parsed_mount_data *data; 2212 struct nfs_fh *mntfh; 2213 struct dentry *mntroot = ERR_PTR(-ENOMEM); 2214 int (*compare_super)(struct super_block *, void *) = nfs_compare_super; 2215 struct nfs_sb_mountdata sb_mntdata = { 2216 .mntflags = flags, 2217 }; 2218 int error; 2219 2220 data = nfs_alloc_parsed_mount_data(NFS_DEFAULT_VERSION); 2221 mntfh = nfs_alloc_fhandle(); 2222 if (data == NULL || mntfh == NULL) 2223 goto out_free_fh; 2224 2225 security_init_mnt_opts(&data->lsm_opts); 2226 2227 /* Validate the mount data */ 2228 error = nfs_validate_mount_data(raw_data, data, mntfh, dev_name); 2229 if (error < 0) { 2230 mntroot = ERR_PTR(error); 2231 goto out; 2232 } 2233 2234 #ifdef CONFIG_NFS_V4 2235 if (data->version == 4) { 2236 mntroot = nfs4_try_mount(flags, dev_name, data); 2237 kfree(data->client_address); 2238 kfree(data->nfs_server.export_path); 2239 goto out; 2240 } 2241 #endif /* CONFIG_NFS_V4 */ 2242 2243 /* Get a volume representation */ 2244 server = nfs_create_server(data, mntfh); 2245 if (IS_ERR(server)) { 2246 mntroot = ERR_CAST(server); 2247 goto out; 2248 } 2249 sb_mntdata.server = server; 2250 2251 if (server->flags & NFS_MOUNT_UNSHARED) 2252 compare_super = NULL; 2253 2254 /* -o noac implies -o sync */ 2255 if (server->flags & NFS_MOUNT_NOAC) 2256 sb_mntdata.mntflags |= MS_SYNCHRONOUS; 2257 2258 /* Get a superblock - note that we may end up sharing one that already exists */ 2259 s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata); 2260 if (IS_ERR(s)) { 2261 mntroot = ERR_CAST(s); 2262 goto out_err_nosb; 2263 } 2264 2265 if (s->s_fs_info != server) { 2266 nfs_free_server(server); 2267 server = NULL; 2268 } else { 2269 error = nfs_bdi_register(server); 2270 if (error) { 2271 mntroot = ERR_PTR(error); 2272 goto error_splat_bdi; 2273 } 2274 } 2275 2276 if (!s->s_root) { 2277 /* initial superblock/root creation */ 2278 nfs_fill_super(s, data); 2279 nfs_fscache_get_super_cookie(s, data->fscache_uniq, NULL); 2280 } 2281 2282 mntroot = nfs_get_root(s, mntfh, dev_name); 2283 if (IS_ERR(mntroot)) 2284 goto error_splat_super; 2285 2286 error = security_sb_set_mnt_opts(s, &data->lsm_opts); 2287 if (error) 2288 goto error_splat_root; 2289 2290 s->s_flags |= MS_ACTIVE; 2291 2292 out: 2293 kfree(data->nfs_server.hostname); 2294 kfree(data->mount_server.hostname); 2295 kfree(data->fscache_uniq); 2296 security_free_mnt_opts(&data->lsm_opts); 2297 out_free_fh: 2298 nfs_free_fhandle(mntfh); 2299 kfree(data); 2300 return mntroot; 2301 2302 out_err_nosb: 2303 nfs_free_server(server); 2304 goto out; 2305 2306 error_splat_root: 2307 dput(mntroot); 2308 mntroot = ERR_PTR(error); 2309 error_splat_super: 2310 if (server && !s->s_root) 2311 bdi_unregister(&server->backing_dev_info); 2312 error_splat_bdi: 2313 deactivate_locked_super(s); 2314 goto out; 2315 } 2316 2317 /* 2318 * Ensure that we unregister the bdi before kill_anon_super 2319 * releases the device name 2320 */ 2321 static void nfs_put_super(struct super_block *s) 2322 { 2323 struct nfs_server *server = NFS_SB(s); 2324 2325 bdi_unregister(&server->backing_dev_info); 2326 } 2327 2328 /* 2329 * Destroy an NFS2/3 superblock 2330 */ 2331 static void nfs_kill_super(struct super_block *s) 2332 { 2333 struct nfs_server *server = NFS_SB(s); 2334 2335 kill_anon_super(s); 2336 nfs_fscache_release_super_cookie(s); 2337 nfs_free_server(server); 2338 } 2339 2340 /* 2341 * Clone an NFS2/3 server record on xdev traversal (FSID-change) 2342 */ 2343 static struct dentry * 2344 nfs_xdev_mount(struct file_system_type *fs_type, int flags, 2345 const char *dev_name, void *raw_data) 2346 { 2347 struct nfs_clone_mount *data = raw_data; 2348 struct super_block *s; 2349 struct nfs_server *server; 2350 struct dentry *mntroot; 2351 int (*compare_super)(struct super_block *, void *) = nfs_compare_super; 2352 struct nfs_sb_mountdata sb_mntdata = { 2353 .mntflags = flags, 2354 }; 2355 int error; 2356 2357 dprintk("--> nfs_xdev_mount()\n"); 2358 2359 /* create a new volume representation */ 2360 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr); 2361 if (IS_ERR(server)) { 2362 error = PTR_ERR(server); 2363 goto out_err_noserver; 2364 } 2365 sb_mntdata.server = server; 2366 2367 if (server->flags & NFS_MOUNT_UNSHARED) 2368 compare_super = NULL; 2369 2370 /* -o noac implies -o sync */ 2371 if (server->flags & NFS_MOUNT_NOAC) 2372 sb_mntdata.mntflags |= MS_SYNCHRONOUS; 2373 2374 /* Get a superblock - note that we may end up sharing one that already exists */ 2375 s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata); 2376 if (IS_ERR(s)) { 2377 error = PTR_ERR(s); 2378 goto out_err_nosb; 2379 } 2380 2381 if (s->s_fs_info != server) { 2382 nfs_free_server(server); 2383 server = NULL; 2384 } else { 2385 error = nfs_bdi_register(server); 2386 if (error) 2387 goto error_splat_bdi; 2388 } 2389 2390 if (!s->s_root) { 2391 /* initial superblock/root creation */ 2392 nfs_clone_super(s, data->sb); 2393 nfs_fscache_get_super_cookie(s, NULL, data); 2394 } 2395 2396 mntroot = nfs_get_root(s, data->fh, dev_name); 2397 if (IS_ERR(mntroot)) { 2398 error = PTR_ERR(mntroot); 2399 goto error_splat_super; 2400 } 2401 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) { 2402 dput(mntroot); 2403 error = -ESTALE; 2404 goto error_splat_super; 2405 } 2406 2407 s->s_flags |= MS_ACTIVE; 2408 2409 /* clone any lsm security options from the parent to the new sb */ 2410 security_sb_clone_mnt_opts(data->sb, s); 2411 2412 dprintk("<-- nfs_xdev_mount() = 0\n"); 2413 return mntroot; 2414 2415 out_err_nosb: 2416 nfs_free_server(server); 2417 out_err_noserver: 2418 dprintk("<-- nfs_xdev_mount() = %d [error]\n", error); 2419 return ERR_PTR(error); 2420 2421 error_splat_super: 2422 if (server && !s->s_root) 2423 bdi_unregister(&server->backing_dev_info); 2424 error_splat_bdi: 2425 deactivate_locked_super(s); 2426 dprintk("<-- nfs_xdev_mount() = %d [splat]\n", error); 2427 return ERR_PTR(error); 2428 } 2429 2430 #ifdef CONFIG_NFS_V4 2431 2432 /* 2433 * Finish setting up a cloned NFS4 superblock 2434 */ 2435 static void nfs4_clone_super(struct super_block *sb, 2436 const struct super_block *old_sb) 2437 { 2438 sb->s_blocksize_bits = old_sb->s_blocksize_bits; 2439 sb->s_blocksize = old_sb->s_blocksize; 2440 sb->s_maxbytes = old_sb->s_maxbytes; 2441 sb->s_time_gran = 1; 2442 sb->s_op = old_sb->s_op; 2443 /* 2444 * The VFS shouldn't apply the umask to mode bits. We will do 2445 * so ourselves when necessary. 2446 */ 2447 sb->s_flags |= MS_POSIXACL; 2448 sb->s_xattr = old_sb->s_xattr; 2449 nfs_initialise_sb(sb); 2450 } 2451 2452 /* 2453 * Set up an NFS4 superblock 2454 */ 2455 static void nfs4_fill_super(struct super_block *sb) 2456 { 2457 sb->s_time_gran = 1; 2458 sb->s_op = &nfs4_sops; 2459 /* 2460 * The VFS shouldn't apply the umask to mode bits. We will do 2461 * so ourselves when necessary. 2462 */ 2463 sb->s_flags |= MS_POSIXACL; 2464 sb->s_xattr = nfs4_xattr_handlers; 2465 nfs_initialise_sb(sb); 2466 } 2467 2468 static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args) 2469 { 2470 args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3| 2471 NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL); 2472 } 2473 2474 static int nfs4_validate_text_mount_data(void *options, 2475 struct nfs_parsed_mount_data *args, 2476 const char *dev_name) 2477 { 2478 struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; 2479 2480 nfs_set_port(sap, &args->nfs_server.port, NFS_PORT); 2481 2482 nfs_validate_transport_protocol(args); 2483 2484 nfs4_validate_mount_flags(args); 2485 2486 if (args->version != 4) { 2487 dfprintk(MOUNT, 2488 "NFS4: Illegal mount version\n"); 2489 return -EINVAL; 2490 } 2491 2492 if (args->auth_flavor_len > 1) { 2493 dfprintk(MOUNT, 2494 "NFS4: Too many RPC auth flavours specified\n"); 2495 return -EINVAL; 2496 } 2497 2498 if (args->client_address == NULL) { 2499 dfprintk(MOUNT, 2500 "NFS4: mount program didn't pass callback address\n"); 2501 return -EINVAL; 2502 } 2503 2504 return nfs_parse_devname(dev_name, 2505 &args->nfs_server.hostname, 2506 NFS4_MAXNAMLEN, 2507 &args->nfs_server.export_path, 2508 NFS4_MAXPATHLEN); 2509 } 2510 2511 /* 2512 * Validate NFSv4 mount options 2513 */ 2514 static int nfs4_validate_mount_data(void *options, 2515 struct nfs_parsed_mount_data *args, 2516 const char *dev_name) 2517 { 2518 struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; 2519 struct nfs4_mount_data *data = (struct nfs4_mount_data *)options; 2520 char *c; 2521 2522 if (data == NULL) 2523 goto out_no_data; 2524 2525 switch (data->version) { 2526 case 1: 2527 if (data->host_addrlen > sizeof(args->nfs_server.address)) 2528 goto out_no_address; 2529 if (data->host_addrlen == 0) 2530 goto out_no_address; 2531 args->nfs_server.addrlen = data->host_addrlen; 2532 if (copy_from_user(sap, data->host_addr, data->host_addrlen)) 2533 return -EFAULT; 2534 if (!nfs_verify_server_address(sap)) 2535 goto out_no_address; 2536 2537 if (data->auth_flavourlen) { 2538 if (data->auth_flavourlen > 1) 2539 goto out_inval_auth; 2540 if (copy_from_user(&args->auth_flavors[0], 2541 data->auth_flavours, 2542 sizeof(args->auth_flavors[0]))) 2543 return -EFAULT; 2544 } 2545 2546 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN); 2547 if (IS_ERR(c)) 2548 return PTR_ERR(c); 2549 args->nfs_server.hostname = c; 2550 2551 c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN); 2552 if (IS_ERR(c)) 2553 return PTR_ERR(c); 2554 args->nfs_server.export_path = c; 2555 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c); 2556 2557 c = strndup_user(data->client_addr.data, 16); 2558 if (IS_ERR(c)) 2559 return PTR_ERR(c); 2560 args->client_address = c; 2561 2562 /* 2563 * Translate to nfs_parsed_mount_data, which nfs4_fill_super 2564 * can deal with. 2565 */ 2566 2567 args->flags = data->flags & NFS4_MOUNT_FLAGMASK; 2568 args->rsize = data->rsize; 2569 args->wsize = data->wsize; 2570 args->timeo = data->timeo; 2571 args->retrans = data->retrans; 2572 args->acregmin = data->acregmin; 2573 args->acregmax = data->acregmax; 2574 args->acdirmin = data->acdirmin; 2575 args->acdirmax = data->acdirmax; 2576 args->nfs_server.protocol = data->proto; 2577 nfs_validate_transport_protocol(args); 2578 2579 break; 2580 default: 2581 if (nfs_parse_mount_options((char *)options, args) == 0) 2582 return -EINVAL; 2583 2584 if (!nfs_verify_server_address(sap)) 2585 return -EINVAL; 2586 2587 return nfs4_validate_text_mount_data(options, args, dev_name); 2588 } 2589 2590 return 0; 2591 2592 out_no_data: 2593 dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n"); 2594 return -EINVAL; 2595 2596 out_inval_auth: 2597 dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n", 2598 data->auth_flavourlen); 2599 return -EINVAL; 2600 2601 out_no_address: 2602 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n"); 2603 return -EINVAL; 2604 } 2605 2606 /* 2607 * Get the superblock for the NFS4 root partition 2608 */ 2609 static struct dentry * 2610 nfs4_remote_mount(struct file_system_type *fs_type, int flags, 2611 const char *dev_name, void *raw_data) 2612 { 2613 struct nfs_parsed_mount_data *data = raw_data; 2614 struct super_block *s; 2615 struct nfs_server *server; 2616 struct nfs_fh *mntfh; 2617 struct dentry *mntroot; 2618 int (*compare_super)(struct super_block *, void *) = nfs_compare_super; 2619 struct nfs_sb_mountdata sb_mntdata = { 2620 .mntflags = flags, 2621 }; 2622 int error = -ENOMEM; 2623 2624 mntfh = nfs_alloc_fhandle(); 2625 if (data == NULL || mntfh == NULL) 2626 goto out_free_fh; 2627 2628 security_init_mnt_opts(&data->lsm_opts); 2629 2630 /* Get a volume representation */ 2631 server = nfs4_create_server(data, mntfh); 2632 if (IS_ERR(server)) { 2633 error = PTR_ERR(server); 2634 goto out; 2635 } 2636 sb_mntdata.server = server; 2637 2638 if (server->flags & NFS4_MOUNT_UNSHARED) 2639 compare_super = NULL; 2640 2641 /* -o noac implies -o sync */ 2642 if (server->flags & NFS_MOUNT_NOAC) 2643 sb_mntdata.mntflags |= MS_SYNCHRONOUS; 2644 2645 /* Get a superblock - note that we may end up sharing one that already exists */ 2646 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata); 2647 if (IS_ERR(s)) { 2648 error = PTR_ERR(s); 2649 goto out_free; 2650 } 2651 2652 if (s->s_fs_info != server) { 2653 nfs_free_server(server); 2654 server = NULL; 2655 } else { 2656 error = nfs_bdi_register(server); 2657 if (error) 2658 goto error_splat_bdi; 2659 } 2660 2661 if (!s->s_root) { 2662 /* initial superblock/root creation */ 2663 nfs4_fill_super(s); 2664 nfs_fscache_get_super_cookie( 2665 s, data ? data->fscache_uniq : NULL, NULL); 2666 } 2667 2668 mntroot = nfs4_get_root(s, mntfh, dev_name); 2669 if (IS_ERR(mntroot)) { 2670 error = PTR_ERR(mntroot); 2671 goto error_splat_super; 2672 } 2673 2674 error = security_sb_set_mnt_opts(s, &data->lsm_opts); 2675 if (error) 2676 goto error_splat_root; 2677 2678 s->s_flags |= MS_ACTIVE; 2679 2680 security_free_mnt_opts(&data->lsm_opts); 2681 nfs_free_fhandle(mntfh); 2682 return mntroot; 2683 2684 out: 2685 security_free_mnt_opts(&data->lsm_opts); 2686 out_free_fh: 2687 nfs_free_fhandle(mntfh); 2688 return ERR_PTR(error); 2689 2690 out_free: 2691 nfs_free_server(server); 2692 goto out; 2693 2694 error_splat_root: 2695 dput(mntroot); 2696 error_splat_super: 2697 if (server && !s->s_root) 2698 bdi_unregister(&server->backing_dev_info); 2699 error_splat_bdi: 2700 deactivate_locked_super(s); 2701 goto out; 2702 } 2703 2704 static struct vfsmount *nfs_do_root_mount(struct file_system_type *fs_type, 2705 int flags, void *data, const char *hostname) 2706 { 2707 struct vfsmount *root_mnt; 2708 char *root_devname; 2709 size_t len; 2710 2711 len = strlen(hostname) + 3; 2712 root_devname = kmalloc(len, GFP_KERNEL); 2713 if (root_devname == NULL) 2714 return ERR_PTR(-ENOMEM); 2715 snprintf(root_devname, len, "%s:/", hostname); 2716 root_mnt = vfs_kern_mount(fs_type, flags, root_devname, data); 2717 kfree(root_devname); 2718 return root_mnt; 2719 } 2720 2721 struct nfs_referral_count { 2722 struct list_head list; 2723 const struct task_struct *task; 2724 unsigned int referral_count; 2725 }; 2726 2727 static LIST_HEAD(nfs_referral_count_list); 2728 static DEFINE_SPINLOCK(nfs_referral_count_list_lock); 2729 2730 static struct nfs_referral_count *nfs_find_referral_count(void) 2731 { 2732 struct nfs_referral_count *p; 2733 2734 list_for_each_entry(p, &nfs_referral_count_list, list) { 2735 if (p->task == current) 2736 return p; 2737 } 2738 return NULL; 2739 } 2740 2741 #define NFS_MAX_NESTED_REFERRALS 2 2742 2743 static int nfs_referral_loop_protect(void) 2744 { 2745 struct nfs_referral_count *p, *new; 2746 int ret = -ENOMEM; 2747 2748 new = kmalloc(sizeof(*new), GFP_KERNEL); 2749 if (!new) 2750 goto out; 2751 new->task = current; 2752 new->referral_count = 1; 2753 2754 ret = 0; 2755 spin_lock(&nfs_referral_count_list_lock); 2756 p = nfs_find_referral_count(); 2757 if (p != NULL) { 2758 if (p->referral_count >= NFS_MAX_NESTED_REFERRALS) 2759 ret = -ELOOP; 2760 else 2761 p->referral_count++; 2762 } else { 2763 list_add(&new->list, &nfs_referral_count_list); 2764 new = NULL; 2765 } 2766 spin_unlock(&nfs_referral_count_list_lock); 2767 kfree(new); 2768 out: 2769 return ret; 2770 } 2771 2772 static void nfs_referral_loop_unprotect(void) 2773 { 2774 struct nfs_referral_count *p; 2775 2776 spin_lock(&nfs_referral_count_list_lock); 2777 p = nfs_find_referral_count(); 2778 p->referral_count--; 2779 if (p->referral_count == 0) 2780 list_del(&p->list); 2781 else 2782 p = NULL; 2783 spin_unlock(&nfs_referral_count_list_lock); 2784 kfree(p); 2785 } 2786 2787 static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt, 2788 const char *export_path) 2789 { 2790 struct mnt_namespace *ns_private; 2791 struct super_block *s; 2792 struct dentry *dentry; 2793 struct path path; 2794 int ret; 2795 2796 ns_private = create_mnt_ns(root_mnt); 2797 ret = PTR_ERR(ns_private); 2798 if (IS_ERR(ns_private)) 2799 goto out_mntput; 2800 2801 ret = nfs_referral_loop_protect(); 2802 if (ret != 0) 2803 goto out_put_mnt_ns; 2804 2805 ret = vfs_path_lookup(root_mnt->mnt_root, root_mnt, 2806 export_path, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path); 2807 2808 nfs_referral_loop_unprotect(); 2809 put_mnt_ns(ns_private); 2810 2811 if (ret != 0) 2812 goto out_err; 2813 2814 s = path.mnt->mnt_sb; 2815 atomic_inc(&s->s_active); 2816 dentry = dget(path.dentry); 2817 2818 path_put(&path); 2819 down_write(&s->s_umount); 2820 return dentry; 2821 out_put_mnt_ns: 2822 put_mnt_ns(ns_private); 2823 out_mntput: 2824 mntput(root_mnt); 2825 out_err: 2826 return ERR_PTR(ret); 2827 } 2828 2829 static struct dentry *nfs4_try_mount(int flags, const char *dev_name, 2830 struct nfs_parsed_mount_data *data) 2831 { 2832 char *export_path; 2833 struct vfsmount *root_mnt; 2834 struct dentry *res; 2835 2836 dfprintk(MOUNT, "--> nfs4_try_mount()\n"); 2837 2838 export_path = data->nfs_server.export_path; 2839 data->nfs_server.export_path = "/"; 2840 root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, data, 2841 data->nfs_server.hostname); 2842 data->nfs_server.export_path = export_path; 2843 2844 res = ERR_CAST(root_mnt); 2845 if (!IS_ERR(root_mnt)) 2846 res = nfs_follow_remote_path(root_mnt, export_path); 2847 2848 dfprintk(MOUNT, "<-- nfs4_try_mount() = %ld%s\n", 2849 IS_ERR(res) ? PTR_ERR(res) : 0, 2850 IS_ERR(res) ? " [error]" : ""); 2851 return res; 2852 } 2853 2854 /* 2855 * Get the superblock for an NFS4 mountpoint 2856 */ 2857 static struct dentry *nfs4_mount(struct file_system_type *fs_type, 2858 int flags, const char *dev_name, void *raw_data) 2859 { 2860 struct nfs_parsed_mount_data *data; 2861 int error = -ENOMEM; 2862 struct dentry *res = ERR_PTR(-ENOMEM); 2863 2864 data = nfs_alloc_parsed_mount_data(4); 2865 if (data == NULL) 2866 goto out_free_data; 2867 2868 /* Validate the mount data */ 2869 error = nfs4_validate_mount_data(raw_data, data, dev_name); 2870 if (error < 0) { 2871 res = ERR_PTR(error); 2872 goto out; 2873 } 2874 2875 res = nfs4_try_mount(flags, dev_name, data); 2876 if (IS_ERR(res)) 2877 error = PTR_ERR(res); 2878 2879 out: 2880 kfree(data->client_address); 2881 kfree(data->nfs_server.export_path); 2882 kfree(data->nfs_server.hostname); 2883 kfree(data->fscache_uniq); 2884 out_free_data: 2885 kfree(data); 2886 dprintk("<-- nfs4_mount() = %d%s\n", error, 2887 error != 0 ? " [error]" : ""); 2888 return res; 2889 } 2890 2891 static void nfs4_kill_super(struct super_block *sb) 2892 { 2893 struct nfs_server *server = NFS_SB(sb); 2894 2895 dprintk("--> %s\n", __func__); 2896 nfs_super_return_all_delegations(sb); 2897 kill_anon_super(sb); 2898 nfs_fscache_release_super_cookie(sb); 2899 nfs_free_server(server); 2900 dprintk("<-- %s\n", __func__); 2901 } 2902 2903 /* 2904 * Clone an NFS4 server record on xdev traversal (FSID-change) 2905 */ 2906 static struct dentry * 2907 nfs4_xdev_mount(struct file_system_type *fs_type, int flags, 2908 const char *dev_name, void *raw_data) 2909 { 2910 struct nfs_clone_mount *data = raw_data; 2911 struct super_block *s; 2912 struct nfs_server *server; 2913 struct dentry *mntroot; 2914 int (*compare_super)(struct super_block *, void *) = nfs_compare_super; 2915 struct nfs_sb_mountdata sb_mntdata = { 2916 .mntflags = flags, 2917 }; 2918 int error; 2919 2920 dprintk("--> nfs4_xdev_mount()\n"); 2921 2922 /* create a new volume representation */ 2923 server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr); 2924 if (IS_ERR(server)) { 2925 error = PTR_ERR(server); 2926 goto out_err_noserver; 2927 } 2928 sb_mntdata.server = server; 2929 2930 if (server->flags & NFS4_MOUNT_UNSHARED) 2931 compare_super = NULL; 2932 2933 /* -o noac implies -o sync */ 2934 if (server->flags & NFS_MOUNT_NOAC) 2935 sb_mntdata.mntflags |= MS_SYNCHRONOUS; 2936 2937 /* Get a superblock - note that we may end up sharing one that already exists */ 2938 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata); 2939 if (IS_ERR(s)) { 2940 error = PTR_ERR(s); 2941 goto out_err_nosb; 2942 } 2943 2944 if (s->s_fs_info != server) { 2945 nfs_free_server(server); 2946 server = NULL; 2947 } else { 2948 error = nfs_bdi_register(server); 2949 if (error) 2950 goto error_splat_bdi; 2951 } 2952 2953 if (!s->s_root) { 2954 /* initial superblock/root creation */ 2955 nfs4_clone_super(s, data->sb); 2956 nfs_fscache_get_super_cookie(s, NULL, data); 2957 } 2958 2959 mntroot = nfs4_get_root(s, data->fh, dev_name); 2960 if (IS_ERR(mntroot)) { 2961 error = PTR_ERR(mntroot); 2962 goto error_splat_super; 2963 } 2964 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) { 2965 dput(mntroot); 2966 error = -ESTALE; 2967 goto error_splat_super; 2968 } 2969 2970 s->s_flags |= MS_ACTIVE; 2971 2972 security_sb_clone_mnt_opts(data->sb, s); 2973 2974 dprintk("<-- nfs4_xdev_mount() = 0\n"); 2975 return mntroot; 2976 2977 out_err_nosb: 2978 nfs_free_server(server); 2979 out_err_noserver: 2980 dprintk("<-- nfs4_xdev_mount() = %d [error]\n", error); 2981 return ERR_PTR(error); 2982 2983 error_splat_super: 2984 if (server && !s->s_root) 2985 bdi_unregister(&server->backing_dev_info); 2986 error_splat_bdi: 2987 deactivate_locked_super(s); 2988 dprintk("<-- nfs4_xdev_mount() = %d [splat]\n", error); 2989 return ERR_PTR(error); 2990 } 2991 2992 static struct dentry * 2993 nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags, 2994 const char *dev_name, void *raw_data) 2995 { 2996 struct nfs_clone_mount *data = raw_data; 2997 struct super_block *s; 2998 struct nfs_server *server; 2999 struct dentry *mntroot; 3000 struct nfs_fh *mntfh; 3001 int (*compare_super)(struct super_block *, void *) = nfs_compare_super; 3002 struct nfs_sb_mountdata sb_mntdata = { 3003 .mntflags = flags, 3004 }; 3005 int error = -ENOMEM; 3006 3007 dprintk("--> nfs4_referral_get_sb()\n"); 3008 3009 mntfh = nfs_alloc_fhandle(); 3010 if (mntfh == NULL) 3011 goto out_err_nofh; 3012 3013 /* create a new volume representation */ 3014 server = nfs4_create_referral_server(data, mntfh); 3015 if (IS_ERR(server)) { 3016 error = PTR_ERR(server); 3017 goto out_err_noserver; 3018 } 3019 sb_mntdata.server = server; 3020 3021 if (server->flags & NFS4_MOUNT_UNSHARED) 3022 compare_super = NULL; 3023 3024 /* -o noac implies -o sync */ 3025 if (server->flags & NFS_MOUNT_NOAC) 3026 sb_mntdata.mntflags |= MS_SYNCHRONOUS; 3027 3028 /* Get a superblock - note that we may end up sharing one that already exists */ 3029 s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata); 3030 if (IS_ERR(s)) { 3031 error = PTR_ERR(s); 3032 goto out_err_nosb; 3033 } 3034 3035 if (s->s_fs_info != server) { 3036 nfs_free_server(server); 3037 server = NULL; 3038 } else { 3039 error = nfs_bdi_register(server); 3040 if (error) 3041 goto error_splat_bdi; 3042 } 3043 3044 if (!s->s_root) { 3045 /* initial superblock/root creation */ 3046 nfs4_fill_super(s); 3047 nfs_fscache_get_super_cookie(s, NULL, data); 3048 } 3049 3050 mntroot = nfs4_get_root(s, mntfh, dev_name); 3051 if (IS_ERR(mntroot)) { 3052 error = PTR_ERR(mntroot); 3053 goto error_splat_super; 3054 } 3055 if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) { 3056 dput(mntroot); 3057 error = -ESTALE; 3058 goto error_splat_super; 3059 } 3060 3061 s->s_flags |= MS_ACTIVE; 3062 3063 security_sb_clone_mnt_opts(data->sb, s); 3064 3065 nfs_free_fhandle(mntfh); 3066 dprintk("<-- nfs4_referral_get_sb() = 0\n"); 3067 return mntroot; 3068 3069 out_err_nosb: 3070 nfs_free_server(server); 3071 out_err_noserver: 3072 nfs_free_fhandle(mntfh); 3073 out_err_nofh: 3074 dprintk("<-- nfs4_referral_get_sb() = %d [error]\n", error); 3075 return ERR_PTR(error); 3076 3077 error_splat_super: 3078 if (server && !s->s_root) 3079 bdi_unregister(&server->backing_dev_info); 3080 error_splat_bdi: 3081 deactivate_locked_super(s); 3082 nfs_free_fhandle(mntfh); 3083 dprintk("<-- nfs4_referral_get_sb() = %d [splat]\n", error); 3084 return ERR_PTR(error); 3085 } 3086 3087 /* 3088 * Create an NFS4 server record on referral traversal 3089 */ 3090 static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type, 3091 int flags, const char *dev_name, void *raw_data) 3092 { 3093 struct nfs_clone_mount *data = raw_data; 3094 char *export_path; 3095 struct vfsmount *root_mnt; 3096 struct dentry *res; 3097 3098 dprintk("--> nfs4_referral_mount()\n"); 3099 3100 export_path = data->mnt_path; 3101 data->mnt_path = "/"; 3102 3103 root_mnt = nfs_do_root_mount(&nfs4_remote_referral_fs_type, 3104 flags, data, data->hostname); 3105 data->mnt_path = export_path; 3106 3107 res = ERR_CAST(root_mnt); 3108 if (!IS_ERR(root_mnt)) 3109 res = nfs_follow_remote_path(root_mnt, export_path); 3110 dprintk("<-- nfs4_referral_mount() = %ld%s\n", 3111 IS_ERR(res) ? PTR_ERR(res) : 0, 3112 IS_ERR(res) ? " [error]" : ""); 3113 return res; 3114 } 3115 3116 #endif /* CONFIG_NFS_V4 */ 3117