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