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