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