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