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