Pileus Git - ~andy/linux/blob - fs/nfs/super.c

   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/seq_file.h>
  43 #include <linux/mount.h>
  44 #include <linux/namei.h>
  45 #include <linux/nfs_idmap.h>
  46 #include <linux/vfs.h>
  47 #include <linux/inet.h>
  48 #include <linux/in6.h>
  49 #include <linux/slab.h>
  50 #include <net/ipv6.h>
  51 #include <linux/netdevice.h>
  52 #include <linux/nfs_xdr.h>
  53 #include <linux/magic.h>
  54 #include <linux/parser.h>
  55 #include <linux/nsproxy.h>
  56 #include <linux/rcupdate.h>
  57
  58 #include <asm/system.h>
  59 #include <asm/uaccess.h>
  60
  61 #include "nfs4_fs.h"
  62 #include "callback.h"
  63 #include "delegation.h"
  64 #include "iostat.h"
  65 #include "internal.h"
  66 #include "fscache.h"
  67 #include "pnfs.h"
  68
  69 #define NFSDBG_FACILITY         NFSDBG_VFS
  70
  71 #ifdef CONFIG_NFS_V3
  72 #define NFS_DEFAULT_VERSION 3
  73 #else
  74 #define NFS_DEFAULT_VERSION 2
  75 #endif
  76
  77 enum {
  78         /* Mount options that take no arguments */
  79         Opt_soft, Opt_hard,
  80         Opt_posix, Opt_noposix,
  81         Opt_cto, Opt_nocto,
  82         Opt_ac, Opt_noac,
  83         Opt_lock, Opt_nolock,
  84         Opt_udp, Opt_tcp, Opt_rdma,
  85         Opt_acl, Opt_noacl,
  86         Opt_rdirplus, Opt_nordirplus,
  87         Opt_sharecache, Opt_nosharecache,
  88         Opt_resvport, Opt_noresvport,
  89         Opt_fscache, Opt_nofscache,
  90
  91         /* Mount options that take integer arguments */
  92         Opt_port,
  93         Opt_rsize, Opt_wsize, Opt_bsize,
  94         Opt_timeo, Opt_retrans,
  95         Opt_acregmin, Opt_acregmax,
  96         Opt_acdirmin, Opt_acdirmax,
  97         Opt_actimeo,
  98         Opt_namelen,
  99         Opt_mountport,
 100         Opt_mountvers,
 101         Opt_minorversion,
 102
 103         /* Mount options that take string arguments */
 104         Opt_nfsvers,
 105         Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
 106         Opt_addr, Opt_mountaddr, Opt_clientaddr,
 107         Opt_lookupcache,
 108         Opt_fscache_uniq,
 109         Opt_local_lock,
 110
 111         /* Special mount options */
 112         Opt_userspace, Opt_deprecated, Opt_sloppy,
 113
 114         Opt_err
 115 };
 116
 117 static const match_table_t nfs_mount_option_tokens = {
 118         { Opt_userspace, "bg" },
 119         { Opt_userspace, "fg" },
 120         { Opt_userspace, "retry=%s" },
 121
 122         { Opt_sloppy, "sloppy" },
 123
 124         { Opt_soft, "soft" },
 125         { Opt_hard, "hard" },
 126         { Opt_deprecated, "intr" },
 127         { Opt_deprecated, "nointr" },
 128         { Opt_posix, "posix" },
 129         { Opt_noposix, "noposix" },
 130         { Opt_cto, "cto" },
 131         { Opt_nocto, "nocto" },
 132         { Opt_ac, "ac" },
 133         { Opt_noac, "noac" },
 134         { Opt_lock, "lock" },
 135         { Opt_nolock, "nolock" },
 136         { Opt_udp, "udp" },
 137         { Opt_tcp, "tcp" },
 138         { Opt_rdma, "rdma" },
 139         { Opt_acl, "acl" },
 140         { Opt_noacl, "noacl" },
 141         { Opt_rdirplus, "rdirplus" },
 142         { Opt_nordirplus, "nordirplus" },
 143         { Opt_sharecache, "sharecache" },
 144         { Opt_nosharecache, "nosharecache" },
 145         { Opt_resvport, "resvport" },
 146         { Opt_noresvport, "noresvport" },
 147         { Opt_fscache, "fsc" },
 148         { Opt_nofscache, "nofsc" },
 149
 150         { Opt_port, "port=%s" },
 151         { Opt_rsize, "rsize=%s" },
 152         { Opt_wsize, "wsize=%s" },
 153         { Opt_bsize, "bsize=%s" },
 154         { Opt_timeo, "timeo=%s" },
 155         { Opt_retrans, "retrans=%s" },
 156         { Opt_acregmin, "acregmin=%s" },
 157         { Opt_acregmax, "acregmax=%s" },
 158         { Opt_acdirmin, "acdirmin=%s" },
 159         { Opt_acdirmax, "acdirmax=%s" },
 160         { Opt_actimeo, "actimeo=%s" },
 161         { Opt_namelen, "namlen=%s" },
 162         { Opt_mountport, "mountport=%s" },
 163         { Opt_mountvers, "mountvers=%s" },
 164         { Opt_minorversion, "minorversion=%s" },
 165
 166         { Opt_nfsvers, "nfsvers=%s" },
 167         { Opt_nfsvers, "vers=%s" },
 168
 169         { Opt_sec, "sec=%s" },
 170         { Opt_proto, "proto=%s" },
 171         { Opt_mountproto, "mountproto=%s" },
 172         { Opt_addr, "addr=%s" },
 173         { Opt_clientaddr, "clientaddr=%s" },
 174         { Opt_mounthost, "mounthost=%s" },
 175         { Opt_mountaddr, "mountaddr=%s" },
 176
 177         { Opt_lookupcache, "lookupcache=%s" },
 178         { Opt_fscache_uniq, "fsc=%s" },
 179         { Opt_local_lock, "local_lock=%s" },
 180
 181         /* The following needs to be listed after all other options */
 182         { Opt_nfsvers, "v%s" },
 183
 184         { Opt_err, NULL }
 185 };
 186
 187 enum {
 188         Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
 189
 190         Opt_xprt_err
 191 };
 192
 193 static const match_table_t nfs_xprt_protocol_tokens = {
 194         { Opt_xprt_udp, "udp" },
 195         { Opt_xprt_udp6, "udp6" },
 196         { Opt_xprt_tcp, "tcp" },
 197         { Opt_xprt_tcp6, "tcp6" },
 198         { Opt_xprt_rdma, "rdma" },
 199
 200         { Opt_xprt_err, NULL }
 201 };
 202
 203 enum {
 204         Opt_sec_none, Opt_sec_sys,
 205         Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 206         Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
 207         Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
 208
 209         Opt_sec_err
 210 };
 211
 212 static const match_table_t nfs_secflavor_tokens = {
 213         { Opt_sec_none, "none" },
 214         { Opt_sec_none, "null" },
 215         { Opt_sec_sys, "sys" },
 216
 217         { Opt_sec_krb5, "krb5" },
 218         { Opt_sec_krb5i, "krb5i" },
 219         { Opt_sec_krb5p, "krb5p" },
 220
 221         { Opt_sec_lkey, "lkey" },
 222         { Opt_sec_lkeyi, "lkeyi" },
 223         { Opt_sec_lkeyp, "lkeyp" },
 224
 225         { Opt_sec_spkm, "spkm3" },
 226         { Opt_sec_spkmi, "spkm3i" },
 227         { Opt_sec_spkmp, "spkm3p" },
 228
 229         { Opt_sec_err, NULL }
 230 };
 231
 232 enum {
 233         Opt_lookupcache_all, Opt_lookupcache_positive,
 234         Opt_lookupcache_none,
 235
 236         Opt_lookupcache_err
 237 };
 238
 239 static match_table_t nfs_lookupcache_tokens = {
 240         { Opt_lookupcache_all, "all" },
 241         { Opt_lookupcache_positive, "pos" },
 242         { Opt_lookupcache_positive, "positive" },
 243         { Opt_lookupcache_none, "none" },
 244
 245         { Opt_lookupcache_err, NULL }
 246 };
 247
 248 enum {
 249         Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
 250         Opt_local_lock_none,
 251
 252         Opt_local_lock_err
 253 };
 254
 255 static match_table_t nfs_local_lock_tokens = {
 256         { Opt_local_lock_all, "all" },
 257         { Opt_local_lock_flock, "flock" },
 258         { Opt_local_lock_posix, "posix" },
 259         { Opt_local_lock_none, "none" },
 260
 261         { Opt_local_lock_err, NULL }
 262 };
 263
 264 enum {
 265         Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
 266         Opt_vers_4_1,
 267
 268         Opt_vers_err
 269 };
 270
 271 static match_table_t nfs_vers_tokens = {
 272         { Opt_vers_2, "2" },
 273         { Opt_vers_3, "3" },
 274         { Opt_vers_4, "4" },
 275         { Opt_vers_4_0, "4.0" },
 276         { Opt_vers_4_1, "4.1" },
 277
 278         { Opt_vers_err, NULL }
 279 };
 280
 281 static void nfs_umount_begin(struct super_block *);
 282 static int  nfs_statfs(struct dentry *, struct kstatfs *);
 283 static int  nfs_show_options(struct seq_file *, struct dentry *);
 284 static int  nfs_show_devname(struct seq_file *, struct dentry *);
 285 static int  nfs_show_path(struct seq_file *, struct dentry *);
 286 static int  nfs_show_stats(struct seq_file *, struct dentry *);
 287 static struct dentry *nfs_fs_mount(struct file_system_type *,
 288                 int, const char *, void *);
 289 static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
 290                 int flags, const char *dev_name, void *raw_data);
 291 static void nfs_put_super(struct super_block *);
 292 static void nfs_kill_super(struct super_block *);
 293 static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
 294
 295 static struct file_system_type nfs_fs_type = {
 296         .owner          = THIS_MODULE,
 297         .name           = "nfs",
 298         .mount          = nfs_fs_mount,
 299         .kill_sb        = nfs_kill_super,
 300         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 301 };
 302
 303 struct file_system_type nfs_xdev_fs_type = {
 304         .owner          = THIS_MODULE,
 305         .name           = "nfs",
 306         .mount          = nfs_xdev_mount,
 307         .kill_sb        = nfs_kill_super,
 308         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 309 };
 310
 311 static const struct super_operations nfs_sops = {
 312         .alloc_inode    = nfs_alloc_inode,
 313         .destroy_inode  = nfs_destroy_inode,
 314         .write_inode    = nfs_write_inode,
 315         .put_super      = nfs_put_super,
 316         .statfs         = nfs_statfs,
 317         .evict_inode    = nfs_evict_inode,
 318         .umount_begin   = nfs_umount_begin,
 319         .show_options   = nfs_show_options,
 320         .show_devname   = nfs_show_devname,
 321         .show_path      = nfs_show_path,
 322         .show_stats     = nfs_show_stats,
 323         .remount_fs     = nfs_remount,
 324 };
 325
 326 #ifdef CONFIG_NFS_V4
 327 static int nfs4_validate_text_mount_data(void *options,
 328         struct nfs_parsed_mount_data *args, const char *dev_name);
 329 static struct dentry *nfs4_try_mount(int flags, const char *dev_name,
 330         struct nfs_parsed_mount_data *data);
 331 static struct dentry *nfs4_mount(struct file_system_type *fs_type,
 332         int flags, const char *dev_name, void *raw_data);
 333 static struct dentry *nfs4_remote_mount(struct file_system_type *fs_type,
 334         int flags, const char *dev_name, void *raw_data);
 335 static struct dentry *nfs4_xdev_mount(struct file_system_type *fs_type,
 336         int flags, const char *dev_name, void *raw_data);
 337 static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
 338         int flags, const char *dev_name, void *raw_data);
 339 static struct dentry *nfs4_remote_referral_mount(struct file_system_type *fs_type,
 340         int flags, const char *dev_name, void *raw_data);
 341 static void nfs4_kill_super(struct super_block *sb);
 342
 343 static struct file_system_type nfs4_fs_type = {
 344         .owner          = THIS_MODULE,
 345         .name           = "nfs4",
 346         .mount          = nfs4_mount,
 347         .kill_sb        = nfs4_kill_super,
 348         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 349 };
 350
 351 static struct file_system_type nfs4_remote_fs_type = {
 352         .owner          = THIS_MODULE,
 353         .name           = "nfs4",
 354         .mount          = nfs4_remote_mount,
 355         .kill_sb        = nfs4_kill_super,
 356         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 357 };
 358
 359 struct file_system_type nfs4_xdev_fs_type = {
 360         .owner          = THIS_MODULE,
 361         .name           = "nfs4",
 362         .mount          = nfs4_xdev_mount,
 363         .kill_sb        = nfs4_kill_super,
 364         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 365 };
 366
 367 static struct file_system_type nfs4_remote_referral_fs_type = {
 368         .owner          = THIS_MODULE,
 369         .name           = "nfs4",
 370         .mount          = nfs4_remote_referral_mount,
 371         .kill_sb        = nfs4_kill_super,
 372         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 373 };
 374
 375 struct file_system_type nfs4_referral_fs_type = {
 376         .owner          = THIS_MODULE,
 377         .name           = "nfs4",
 378         .mount          = nfs4_referral_mount,
 379         .kill_sb        = nfs4_kill_super,
 380         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
 381 };
 382
 383 static const struct super_operations nfs4_sops = {
 384         .alloc_inode    = nfs_alloc_inode,
 385         .destroy_inode  = nfs_destroy_inode,
 386         .write_inode    = nfs_write_inode,
 387         .put_super      = nfs_put_super,
 388         .statfs         = nfs_statfs,
 389         .evict_inode    = nfs4_evict_inode,
 390         .umount_begin   = nfs_umount_begin,
 391         .show_options   = nfs_show_options,
 392         .show_devname   = nfs_show_devname,
 393         .show_path      = nfs_show_path,
 394         .show_stats     = nfs_show_stats,
 395         .remount_fs     = nfs_remount,
 396 };
 397 #endif
 398
 399 static struct shrinker acl_shrinker = {
 400         .shrink         = nfs_access_cache_shrinker,
 401         .seeks          = DEFAULT_SEEKS,
 402 };
 403
 404 /*
 405  * Register the NFS filesystems
 406  */
 407 int __init register_nfs_fs(void)
 408 {
 409         int ret;
 410
 411         ret = register_filesystem(&nfs_fs_type);
 412         if (ret < 0)
 413                 goto error_0;
 414
 415         ret = nfs_register_sysctl();
 416         if (ret < 0)
 417                 goto error_1;
 418 #ifdef CONFIG_NFS_V4
 419         ret = register_filesystem(&nfs4_fs_type);
 420         if (ret < 0)
 421                 goto error_2;
 422 #endif
 423         register_shrinker(&acl_shrinker);
 424         return 0;
 425
 426 #ifdef CONFIG_NFS_V4
 427 error_2:
 428         nfs_unregister_sysctl();
 429 #endif
 430 error_1:
 431         unregister_filesystem(&nfs_fs_type);
 432 error_0:
 433         return ret;
 434 }
 435
 436 /*
 437  * Unregister the NFS filesystems
 438  */
 439 void __exit unregister_nfs_fs(void)
 440 {
 441         unregister_shrinker(&acl_shrinker);
 442 #ifdef CONFIG_NFS_V4
 443         unregister_filesystem(&nfs4_fs_type);
 444 #endif
 445         nfs_unregister_sysctl();
 446         unregister_filesystem(&nfs_fs_type);
 447 }
 448
 449 void nfs_sb_active(struct super_block *sb)
 450 {
 451         struct nfs_server *server = NFS_SB(sb);
 452
 453         if (atomic_inc_return(&server->active) == 1)
 454                 atomic_inc(&sb->s_active);
 455 }
 456
 457 void nfs_sb_deactive(struct super_block *sb)
 458 {
 459         struct nfs_server *server = NFS_SB(sb);
 460
 461         if (atomic_dec_and_test(&server->active))
 462                 deactivate_super(sb);
 463 }
 464
 465 /*
 466  * Deliver file system statistics to userspace
 467  */
 468 static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 469 {
 470         struct nfs_server *server = NFS_SB(dentry->d_sb);
 471         unsigned char blockbits;
 472         unsigned long blockres;
 473         struct nfs_fh *fh = NFS_FH(dentry->d_inode);
 474         struct nfs_fsstat res;
 475         int error = -ENOMEM;
 476
 477         res.fattr = nfs_alloc_fattr();
 478         if (res.fattr == NULL)
 479                 goto out_err;
 480
 481         error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
 482         if (unlikely(error == -ESTALE)) {
 483                 struct dentry *pd_dentry;
 484
 485                 pd_dentry = dget_parent(dentry);
 486                 if (pd_dentry != NULL) {
 487                         nfs_zap_caches(pd_dentry->d_inode);
 488                         dput(pd_dentry);
 489                 }
 490         }
 491         nfs_free_fattr(res.fattr);
 492         if (error < 0)
 493                 goto out_err;
 494
 495         buf->f_type = NFS_SUPER_MAGIC;
 496
 497         /*
 498          * Current versions of glibc do not correctly handle the
 499          * case where f_frsize != f_bsize.  Eventually we want to
 500          * report the value of wtmult in this field.
 501          */
 502         buf->f_frsize = dentry->d_sb->s_blocksize;
 503
 504         /*
 505          * On most *nix systems, f_blocks, f_bfree, and f_bavail
 506          * are reported in units of f_frsize.  Linux hasn't had
 507          * an f_frsize field in its statfs struct until recently,
 508          * thus historically Linux's sys_statfs reports these
 509          * fields in units of f_bsize.
 510          */
 511         buf->f_bsize = dentry->d_sb->s_blocksize;
 512         blockbits = dentry->d_sb->s_blocksize_bits;
 513         blockres = (1 << blockbits) - 1;
 514         buf->f_blocks = (res.tbytes + blockres) >> blockbits;
 515         buf->f_bfree = (res.fbytes + blockres) >> blockbits;
 516         buf->f_bavail = (res.abytes + blockres) >> blockbits;
 517
 518         buf->f_files = res.tfiles;
 519         buf->f_ffree = res.afiles;
 520
 521         buf->f_namelen = server->namelen;
 522
 523         return 0;
 524
 525  out_err:
 526         dprintk("%s: statfs error = %d\n", __func__, -error);
 527         return error;
 528 }
 529
 530 /*
 531  * Map the security flavour number to a name
 532  */
 533 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
 534 {
 535         static const struct {
 536                 rpc_authflavor_t flavour;
 537                 const char *str;
 538         } sec_flavours[] = {
 539                 { RPC_AUTH_NULL, "null" },
 540                 { RPC_AUTH_UNIX, "sys" },
 541                 { RPC_AUTH_GSS_KRB5, "krb5" },
 542                 { RPC_AUTH_GSS_KRB5I, "krb5i" },
 543                 { RPC_AUTH_GSS_KRB5P, "krb5p" },
 544                 { RPC_AUTH_GSS_LKEY, "lkey" },
 545                 { RPC_AUTH_GSS_LKEYI, "lkeyi" },
 546                 { RPC_AUTH_GSS_LKEYP, "lkeyp" },
 547                 { RPC_AUTH_GSS_SPKM, "spkm" },
 548                 { RPC_AUTH_GSS_SPKMI, "spkmi" },
 549                 { RPC_AUTH_GSS_SPKMP, "spkmp" },
 550                 { UINT_MAX, "unknown" }
 551         };
 552         int i;
 553
 554         for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
 555                 if (sec_flavours[i].flavour == flavour)
 556                         break;
 557         }
 558         return sec_flavours[i].str;
 559 }
 560
 561 static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss,
 562                                   int showdefaults)
 563 {
 564         struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address;
 565
 566         seq_printf(m, ",mountproto=");
 567         switch (sap->sa_family) {
 568         case AF_INET:
 569                 switch (nfss->mountd_protocol) {
 570                 case IPPROTO_UDP:
 571                         seq_printf(m, RPCBIND_NETID_UDP);
 572                         break;
 573                 case IPPROTO_TCP:
 574                         seq_printf(m, RPCBIND_NETID_TCP);
 575                         break;
 576                 default:
 577                         if (showdefaults)
 578                                 seq_printf(m, "auto");
 579                 }
 580                 break;
 581         case AF_INET6:
 582                 switch (nfss->mountd_protocol) {
 583                 case IPPROTO_UDP:
 584                         seq_printf(m, RPCBIND_NETID_UDP6);
 585                         break;
 586                 case IPPROTO_TCP:
 587                         seq_printf(m, RPCBIND_NETID_TCP6);
 588                         break;
 589                 default:
 590                         if (showdefaults)
 591                                 seq_printf(m, "auto");
 592                 }
 593                 break;
 594         default:
 595                 if (showdefaults)
 596                         seq_printf(m, "auto");
 597         }
 598 }
 599
 600 static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
 601                                     int showdefaults)
 602 {
 603         struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;
 604
 605         if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE)
 606                 return;
 607
 608         switch (sap->sa_family) {
 609         case AF_INET: {
 610                 struct sockaddr_in *sin = (struct sockaddr_in *)sap;
 611                 seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr);
 612                 break;
 613         }
 614         case AF_INET6: {
 615                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
 616                 seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr);
 617                 break;
 618         }
 619         default:
 620                 if (showdefaults)
 621                         seq_printf(m, ",mountaddr=unspecified");
 622         }
 623
 624         if (nfss->mountd_version || showdefaults)
 625                 seq_printf(m, ",mountvers=%u", nfss->mountd_version);
 626         if ((nfss->mountd_port &&
 627                 nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) ||
 628                 showdefaults)
 629                 seq_printf(m, ",mountport=%u", nfss->mountd_port);
 630
 631         nfs_show_mountd_netid(m, nfss, showdefaults);
 632 }
 633
 634 #ifdef CONFIG_NFS_V4
 635 static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
 636                                     int showdefaults)
 637 {
 638         struct nfs_client *clp = nfss->nfs_client;
 639
 640         seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
 641 }
 642 #else
 643 static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
 644                                     int showdefaults)
 645 {
 646 }
 647 #endif
 648
 649 static void nfs_show_nfs_version(struct seq_file *m,
 650                 unsigned int version,
 651                 unsigned int minorversion)
 652 {
 653         seq_printf(m, ",vers=%u", version);
 654         if (version == 4)
 655                 seq_printf(m, ".%u", minorversion);
 656 }
 657
 658 /*
 659  * Describe the mount options in force on this server representation
 660  */
 661 static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
 662                                    int showdefaults)
 663 {
 664         static const struct proc_nfs_info {
 665                 int flag;
 666                 const char *str;
 667                 const char *nostr;
 668         } nfs_info[] = {
 669                 { NFS_MOUNT_SOFT, ",soft", ",hard" },
 670                 { NFS_MOUNT_POSIX, ",posix", "" },
 671                 { NFS_MOUNT_NOCTO, ",nocto", "" },
 672                 { NFS_MOUNT_NOAC, ",noac", "" },
 673                 { NFS_MOUNT_NONLM, ",nolock", "" },
 674                 { NFS_MOUNT_NOACL, ",noacl", "" },
 675                 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
 676                 { NFS_MOUNT_UNSHARED, ",nosharecache", "" },
 677                 { NFS_MOUNT_NORESVPORT, ",noresvport", "" },
 678                 { 0, NULL, NULL }
 679         };
 680         const struct proc_nfs_info *nfs_infop;
 681         struct nfs_client *clp = nfss->nfs_client;
 682         u32 version = clp->rpc_ops->version;
 683         int local_flock, local_fcntl;
 684
 685         nfs_show_nfs_version(m, version, clp->cl_minorversion);
 686         seq_printf(m, ",rsize=%u", nfss->rsize);
 687         seq_printf(m, ",wsize=%u", nfss->wsize);
 688         if (nfss->bsize != 0)
 689                 seq_printf(m, ",bsize=%u", nfss->bsize);
 690         seq_printf(m, ",namlen=%u", nfss->namelen);
 691         if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
 692                 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
 693         if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
 694                 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
 695         if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
 696                 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
 697         if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
 698                 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
 699         for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
 700                 if (nfss->flags & nfs_infop->flag)
 701                         seq_puts(m, nfs_infop->str);
 702                 else
 703                         seq_puts(m, nfs_infop->nostr);
 704         }
 705         rcu_read_lock();
 706         seq_printf(m, ",proto=%s",
 707                    rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
 708         rcu_read_unlock();
 709         if (version == 4) {
 710                 if (nfss->port != NFS_PORT)
 711                         seq_printf(m, ",port=%u", nfss->port);
 712         } else
 713                 if (nfss->port)
 714                         seq_printf(m, ",port=%u", nfss->port);
 715
 716         seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
 717         seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
 718         seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
 719
 720         if (version != 4)
 721                 nfs_show_mountd_options(m, nfss, showdefaults);
 722         else
 723                 nfs_show_nfsv4_options(m, nfss, showdefaults);
 724
 725         if (nfss->options & NFS_OPTION_FSCACHE)
 726                 seq_printf(m, ",fsc");
 727
 728         if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
 729                 if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
 730                         seq_printf(m, ",lookupcache=none");
 731                 else
 732                         seq_printf(m, ",lookupcache=pos");
 733         }
 734
 735         local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
 736         local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;
 737
 738         if (!local_flock && !local_fcntl)
 739                 seq_printf(m, ",local_lock=none");
 740         else if (local_flock && local_fcntl)
 741                 seq_printf(m, ",local_lock=all");
 742         else if (local_flock)
 743                 seq_printf(m, ",local_lock=flock");
 744         else
 745                 seq_printf(m, ",local_lock=posix");
 746 }
 747
 748 /*
 749  * Describe the mount options on this VFS mountpoint
 750  */
 751 static int nfs_show_options(struct seq_file *m, struct dentry *root)
 752 {
 753         struct nfs_server *nfss = NFS_SB(root->d_sb);
 754
 755         nfs_show_mount_options(m, nfss, 0);
 756
 757         rcu_read_lock();
 758         seq_printf(m, ",addr=%s",
 759                         rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
 760                                                         RPC_DISPLAY_ADDR));
 761         rcu_read_unlock();
 762
 763         return 0;
 764 }
 765
 766 #ifdef CONFIG_NFS_V4
 767 #ifdef CONFIG_NFS_V4_1
 768 static void show_sessions(struct seq_file *m, struct nfs_server *server)
 769 {
 770         if (nfs4_has_session(server->nfs_client))
 771                 seq_printf(m, ",sessions");
 772 }
 773 #else
 774 static void show_sessions(struct seq_file *m, struct nfs_server *server) {}
 775 #endif
 776 #endif
 777
 778 #ifdef CONFIG_NFS_V4
 779 #ifdef CONFIG_NFS_V4_1
 780 static void show_pnfs(struct seq_file *m, struct nfs_server *server)
 781 {
 782         seq_printf(m, ",pnfs=");
 783         if (server->pnfs_curr_ld)
 784                 seq_printf(m, "%s", server->pnfs_curr_ld->name);
 785         else
 786                 seq_printf(m, "not configured");
 787 }
 788 #else
 789 static void show_pnfs(struct seq_file *m, struct nfs_server *server) {}
 790 #endif
 791 #endif
 792
 793 static int nfs_show_devname(struct seq_file *m, struct dentry *root)
 794 {
 795         char *page = (char *) __get_free_page(GFP_KERNEL);
 796         char *devname, *dummy;
 797         int err = 0;
 798         if (!page)
 799                 return -ENOMEM;
 800         devname = nfs_path(&dummy, root, page, PAGE_SIZE);
 801         if (IS_ERR(devname))
 802                 err = PTR_ERR(devname);
 803         else
 804                 seq_escape(m, devname, " \t\n\\");
 805         free_page((unsigned long)page);
 806         return err;
 807 }
 808
 809 static int nfs_show_path(struct seq_file *m, struct dentry *dentry)
 810 {
 811         seq_puts(m, "/");
 812         return 0;
 813 }
 814
 815 /*
 816  * Present statistical information for this VFS mountpoint
 817  */
 818 static int nfs_show_stats(struct seq_file *m, struct dentry *root)
 819 {
 820         int i, cpu;
 821         struct nfs_server *nfss = NFS_SB(root->d_sb);
 822         struct rpc_auth *auth = nfss->client->cl_auth;
 823         struct nfs_iostats totals = { };
 824
 825         seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
 826
 827         /*
 828          * Display all mount option settings
 829          */
 830         seq_printf(m, "\n\topts:\t");
 831         seq_puts(m, root->d_sb->s_flags & MS_RDONLY ? "ro" : "rw");
 832         seq_puts(m, root->d_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
 833         seq_puts(m, root->d_sb->s_flags & MS_NOATIME ? ",noatime" : "");
 834         seq_puts(m, root->d_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
 835         nfs_show_mount_options(m, nfss, 1);
 836
 837         seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
 838
 839         if (nfss->nfs_client && nfss->nfs_client->impl_id) {
 840                 struct nfs41_impl_id *impl_id = nfss->nfs_client->impl_id;
 841                 seq_printf(m, "\n\timpl_id:\tname='%s',domain='%s',"
 842                            "date='%llu,%u'",
 843                            impl_id->name, impl_id->domain,
 844                            impl_id->date.seconds, impl_id->date.nseconds);
 845         }
 846
 847         seq_printf(m, "\n\tcaps:\t");
 848         seq_printf(m, "caps=0x%x", nfss->caps);
 849         seq_printf(m, ",wtmult=%u", nfss->wtmult);
 850         seq_printf(m, ",dtsize=%u", nfss->dtsize);
 851         seq_printf(m, ",bsize=%u", nfss->bsize);
 852         seq_printf(m, ",namlen=%u", nfss->namelen);
 853
 854 #ifdef CONFIG_NFS_V4
 855         if (nfss->nfs_client->rpc_ops->version == 4) {
 856                 seq_printf(m, "\n\tnfsv4:\t");
 857                 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
 858                 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
 859                 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
 860                 show_sessions(m, nfss);
 861                 show_pnfs(m, nfss);
 862         }
 863 #endif
 864
 865         /*
 866          * Display security flavor in effect for this mount
 867          */
 868         seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
 869         if (auth->au_flavor)
 870                 seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
 871
 872         /*
 873          * Display superblock I/O counters
 874          */
 875         for_each_possible_cpu(cpu) {
 876                 struct nfs_iostats *stats;
 877
 878                 preempt_disable();
 879                 stats = per_cpu_ptr(nfss->io_stats, cpu);
 880
 881                 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
 882                         totals.events[i] += stats->events[i];
 883                 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
 884                         totals.bytes[i] += stats->bytes[i];
 885 #ifdef CONFIG_NFS_FSCACHE
 886                 for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
 887                         totals.fscache[i] += stats->fscache[i];
 888 #endif
 889
 890                 preempt_enable();
 891         }
 892
 893         seq_printf(m, "\n\tevents:\t");
 894         for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
 895                 seq_printf(m, "%lu ", totals.events[i]);
 896         seq_printf(m, "\n\tbytes:\t");
 897         for (i = 0; i < __NFSIOS_BYTESMAX; i++)
 898                 seq_printf(m, "%Lu ", totals.bytes[i]);
 899 #ifdef CONFIG_NFS_FSCACHE
 900         if (nfss->options & NFS_OPTION_FSCACHE) {
 901                 seq_printf(m, "\n\tfsc:\t");
 902                 for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
 903                         seq_printf(m, "%Lu ", totals.bytes[i]);
 904         }
 905 #endif
 906         seq_printf(m, "\n");
 907
 908         rpc_print_iostats(m, nfss->client);
 909
 910         return 0;
 911 }
 912
 913 /*
 914  * Begin unmount by attempting to remove all automounted mountpoints we added
 915  * in response to xdev traversals and referrals
 916  */
 917 static void nfs_umount_begin(struct super_block *sb)
 918 {
 919         struct nfs_server *server;
 920         struct rpc_clnt *rpc;
 921
 922         server = NFS_SB(sb);
 923         /* -EIO all pending I/O */
 924         rpc = server->client_acl;
 925         if (!IS_ERR(rpc))
 926                 rpc_killall_tasks(rpc);
 927         rpc = server->client;
 928         if (!IS_ERR(rpc))
 929                 rpc_killall_tasks(rpc);
 930 }
 931
 932 static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(unsigned int version)
 933 {
 934         struct nfs_parsed_mount_data *data;
 935
 936         data = kzalloc(sizeof(*data), GFP_KERNEL);
 937         if (data) {
 938                 data->acregmin          = NFS_DEF_ACREGMIN;
 939                 data->acregmax          = NFS_DEF_ACREGMAX;
 940                 data->acdirmin          = NFS_DEF_ACDIRMIN;
 941                 data->acdirmax          = NFS_DEF_ACDIRMAX;
 942                 data->mount_server.port = NFS_UNSPEC_PORT;
 943                 data->nfs_server.port   = NFS_UNSPEC_PORT;
 944                 data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
 945                 data->auth_flavors[0]   = RPC_AUTH_UNIX;
 946                 data->auth_flavor_len   = 1;
 947                 data->version           = version;
 948                 data->minorversion      = 0;
 949                 data->net               = current->nsproxy->net_ns;
 950                 security_init_mnt_opts(&data->lsm_opts);
 951         }
 952         return data;
 953 }
 954
 955 static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
 956 {
 957         if (data) {
 958                 kfree(data->client_address);
 959                 kfree(data->mount_server.hostname);
 960                 kfree(data->nfs_server.export_path);
 961                 kfree(data->nfs_server.hostname);
 962                 kfree(data->fscache_uniq);
 963                 security_free_mnt_opts(&data->lsm_opts);
 964                 kfree(data);
 965         }
 966 }
 967
 968 /*
 969  * Sanity-check a server address provided by the mount command.
 970  *
 971  * Address family must be initialized, and address must not be
 972  * the ANY address for that family.
 973  */
 974 static int nfs_verify_server_address(struct sockaddr *addr)
 975 {
 976         switch (addr->sa_family) {
 977         case AF_INET: {
 978                 struct sockaddr_in *sa = (struct sockaddr_in *)addr;
 979                 return sa->sin_addr.s_addr != htonl(INADDR_ANY);
 980         }
 981         case AF_INET6: {
 982                 struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
 983                 return !ipv6_addr_any(sa);
 984         }
 985         }
 986
 987         dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
 988         return 0;
 989 }
 990
 991 /*
 992  * Select between a default port value and a user-specified port value.
 993  * If a zero value is set, then autobind will be used.
 994  */
 995 static void nfs_set_port(struct sockaddr *sap, int *port,
 996                                  const unsigned short default_port)
 997 {
 998         if (*port == NFS_UNSPEC_PORT)
 999                 *port = default_port;
1000
1001         rpc_set_port(sap, *port);
1002 }
1003
1004 /*
1005  * Sanity check the NFS transport protocol.
1006  *
1007  */
1008 static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
1009 {
1010         switch (mnt->nfs_server.protocol) {
1011         case XPRT_TRANSPORT_UDP:
1012         case XPRT_TRANSPORT_TCP:
1013         case XPRT_TRANSPORT_RDMA:
1014                 break;
1015         default:
1016                 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1017         }
1018 }
1019
1020 /*
1021  * For text based NFSv2/v3 mounts, the mount protocol transport default
1022  * settings should depend upon the specified NFS transport.
1023  */
1024 static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
1025 {
1026         nfs_validate_transport_protocol(mnt);
1027
1028         if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
1029             mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
1030                         return;
1031         switch (mnt->nfs_server.protocol) {
1032         case XPRT_TRANSPORT_UDP:
1033                 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1034                 break;
1035         case XPRT_TRANSPORT_TCP:
1036         case XPRT_TRANSPORT_RDMA:
1037                 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1038         }
1039 }
1040
1041 /*
1042  * Parse the value of the 'sec=' option.
1043  */
1044 static int nfs_parse_security_flavors(char *value,
1045                                       struct nfs_parsed_mount_data *mnt)
1046 {
1047         substring_t args[MAX_OPT_ARGS];
1048
1049         dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
1050
1051         switch (match_token(value, nfs_secflavor_tokens, args)) {
1052         case Opt_sec_none:
1053                 mnt->auth_flavors[0] = RPC_AUTH_NULL;
1054                 break;
1055         case Opt_sec_sys:
1056                 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
1057                 break;
1058         case Opt_sec_krb5:
1059                 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
1060                 break;
1061         case Opt_sec_krb5i:
1062                 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
1063                 break;
1064         case Opt_sec_krb5p:
1065                 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
1066                 break;
1067         case Opt_sec_lkey:
1068                 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
1069                 break;
1070         case Opt_sec_lkeyi:
1071                 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
1072                 break;
1073         case Opt_sec_lkeyp:
1074                 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
1075                 break;
1076         case Opt_sec_spkm:
1077                 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
1078                 break;
1079         case Opt_sec_spkmi:
1080                 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
1081                 break;
1082         case Opt_sec_spkmp:
1083                 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
1084                 break;
1085         default:
1086                 return 0;
1087         }
1088
1089         mnt->flags |= NFS_MOUNT_SECFLAVOUR;
1090         mnt->auth_flavor_len = 1;
1091         return 1;
1092 }
1093
1094 static int nfs_parse_version_string(char *string,
1095                 struct nfs_parsed_mount_data *mnt,
1096                 substring_t *args)
1097 {
1098         mnt->flags &= ~NFS_MOUNT_VER3;
1099         switch (match_token(string, nfs_vers_tokens, args)) {
1100         case Opt_vers_2:
1101                 mnt->version = 2;
1102                 break;
1103         case Opt_vers_3:
1104                 mnt->flags |= NFS_MOUNT_VER3;
1105                 mnt->version = 3;
1106                 break;
1107         case Opt_vers_4:
1108                 /* Backward compatibility option. In future,
1109                  * the mount program should always supply
1110                  * a NFSv4 minor version number.
1111                  */
1112                 mnt->version = 4;
1113                 break;
1114         case Opt_vers_4_0:
1115                 mnt->version = 4;
1116                 mnt->minorversion = 0;
1117                 break;
1118         case Opt_vers_4_1:
1119                 mnt->version = 4;
1120                 mnt->minorversion = 1;
1121                 break;
1122         default:
1123                 return 0;
1124         }
1125         return 1;
1126 }
1127
1128 static int nfs_get_option_str(substring_t args[], char **option)
1129 {
1130         kfree(*option);
1131         *option = match_strdup(args);
1132         return !option;
1133 }
1134
1135 static int nfs_get_option_ul(substring_t args[], unsigned long *option)
1136 {
1137         int rc;
1138         char *string;
1139
1140         string = match_strdup(args);
1141         if (string == NULL)
1142                 return -ENOMEM;
1143         rc = strict_strtoul(string, 10, option);
1144         kfree(string);
1145
1146         return rc;
1147 }
1148
1149 /*
1150  * Error-check and convert a string of mount options from user space into
1151  * a data structure.  The whole mount string is processed; bad options are
1152  * skipped as they are encountered.  If there were no errors, return 1;
1153  * otherwise return 0 (zero).
1154  */
1155 static int nfs_parse_mount_options(char *raw,
1156                                    struct nfs_parsed_mount_data *mnt)
1157 {
1158         char *p, *string, *secdata;
1159         int rc, sloppy = 0, invalid_option = 0;
1160         unsigned short protofamily = AF_UNSPEC;
1161         unsigned short mountfamily = AF_UNSPEC;
1162
1163         if (!raw) {
1164                 dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
1165                 return 1;
1166         }
1167         dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
1168
1169         secdata = alloc_secdata();
1170         if (!secdata)
1171                 goto out_nomem;
1172
1173         rc = security_sb_copy_data(raw, secdata);
1174         if (rc)
1175                 goto out_security_failure;
1176
1177         rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
1178         if (rc)
1179                 goto out_security_failure;
1180
1181         free_secdata(secdata);
1182
1183         while ((p = strsep(&raw, ",")) != NULL) {
1184                 substring_t args[MAX_OPT_ARGS];
1185                 unsigned long option;
1186                 int token;
1187
1188                 if (!*p)
1189                         continue;
1190
1191                 dfprintk(MOUNT, "NFS:   parsing nfs mount option '%s'\n", p);
1192
1193                 token = match_token(p, nfs_mount_option_tokens, args);
1194                 switch (token) {
1195
1196                 /*
1197                  * boolean options:  foo/nofoo
1198                  */
1199                 case Opt_soft:
1200                         mnt->flags |= NFS_MOUNT_SOFT;
1201                         break;
1202                 case Opt_hard:
1203                         mnt->flags &= ~NFS_MOUNT_SOFT;
1204                         break;
1205                 case Opt_posix:
1206                         mnt->flags |= NFS_MOUNT_POSIX;
1207                         break;
1208                 case Opt_noposix:
1209                         mnt->flags &= ~NFS_MOUNT_POSIX;
1210                         break;
1211                 case Opt_cto:
1212                         mnt->flags &= ~NFS_MOUNT_NOCTO;
1213                         break;
1214                 case Opt_nocto:
1215                         mnt->flags |= NFS_MOUNT_NOCTO;
1216                         break;
1217                 case Opt_ac:
1218                         mnt->flags &= ~NFS_MOUNT_NOAC;
1219                         break;
1220                 case Opt_noac:
1221                         mnt->flags |= NFS_MOUNT_NOAC;
1222                         break;
1223                 case Opt_lock:
1224                         mnt->flags &= ~NFS_MOUNT_NONLM;
1225                         mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
1226                                         NFS_MOUNT_LOCAL_FCNTL);
1227                         break;
1228                 case Opt_nolock:
1229                         mnt->flags |= NFS_MOUNT_NONLM;
1230                         mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
1231                                        NFS_MOUNT_LOCAL_FCNTL);
1232                         break;
1233                 case Opt_udp:
1234                         mnt->flags &= ~NFS_MOUNT_TCP;
1235                         mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1236                         break;
1237                 case Opt_tcp:
1238                         mnt->flags |= NFS_MOUNT_TCP;
1239                         mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1240                         break;
1241                 case Opt_rdma:
1242                         mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
1243                         mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1244                         xprt_load_transport(p);
1245                         break;
1246                 case Opt_acl:
1247                         mnt->flags &= ~NFS_MOUNT_NOACL;
1248                         break;
1249                 case Opt_noacl:
1250                         mnt->flags |= NFS_MOUNT_NOACL;
1251                         break;
1252                 case Opt_rdirplus:
1253                         mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
1254                         break;
1255                 case Opt_nordirplus:
1256                         mnt->flags |= NFS_MOUNT_NORDIRPLUS;
1257                         break;
1258                 case Opt_sharecache:
1259                         mnt->flags &= ~NFS_MOUNT_UNSHARED;
1260                         break;
1261                 case Opt_nosharecache:
1262                         mnt->flags |= NFS_MOUNT_UNSHARED;
1263                         break;
1264                 case Opt_resvport:
1265                         mnt->flags &= ~NFS_MOUNT_NORESVPORT;
1266                         break;
1267                 case Opt_noresvport:
1268                         mnt->flags |= NFS_MOUNT_NORESVPORT;
1269                         break;
1270                 case Opt_fscache:
1271                         mnt->options |= NFS_OPTION_FSCACHE;
1272                         kfree(mnt->fscache_uniq);
1273                         mnt->fscache_uniq = NULL;
1274                         break;
1275                 case Opt_nofscache:
1276                         mnt->options &= ~NFS_OPTION_FSCACHE;
1277                         kfree(mnt->fscache_uniq);
1278                         mnt->fscache_uniq = NULL;
1279                         break;
1280
1281                 /*
1282                  * options that take numeric values
1283                  */
1284                 case Opt_port:
1285                         if (nfs_get_option_ul(args, &option) ||
1286                             option > USHRT_MAX)
1287                                 goto out_invalid_value;
1288                         mnt->nfs_server.port = option;
1289                         break;
1290                 case Opt_rsize:
1291                         if (nfs_get_option_ul(args, &option))
1292                                 goto out_invalid_value;
1293                         mnt->rsize = option;
1294                         break;
1295                 case Opt_wsize:
1296                         if (nfs_get_option_ul(args, &option))
1297                                 goto out_invalid_value;
1298                         mnt->wsize = option;
1299                         break;
1300                 case Opt_bsize:
1301                         if (nfs_get_option_ul(args, &option))
1302                                 goto out_invalid_value;
1303                         mnt->bsize = option;
1304                         break;
1305                 case Opt_timeo:
1306                         if (nfs_get_option_ul(args, &option) || option == 0)
1307                                 goto out_invalid_value;
1308                         mnt->timeo = option;
1309                         break;
1310                 case Opt_retrans:
1311                         if (nfs_get_option_ul(args, &option) || option == 0)
1312                                 goto out_invalid_value;
1313                         mnt->retrans = option;
1314                         break;
1315                 case Opt_acregmin:
1316                         if (nfs_get_option_ul(args, &option))
1317                                 goto out_invalid_value;
1318                         mnt->acregmin = option;
1319                         break;
1320                 case Opt_acregmax:
1321                         if (nfs_get_option_ul(args, &option))
1322                                 goto out_invalid_value;
1323                         mnt->acregmax = option;
1324                         break;
1325                 case Opt_acdirmin:
1326                         if (nfs_get_option_ul(args, &option))
1327                                 goto out_invalid_value;
1328                         mnt->acdirmin = option;
1329                         break;
1330                 case Opt_acdirmax:
1331                         if (nfs_get_option_ul(args, &option))
1332                                 goto out_invalid_value;
1333                         mnt->acdirmax = option;
1334                         break;
1335                 case Opt_actimeo:
1336                         if (nfs_get_option_ul(args, &option))
1337                                 goto out_invalid_value;
1338                         mnt->acregmin = mnt->acregmax =
1339                         mnt->acdirmin = mnt->acdirmax = option;
1340                         break;
1341                 case Opt_namelen:
1342                         if (nfs_get_option_ul(args, &option))
1343                                 goto out_invalid_value;
1344                         mnt->namlen = option;
1345                         break;
1346                 case Opt_mountport:
1347                         if (nfs_get_option_ul(args, &option) ||
1348                             option > USHRT_MAX)
1349                                 goto out_invalid_value;
1350                         mnt->mount_server.port = option;
1351                         break;
1352                 case Opt_mountvers:
1353                         if (nfs_get_option_ul(args, &option) ||
1354                             option < NFS_MNT_VERSION ||
1355                             option > NFS_MNT3_VERSION)
1356                                 goto out_invalid_value;
1357                         mnt->mount_server.version = option;
1358                         break;
1359                 case Opt_minorversion:
1360                         if (nfs_get_option_ul(args, &option))
1361                                 goto out_invalid_value;
1362                         if (option > NFS4_MAX_MINOR_VERSION)
1363                                 goto out_invalid_value;
1364                         mnt->minorversion = option;
1365                         break;
1366
1367                 /*
1368                  * options that take text values
1369                  */
1370                 case Opt_nfsvers:
1371                         string = match_strdup(args);
1372                         if (string == NULL)
1373                                 goto out_nomem;
1374                         rc = nfs_parse_version_string(string, mnt, args);
1375                         kfree(string);
1376                         if (!rc)
1377                                 goto out_invalid_value;
1378                         break;
1379                 case Opt_sec:
1380                         string = match_strdup(args);
1381                         if (string == NULL)
1382                                 goto out_nomem;
1383                         rc = nfs_parse_security_flavors(string, mnt);
1384                         kfree(string);
1385                         if (!rc) {
1386                                 dfprintk(MOUNT, "NFS:   unrecognized "
1387                                                 "security flavor\n");
1388                                 return 0;
1389                         }
1390                         break;
1391                 case Opt_proto:
1392                         string = match_strdup(args);
1393                         if (string == NULL)
1394                                 goto out_nomem;
1395                         token = match_token(string,
1396                                             nfs_xprt_protocol_tokens, args);
1397
1398                         protofamily = AF_INET;
1399                         switch (token) {
1400                         case Opt_xprt_udp6:
1401                                 protofamily = AF_INET6;
1402                         case Opt_xprt_udp:
1403                                 mnt->flags &= ~NFS_MOUNT_TCP;
1404                                 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1405                                 break;
1406                         case Opt_xprt_tcp6:
1407                                 protofamily = AF_INET6;
1408                         case Opt_xprt_tcp:
1409                                 mnt->flags |= NFS_MOUNT_TCP;
1410                                 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1411                                 break;
1412                         case Opt_xprt_rdma:
1413                                 /* vector side protocols to TCP */
1414                                 mnt->flags |= NFS_MOUNT_TCP;
1415                                 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1416                                 xprt_load_transport(string);
1417                                 break;
1418                         default:
1419                                 dfprintk(MOUNT, "NFS:   unrecognized "
1420                                                 "transport protocol\n");
1421                                 kfree(string);
1422                                 return 0;
1423                         }
1424                         kfree(string);
1425                         break;
1426                 case Opt_mountproto:
1427                         string = match_strdup(args);
1428                         if (string == NULL)
1429                                 goto out_nomem;
1430                         token = match_token(string,
1431                                             nfs_xprt_protocol_tokens, args);
1432                         kfree(string);
1433
1434                         mountfamily = AF_INET;
1435                         switch (token) {
1436                         case Opt_xprt_udp6:
1437                                 mountfamily = AF_INET6;
1438                         case Opt_xprt_udp:
1439                                 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1440                                 break;
1441                         case Opt_xprt_tcp6:
1442                                 mountfamily = AF_INET6;
1443                         case Opt_xprt_tcp:
1444                                 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1445                                 break;
1446                         case Opt_xprt_rdma: /* not used for side protocols */
1447                         default:
1448                                 dfprintk(MOUNT, "NFS:   unrecognized "
1449                                                 "transport protocol\n");
1450                                 return 0;
1451                         }
1452                         break;
1453                 case Opt_addr:
1454                         string = match_strdup(args);
1455                         if (string == NULL)
1456                                 goto out_nomem;
1457                         mnt->nfs_server.addrlen =
1458                                 rpc_pton(mnt->net, string, strlen(string),
1459                                         (struct sockaddr *)
1460                                         &mnt->nfs_server.address,
1461                                         sizeof(mnt->nfs_server.address));
1462                         kfree(string);
1463                         if (mnt->nfs_server.addrlen == 0)
1464                                 goto out_invalid_address;
1465                         break;
1466                 case Opt_clientaddr:
1467                         if (nfs_get_option_str(args, &mnt->client_address))
1468                                 goto out_nomem;
1469                         break;
1470                 case Opt_mounthost:
1471                         if (nfs_get_option_str(args,
1472                                                &mnt->mount_server.hostname))
1473                                 goto out_nomem;
1474                         break;
1475                 case Opt_mountaddr:
1476                         string = match_strdup(args);
1477                         if (string == NULL)
1478                                 goto out_nomem;
1479                         mnt->mount_server.addrlen =
1480                                 rpc_pton(mnt->net, string, strlen(string),
1481                                         (struct sockaddr *)
1482                                         &mnt->mount_server.address,
1483                                         sizeof(mnt->mount_server.address));
1484                         kfree(string);
1485                         if (mnt->mount_server.addrlen == 0)
1486                                 goto out_invalid_address;
1487                         break;
1488                 case Opt_lookupcache:
1489                         string = match_strdup(args);
1490                         if (string == NULL)
1491                                 goto out_nomem;
1492                         token = match_token(string,
1493                                         nfs_lookupcache_tokens, args);
1494                         kfree(string);
1495                         switch (token) {
1496                                 case Opt_lookupcache_all:
1497                                         mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
1498                                         break;
1499                                 case Opt_lookupcache_positive:
1500                                         mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
1501                                         mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
1502                                         break;
1503                                 case Opt_lookupcache_none:
1504                                         mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
1505                                         break;
1506                                 default:
1507                                         dfprintk(MOUNT, "NFS:   invalid "
1508                                                         "lookupcache argument\n");
1509                                         return 0;
1510                         };
1511                         break;
1512                 case Opt_fscache_uniq:
1513                         if (nfs_get_option_str(args, &mnt->fscache_uniq))
1514                                 goto out_nomem;
1515                         mnt->options |= NFS_OPTION_FSCACHE;
1516                         break;
1517                 case Opt_local_lock:
1518                         string = match_strdup(args);
1519                         if (string == NULL)
1520                                 goto out_nomem;
1521                         token = match_token(string, nfs_local_lock_tokens,
1522                                         args);
1523                         kfree(string);
1524                         switch (token) {
1525                         case Opt_local_lock_all:
1526                                 mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
1527                                                NFS_MOUNT_LOCAL_FCNTL);
1528                                 break;
1529                         case Opt_local_lock_flock:
1530                                 mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
1531                                 break;
1532                         case Opt_local_lock_posix:
1533                                 mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
1534                                 break;
1535                         case Opt_local_lock_none:
1536                                 mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
1537                                                 NFS_MOUNT_LOCAL_FCNTL);
1538                                 break;
1539                         default:
1540                                 dfprintk(MOUNT, "NFS:   invalid "
1541                                                 "local_lock argument\n");
1542                                 return 0;
1543                         };
1544                         break;
1545
1546                 /*
1547                  * Special options
1548                  */
1549                 case Opt_sloppy:
1550                         sloppy = 1;
1551                         dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
1552                         break;
1553                 case Opt_userspace:
1554                 case Opt_deprecated:
1555                         dfprintk(MOUNT, "NFS:   ignoring mount option "
1556                                         "'%s'\n", p);
1557                         break;
1558
1559                 default:
1560                         invalid_option = 1;
1561                         dfprintk(MOUNT, "NFS:   unrecognized mount option "
1562                                         "'%s'\n", p);
1563                 }
1564         }
1565
1566         if (!sloppy && invalid_option)
1567                 return 0;
1568
1569         if (mnt->minorversion && mnt->version != 4)
1570                 goto out_minorversion_mismatch;
1571
1572         /*
1573          * verify that any proto=/mountproto= options match the address
1574          * familiies in the addr=/mountaddr= options.
1575          */
1576         if (protofamily != AF_UNSPEC &&
1577             protofamily != mnt->nfs_server.address.ss_family)
1578                 goto out_proto_mismatch;
1579
1580         if (mountfamily != AF_UNSPEC) {
1581                 if (mnt->mount_server.addrlen) {
1582                         if (mountfamily != mnt->mount_server.address.ss_family)
1583                                 goto out_mountproto_mismatch;
1584                 } else {
1585                         if (mountfamily != mnt->nfs_server.address.ss_family)
1586                                 goto out_mountproto_mismatch;
1587                 }
1588         }
1589
1590         return 1;
1591
1592 out_mountproto_mismatch:
1593         printk(KERN_INFO "NFS: mount server address does not match mountproto= "
1594                          "option\n");
1595         return 0;
1596 out_proto_mismatch:
1597         printk(KERN_INFO "NFS: server address does not match proto= option\n");
1598         return 0;
1599 out_invalid_address:
1600         printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
1601         return 0;
1602 out_invalid_value:
1603         printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
1604         return 0;
1605 out_minorversion_mismatch:
1606         printk(KERN_INFO "NFS: mount option vers=%u does not support "
1607                          "minorversion=%u\n", mnt->version, mnt->minorversion);
1608         return 0;
1609 out_nomem:
1610         printk(KERN_INFO "NFS: not enough memory to parse option\n");
1611         return 0;
1612 out_security_failure:
1613         free_secdata(secdata);
1614         printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1615         return 0;
1616 }
1617
1618 /*
1619  * Match the requested auth flavors with the list returned by
1620  * the server.  Returns zero and sets the mount's authentication
1621  * flavor on success; returns -EACCES if server does not support
1622  * the requested flavor.
1623  */
1624 static int nfs_walk_authlist(struct nfs_parsed_mount_data *args,
1625                              struct nfs_mount_request *request)
1626 {
1627         unsigned int i, j, server_authlist_len = *(request->auth_flav_len);
1628
1629         /*
1630          * Certain releases of Linux's mountd return an empty
1631          * flavor list.  To prevent behavioral regression with
1632          * these servers (ie. rejecting mounts that used to
1633          * succeed), revert to pre-2.6.32 behavior (no checking)
1634          * if the returned flavor list is empty.
1635          */
1636         if (server_authlist_len == 0)
1637                 return 0;
1638
1639         /*
1640          * We avoid sophisticated negotiating here, as there are
1641          * plenty of cases where we can get it wrong, providing
1642          * either too little or too much security.
1643          *
1644          * RFC 2623, section 2.7 suggests we SHOULD prefer the
1645          * flavor listed first.  However, some servers list
1646          * AUTH_NULL first.  Our caller plants AUTH_SYS, the
1647          * preferred default, in args->auth_flavors[0] if user
1648          * didn't specify sec= mount option.
1649          */
1650         for (i = 0; i < args->auth_flavor_len; i++)
1651                 for (j = 0; j < server_authlist_len; j++)
1652                         if (args->auth_flavors[i] == request->auth_flavs[j]) {
1653                                 dfprintk(MOUNT, "NFS: using auth flavor %d\n",
1654                                         request->auth_flavs[j]);
1655                                 args->auth_flavors[0] = request->auth_flavs[j];
1656                                 return 0;
1657                         }
1658
1659         dfprintk(MOUNT, "NFS: server does not support requested auth flavor\n");
1660         nfs_umount(request);
1661         return -EACCES;
1662 }
1663
1664 /*
1665  * Use the remote server's MOUNT service to request the NFS file handle
1666  * corresponding to the provided path.
1667  */
1668 static int nfs_try_mount(struct nfs_parsed_mount_data *args,
1669                          struct nfs_fh *root_fh)
1670 {
1671         rpc_authflavor_t server_authlist[NFS_MAX_SECFLAVORS];
1672         unsigned int server_authlist_len = ARRAY_SIZE(server_authlist);
1673         struct nfs_mount_request request = {
1674                 .sap            = (struct sockaddr *)
1675                                                 &args->mount_server.address,
1676                 .dirpath        = args->nfs_server.export_path,
1677                 .protocol       = args->mount_server.protocol,
1678                 .fh             = root_fh,
1679                 .noresvport     = args->flags & NFS_MOUNT_NORESVPORT,
1680                 .auth_flav_len  = &server_authlist_len,
1681                 .auth_flavs     = server_authlist,
1682                 .net            = args->net,
1683         };
1684         int status;
1685
1686         if (args->mount_server.version == 0) {
1687                 switch (args->version) {
1688                         default:
1689                                 args->mount_server.version = NFS_MNT3_VERSION;
1690                                 break;
1691                         case 2:
1692                                 args->mount_server.version = NFS_MNT_VERSION;
1693                 }
1694         }
1695         request.version = args->mount_server.version;
1696
1697         if (args->mount_server.hostname)
1698                 request.hostname = args->mount_server.hostname;
1699         else
1700                 request.hostname = args->nfs_server.hostname;
1701
1702         /*
1703          * Construct the mount server's address.
1704          */
1705         if (args->mount_server.address.ss_family == AF_UNSPEC) {
1706                 memcpy(request.sap, &args->nfs_server.address,
1707                        args->nfs_server.addrlen);
1708                 args->mount_server.addrlen = args->nfs_server.addrlen;
1709         }
1710         request.salen = args->mount_server.addrlen;
1711         nfs_set_port(request.sap, &args->mount_server.port, 0);
1712
1713         /*
1714          * Now ask the mount server to map our export path
1715          * to a file handle.
1716          */
1717         status = nfs_mount(&request);
1718         if (status != 0) {
1719                 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
1720                                 request.hostname, status);
1721                 return status;
1722         }
1723
1724         /*
1725          * MNTv1 (NFSv2) does not support auth flavor negotiation.
1726          */
1727         if (args->mount_server.version != NFS_MNT3_VERSION)
1728                 return 0;
1729         return nfs_walk_authlist(args, &request);
1730 }
1731
1732 /*
1733  * Split "dev_name" into "hostname:export_path".
1734  *
1735  * The leftmost colon demarks the split between the server's hostname
1736  * and the export path.  If the hostname starts with a left square
1737  * bracket, then it may contain colons.
1738  *
1739  * Note: caller frees hostname and export path, even on error.
1740  */
1741 static int nfs_parse_devname(const char *dev_name,
1742                              char **hostname, size_t maxnamlen,
1743                              char **export_path, size_t maxpathlen)
1744 {
1745         size_t len;
1746         char *end;
1747
1748         /* Is the host name protected with square brakcets? */
1749         if (*dev_name == '[') {
1750                 end = strchr(++dev_name, ']');
1751                 if (end == NULL || end[1] != ':')
1752                         goto out_bad_devname;
1753
1754                 len = end - dev_name;
1755                 end++;
1756         } else {
1757                 char *comma;
1758
1759                 end = strchr(dev_name, ':');
1760                 if (end == NULL)
1761                         goto out_bad_devname;
1762                 len = end - dev_name;
1763
1764                 /* kill possible hostname list: not supported */
1765                 comma = strchr(dev_name, ',');
1766                 if (comma != NULL && comma < end)
1767                         *comma = 0;
1768         }
1769
1770         if (len > maxnamlen)
1771                 goto out_hostname;
1772
1773         /* N.B. caller will free nfs_server.hostname in all cases */
1774         *hostname = kstrndup(dev_name, len, GFP_KERNEL);
1775         if (*hostname == NULL)
1776                 goto out_nomem;
1777         len = strlen(++end);
1778         if (len > maxpathlen)
1779                 goto out_path;
1780         *export_path = kstrndup(end, len, GFP_KERNEL);
1781         if (!*export_path)
1782                 goto out_nomem;
1783
1784         dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1785         return 0;
1786
1787 out_bad_devname:
1788         dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1789         return -EINVAL;
1790
1791 out_nomem:
1792         dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1793         return -ENOMEM;
1794
1795 out_hostname:
1796         dfprintk(MOUNT, "NFS: server hostname too long\n");
1797         return -ENAMETOOLONG;
1798
1799 out_path:
1800         dfprintk(MOUNT, "NFS: export pathname too long\n");
1801         return -ENAMETOOLONG;
1802 }
1803
1804 /*
1805  * Validate the NFS2/NFS3 mount data
1806  * - fills in the mount root filehandle
1807  *
1808  * For option strings, user space handles the following behaviors:
1809  *
1810  * + DNS: mapping server host name to IP address ("addr=" option)
1811  *
1812  * + failure mode: how to behave if a mount request can't be handled
1813  *   immediately ("fg/bg" option)
1814  *
1815  * + retry: how often to retry a mount request ("retry=" option)
1816  *
1817  * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
1818  *   mountproto=tcp after mountproto=udp, and so on
1819  */
1820 static int nfs_validate_mount_data(void *options,
1821                                    struct nfs_parsed_mount_data *args,
1822                                    struct nfs_fh *mntfh,
1823                                    const char *dev_name)
1824 {
1825         struct nfs_mount_data *data = (struct nfs_mount_data *)options;
1826         struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
1827
1828         if (data == NULL)
1829                 goto out_no_data;
1830
1831         switch (data->version) {
1832         case 1:
1833                 data->namlen = 0;
1834         case 2:
1835                 data->bsize = 0;
1836         case 3:
1837                 if (data->flags & NFS_MOUNT_VER3)
1838                         goto out_no_v3;
1839                 data->root.size = NFS2_FHSIZE;
1840                 memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
1841         case 4:
1842                 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1843                         goto out_no_sec;
1844         case 5:
1845                 memset(data->context, 0, sizeof(data->context));
1846         case 6:
1847                 if (data->flags & NFS_MOUNT_VER3) {
1848                         if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
1849                                 goto out_invalid_fh;
1850                         mntfh->size = data->root.size;
1851                         args->version = 3;
1852                 } else {
1853                         mntfh->size = NFS2_FHSIZE;
1854                         args->version = 2;
1855                 }
1856
1857
1858                 memcpy(mntfh->data, data->root.data, mntfh->size);
1859                 if (mntfh->size < sizeof(mntfh->data))
1860                         memset(mntfh->data + mntfh->size, 0,
1861                                sizeof(mntfh->data) - mntfh->size);
1862
1863                 /*
1864                  * Translate to nfs_parsed_mount_data, which nfs_fill_super
1865                  * can deal with.
1866                  */
1867                 args->flags             = data->flags & NFS_MOUNT_FLAGMASK;
1868                 args->flags             |= NFS_MOUNT_LEGACY_INTERFACE;
1869                 args->rsize             = data->rsize;
1870                 args->wsize             = data->wsize;
1871                 args->timeo             = data->timeo;
1872                 args->retrans           = data->retrans;
1873                 args->acregmin          = data->acregmin;
1874                 args->acregmax          = data->acregmax;
1875                 args->acdirmin          = data->acdirmin;
1876                 args->acdirmax          = data->acdirmax;
1877
1878                 memcpy(sap, &data->addr, sizeof(data->addr));
1879                 args->nfs_server.addrlen = sizeof(data->addr);
1880                 if (!nfs_verify_server_address(sap))
1881                         goto out_no_address;
1882
1883                 if (!(data->flags & NFS_MOUNT_TCP))
1884                         args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1885                 /* N.B. caller will free nfs_server.hostname in all cases */
1886                 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
1887                 args->namlen            = data->namlen;
1888                 args->bsize             = data->bsize;
1889
1890                 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1891                         args->auth_flavors[0] = data->pseudoflavor;
1892                 if (!args->nfs_server.hostname)
1893                         goto out_nomem;
1894
1895                 if (!(data->flags & NFS_MOUNT_NONLM))
1896                         args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
1897                                          NFS_MOUNT_LOCAL_FCNTL);
1898                 else
1899                         args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
1900                                         NFS_MOUNT_LOCAL_FCNTL);
1901                 /*
1902                  * The legacy version 6 binary mount data from userspace has a
1903                  * field used only to transport selinux information into the
1904                  * the kernel.  To continue to support that functionality we
1905                  * have a touch of selinux knowledge here in the NFS code. The
1906                  * userspace code converted context=blah to just blah so we are
1907                  * converting back to the full string selinux understands.
1908                  */
1909                 if (data->context[0]){
1910 #ifdef CONFIG_SECURITY_SELINUX
1911                         int rc;
1912                         char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
1913                         if (!opts_str)
1914                                 return -ENOMEM;
1915                         strcpy(opts_str, "context=");
1916                         data->context[NFS_MAX_CONTEXT_LEN] = '\0';
1917                         strcat(opts_str, &data->context[0]);
1918                         rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
1919                         kfree(opts_str);
1920                         if (rc)
1921                                 return rc;
1922 #else
1923                         return -EINVAL;
1924 #endif
1925                 }
1926
1927                 break;
1928         default: {
1929                 int status;
1930
1931                 if (nfs_parse_mount_options((char *)options, args) == 0)
1932                         return -EINVAL;
1933
1934                 if (!nfs_verify_server_address(sap))
1935                         goto out_no_address;
1936
1937                 if (args->version == 4)
1938 #ifdef CONFIG_NFS_V4
1939                         return nfs4_validate_text_mount_data(options,
1940                                                              args, dev_name);
1941 #else
1942                         goto out_v4_not_compiled;
1943 #endif
1944
1945                 nfs_set_port(sap, &args->nfs_server.port, 0);
1946
1947                 nfs_set_mount_transport_protocol(args);
1948
1949                 status = nfs_parse_devname(dev_name,
1950                                            &args->nfs_server.hostname,
1951                                            PAGE_SIZE,
1952                                            &args->nfs_server.export_path,
1953                                            NFS_MAXPATHLEN);
1954                 if (!status)
1955                         status = nfs_try_mount(args, mntfh);
1956
1957                 kfree(args->nfs_server.export_path);
1958                 args->nfs_server.export_path = NULL;
1959
1960                 if (status)
1961                         return status;
1962
1963                 break;
1964                 }
1965         }
1966
1967 #ifndef CONFIG_NFS_V3
1968         if (args->version == 3)
1969                 goto out_v3_not_compiled;
1970 #endif /* !CONFIG_NFS_V3 */
1971
1972         return 0;
1973
1974 out_no_data:
1975         dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
1976         return -EINVAL;
1977
1978 out_no_v3:
1979         dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
1980                  data->version);
1981         return -EINVAL;
1982
1983 out_no_sec:
1984         dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
1985         return -EINVAL;
1986
1987 #ifndef CONFIG_NFS_V3
1988 out_v3_not_compiled:
1989         dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
1990         return -EPROTONOSUPPORT;
1991 #endif /* !CONFIG_NFS_V3 */
1992
1993 #ifndef CONFIG_NFS_V4
1994 out_v4_not_compiled:
1995         dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
1996         return -EPROTONOSUPPORT;
1997 #endif /* !CONFIG_NFS_V4 */
1998
1999 out_nomem:
2000         dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
2001         return -ENOMEM;
2002
2003 out_no_address:
2004         dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
2005         return -EINVAL;
2006
2007 out_invalid_fh:
2008         dfprintk(MOUNT, "NFS: invalid root filehandle\n");
2009         return -EINVAL;
2010 }
2011
2012 static int
2013 nfs_compare_remount_data(struct nfs_server *nfss,
2014                          struct nfs_parsed_mount_data *data)
2015 {
2016         if (data->flags != nfss->flags ||
2017             data->rsize != nfss->rsize ||
2018             data->wsize != nfss->wsize ||
2019             data->retrans != nfss->client->cl_timeout->to_retries ||
2020             data->auth_flavors[0] != nfss->client->cl_auth->au_flavor ||
2021             data->acregmin != nfss->acregmin / HZ ||
2022             data->acregmax != nfss->acregmax / HZ ||
2023             data->acdirmin != nfss->acdirmin / HZ ||
2024             data->acdirmax != nfss->acdirmax / HZ ||
2025             data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
2026             data->nfs_server.port != nfss->port ||
2027             data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
2028             !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
2029                           (struct sockaddr *)&nfss->nfs_client->cl_addr))
2030                 return -EINVAL;
2031
2032         return 0;
2033 }
2034
2035 static int
2036 nfs_remount(struct super_block *sb, int *flags, char *raw_data)
2037 {
2038         int error;
2039         struct nfs_server *nfss = sb->s_fs_info;
2040         struct nfs_parsed_mount_data *data;
2041         struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
2042         struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
2043         u32 nfsvers = nfss->nfs_client->rpc_ops->version;
2044
2045         /*
2046          * Userspace mount programs that send binary options generally send
2047          * them populated with default values. We have no way to know which
2048          * ones were explicitly specified. Fall back to legacy behavior and
2049          * just return success.
2050          */
2051         if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
2052             (nfsvers <= 3 && (!options || (options->version >= 1 &&
2053                                            options->version <= 6))))
2054                 return 0;
2055
2056         data = kzalloc(sizeof(*data), GFP_KERNEL);
2057         if (data == NULL)
2058                 return -ENOMEM;
2059
2060         /* fill out struct with values from existing mount */
2061         data->flags = nfss->flags;
2062         data->rsize = nfss->rsize;
2063         data->wsize = nfss->wsize;
2064         data->retrans = nfss->client->cl_timeout->to_retries;
2065         data->auth_flavors[0] = nfss->client->cl_auth->au_flavor;
2066         data->acregmin = nfss->acregmin / HZ;
2067         data->acregmax = nfss->acregmax / HZ;
2068         data->acdirmin = nfss->acdirmin / HZ;
2069         data->acdirmax = nfss->acdirmax / HZ;
2070         data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
2071         data->nfs_server.port = nfss->port;
2072         data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
2073         memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
2074                 data->nfs_server.addrlen);
2075
2076         /* overwrite those values with any that were specified */
2077         error = nfs_parse_mount_options((char *)options, data);
2078         if (error < 0)
2079                 goto out;
2080
2081         /*
2082          * noac is a special case. It implies -o sync, but that's not
2083          * necessarily reflected in the mtab options. do_remount_sb
2084          * will clear MS_SYNCHRONOUS if -o sync wasn't specified in the
2085          * remount options, so we have to explicitly reset it.
2086          */
2087         if (data->flags & NFS_MOUNT_NOAC)
2088                 *flags |= MS_SYNCHRONOUS;
2089
2090         /* compare new mount options with old ones */
2091         error = nfs_compare_remount_data(nfss, data);
2092 out:
2093         kfree(data);
2094         return error;
2095 }
2096
2097 /*
2098  * Initialise the common bits of the superblock
2099  */
2100 static inline void nfs_initialise_sb(struct super_block *sb)
2101 {
2102         struct nfs_server *server = NFS_SB(sb);
2103
2104         sb->s_magic = NFS_SUPER_MAGIC;
2105
2106         /* We probably want something more informative here */
2107         snprintf(sb->s_id, sizeof(sb->s_id),
2108                  "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
2109
2110         if (sb->s_blocksize == 0)
2111                 sb->s_blocksize = nfs_block_bits(server->wsize,
2112                                                  &sb->s_blocksize_bits);
2113
2114         sb->s_bdi = &server->backing_dev_info;
2115
2116         nfs_super_set_maxbytes(sb, server->maxfilesize);
2117 }
2118
2119 /*
2120  * Finish setting up an NFS2/3 superblock
2121  */
2122 static void nfs_fill_super(struct super_block *sb,
2123                            struct nfs_parsed_mount_data *data)
2124 {
2125         struct nfs_server *server = NFS_SB(sb);
2126
2127         sb->s_blocksize_bits = 0;
2128         sb->s_blocksize = 0;
2129         if (data->bsize)
2130                 sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
2131
2132         if (server->nfs_client->rpc_ops->version == 3) {
2133                 /* The VFS shouldn't apply the umask to mode bits. We will do
2134                  * so ourselves when necessary.
2135                  */
2136                 sb->s_flags |= MS_POSIXACL;
2137                 sb->s_time_gran = 1;
2138         }
2139
2140         sb->s_op = &nfs_sops;
2141         nfs_initialise_sb(sb);
2142 }
2143
2144 /*
2145  * Finish setting up a cloned NFS2/3 superblock
2146  */
2147 static void nfs_clone_super(struct super_block *sb,
2148                             const struct super_block *old_sb)
2149 {
2150         struct nfs_server *server = NFS_SB(sb);
2151
2152         sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2153         sb->s_blocksize = old_sb->s_blocksize;
2154         sb->s_maxbytes = old_sb->s_maxbytes;
2155
2156         if (server->nfs_client->rpc_ops->version == 3) {
2157                 /* The VFS shouldn't apply the umask to mode bits. We will do
2158                  * so ourselves when necessary.
2159                  */
2160                 sb->s_flags |= MS_POSIXACL;
2161                 sb->s_time_gran = 1;
2162         }
2163
2164         sb->s_op = old_sb->s_op;
2165         nfs_initialise_sb(sb);
2166 }
2167
2168 static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
2169 {
2170         const struct nfs_server *a = s->s_fs_info;
2171         const struct rpc_clnt *clnt_a = a->client;
2172         const struct rpc_clnt *clnt_b = b->client;
2173
2174         if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
2175                 goto Ebusy;
2176         if (a->nfs_client != b->nfs_client)
2177                 goto Ebusy;
2178         if (a->flags != b->flags)
2179                 goto Ebusy;
2180         if (a->wsize != b->wsize)
2181                 goto Ebusy;
2182         if (a->rsize != b->rsize)
2183                 goto Ebusy;
2184         if (a->acregmin != b->acregmin)
2185                 goto Ebusy;
2186         if (a->acregmax != b->acregmax)
2187                 goto Ebusy;
2188         if (a->acdirmin != b->acdirmin)
2189                 goto Ebusy;
2190         if (a->acdirmax != b->acdirmax)
2191                 goto Ebusy;
2192         if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
2193                 goto Ebusy;
2194         return 1;
2195 Ebusy:
2196         return 0;
2197 }
2198
2199 struct nfs_sb_mountdata {
2200         struct nfs_server *server;
2201         int mntflags;
2202 };
2203
2204 static int nfs_set_super(struct super_block *s, void *data)
2205 {
2206         struct nfs_sb_mountdata *sb_mntdata = data;
2207         struct nfs_server *server = sb_mntdata->server;
2208         int ret;
2209
2210         s->s_flags = sb_mntdata->mntflags;
2211         s->s_fs_info = server;
2212         s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
2213         ret = set_anon_super(s, server);
2214         if (ret == 0)
2215                 server->s_dev = s->s_dev;
2216         return ret;
2217 }
2218
2219 static int nfs_compare_super_address(struct nfs_server *server1,
2220                                      struct nfs_server *server2)
2221 {
2222         struct sockaddr *sap1, *sap2;
2223
2224         sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
2225         sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
2226
2227         if (sap1->sa_family != sap2->sa_family)
2228                 return 0;
2229
2230         switch (sap1->sa_family) {
2231         case AF_INET: {
2232                 struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
2233                 struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
2234                 if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
2235                         return 0;
2236                 if (sin1->sin_port != sin2->sin_port)
2237                         return 0;
2238                 break;
2239         }
2240         case AF_INET6: {
2241                 struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
2242                 struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
2243                 if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
2244                         return 0;
2245                 if (sin1->sin6_port != sin2->sin6_port)
2246                         return 0;
2247                 break;
2248         }
2249         default:
2250                 return 0;
2251         }
2252
2253         return 1;
2254 }
2255
2256 static int nfs_compare_super(struct super_block *sb, void *data)
2257 {
2258         struct nfs_sb_mountdata *sb_mntdata = data;
2259         struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
2260         int mntflags = sb_mntdata->mntflags;
2261
2262         if (!nfs_compare_super_address(old, server))
2263                 return 0;
2264         /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
2265         if (old->flags & NFS_MOUNT_UNSHARED)
2266                 return 0;
2267         if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
2268                 return 0;
2269         return nfs_compare_mount_options(sb, server, mntflags);
2270 }
2271
2272 static int nfs_bdi_register(struct nfs_server *server)
2273 {
2274         return bdi_register_dev(&server->backing_dev_info, server->s_dev);
2275 }
2276
2277 static struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
2278         int flags, const char *dev_name, void *raw_data)
2279 {
2280         struct nfs_server *server = NULL;
2281         struct super_block *s;
2282         struct nfs_parsed_mount_data *data;
2283         struct nfs_fh *mntfh;
2284         struct dentry *mntroot = ERR_PTR(-ENOMEM);
2285         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2286         struct nfs_sb_mountdata sb_mntdata = {
2287                 .mntflags = flags,
2288         };
2289         int error;
2290
2291         data = nfs_alloc_parsed_mount_data(NFS_DEFAULT_VERSION);
2292         mntfh = nfs_alloc_fhandle();
2293         if (data == NULL || mntfh == NULL)
2294                 goto out;
2295
2296         /* Validate the mount data */
2297         error = nfs_validate_mount_data(raw_data, data, mntfh, dev_name);
2298         if (error < 0) {
2299                 mntroot = ERR_PTR(error);
2300                 goto out;
2301         }
2302
2303 #ifdef CONFIG_NFS_V4
2304         if (data->version == 4) {
2305                 mntroot = nfs4_try_mount(flags, dev_name, data);
2306                 goto out;
2307         }
2308 #endif  /* CONFIG_NFS_V4 */
2309
2310         /* Get a volume representation */
2311         server = nfs_create_server(data, mntfh);
2312         if (IS_ERR(server)) {
2313                 mntroot = ERR_CAST(server);
2314                 goto out;
2315         }
2316         sb_mntdata.server = server;
2317
2318         if (server->flags & NFS_MOUNT_UNSHARED)
2319                 compare_super = NULL;
2320
2321         /* -o noac implies -o sync */
2322         if (server->flags & NFS_MOUNT_NOAC)
2323                 sb_mntdata.mntflags |= MS_SYNCHRONOUS;
2324
2325         /* Get a superblock - note that we may end up sharing one that already exists */
2326         s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
2327         if (IS_ERR(s)) {
2328                 mntroot = ERR_CAST(s);
2329                 goto out_err_nosb;
2330         }
2331
2332         if (s->s_fs_info != server) {
2333                 nfs_free_server(server);
2334                 server = NULL;
2335         } else {
2336                 error = nfs_bdi_register(server);
2337                 if (error) {
2338                         mntroot = ERR_PTR(error);
2339                         goto error_splat_bdi;
2340                 }
2341         }
2342
2343         if (!s->s_root) {
2344                 /* initial superblock/root creation */
2345                 nfs_fill_super(s, data);
2346                 nfs_fscache_get_super_cookie(s, data->fscache_uniq, NULL);
2347         }
2348
2349         mntroot = nfs_get_root(s, mntfh, dev_name);
2350         if (IS_ERR(mntroot))
2351                 goto error_splat_super;
2352
2353         error = security_sb_set_mnt_opts(s, &data->lsm_opts);
2354         if (error)
2355                 goto error_splat_root;
2356
2357         s->s_flags |= MS_ACTIVE;
2358
2359 out:
2360         nfs_free_parsed_mount_data(data);
2361         nfs_free_fhandle(mntfh);
2362         return mntroot;
2363
2364 out_err_nosb:
2365         nfs_free_server(server);
2366         goto out;
2367
2368 error_splat_root:
2369         dput(mntroot);
2370         mntroot = ERR_PTR(error);
2371 error_splat_super:
2372         if (server && !s->s_root)
2373                 bdi_unregister(&server->backing_dev_info);
2374 error_splat_bdi:
2375         deactivate_locked_super(s);
2376         goto out;
2377 }
2378
2379 /*
2380  * Ensure that we unregister the bdi before kill_anon_super
2381  * releases the device name
2382  */
2383 static void nfs_put_super(struct super_block *s)
2384 {
2385         struct nfs_server *server = NFS_SB(s);
2386
2387         bdi_unregister(&server->backing_dev_info);
2388 }
2389
2390 /*
2391  * Destroy an NFS2/3 superblock
2392  */
2393 static void nfs_kill_super(struct super_block *s)
2394 {
2395         struct nfs_server *server = NFS_SB(s);
2396
2397         kill_anon_super(s);
2398         nfs_fscache_release_super_cookie(s);
2399         nfs_free_server(server);
2400 }
2401
2402 /*
2403  * Clone an NFS2/3 server record on xdev traversal (FSID-change)
2404  */
2405 static struct dentry *
2406 nfs_xdev_mount(struct file_system_type *fs_type, int flags,
2407                 const char *dev_name, void *raw_data)
2408 {
2409         struct nfs_clone_mount *data = raw_data;
2410         struct super_block *s;
2411         struct nfs_server *server;
2412         struct dentry *mntroot;
2413         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2414         struct nfs_sb_mountdata sb_mntdata = {
2415                 .mntflags = flags,
2416         };
2417         int error;
2418
2419         dprintk("--> nfs_xdev_mount()\n");
2420
2421         /* create a new volume representation */
2422         server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
2423         if (IS_ERR(server)) {
2424                 error = PTR_ERR(server);
2425                 goto out_err_noserver;
2426         }
2427         sb_mntdata.server = server;
2428
2429         if (server->flags & NFS_MOUNT_UNSHARED)
2430                 compare_super = NULL;
2431
2432         /* -o noac implies -o sync */
2433         if (server->flags & NFS_MOUNT_NOAC)
2434                 sb_mntdata.mntflags |= MS_SYNCHRONOUS;
2435
2436         /* Get a superblock - note that we may end up sharing one that already exists */
2437         s = sget(&nfs_fs_type, compare_super, nfs_set_super, &sb_mntdata);
2438         if (IS_ERR(s)) {
2439                 error = PTR_ERR(s);
2440                 goto out_err_nosb;
2441         }
2442
2443         if (s->s_fs_info != server) {
2444                 nfs_free_server(server);
2445                 server = NULL;
2446         } else {
2447                 error = nfs_bdi_register(server);
2448                 if (error)
2449                         goto error_splat_bdi;
2450         }
2451
2452         if (!s->s_root) {
2453                 /* initial superblock/root creation */
2454                 nfs_clone_super(s, data->sb);
2455                 nfs_fscache_get_super_cookie(s, NULL, data);
2456         }
2457
2458         mntroot = nfs_get_root(s, data->fh, dev_name);
2459         if (IS_ERR(mntroot)) {
2460                 error = PTR_ERR(mntroot);
2461                 goto error_splat_super;
2462         }
2463         if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
2464                 dput(mntroot);
2465                 error = -ESTALE;
2466                 goto error_splat_super;
2467         }
2468
2469         s->s_flags |= MS_ACTIVE;
2470
2471         /* clone any lsm security options from the parent to the new sb */
2472         security_sb_clone_mnt_opts(data->sb, s);
2473
2474         dprintk("<-- nfs_xdev_mount() = 0\n");
2475         return mntroot;
2476
2477 out_err_nosb:
2478         nfs_free_server(server);
2479 out_err_noserver:
2480         dprintk("<-- nfs_xdev_mount() = %d [error]\n", error);
2481         return ERR_PTR(error);
2482
2483 error_splat_super:
2484         if (server && !s->s_root)
2485                 bdi_unregister(&server->backing_dev_info);
2486 error_splat_bdi:
2487         deactivate_locked_super(s);
2488         dprintk("<-- nfs_xdev_mount() = %d [splat]\n", error);
2489         return ERR_PTR(error);
2490 }
2491
2492 #ifdef CONFIG_NFS_V4
2493
2494 /*
2495  * Finish setting up a cloned NFS4 superblock
2496  */
2497 static void nfs4_clone_super(struct super_block *sb,
2498                             const struct super_block *old_sb)
2499 {
2500         sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2501         sb->s_blocksize = old_sb->s_blocksize;
2502         sb->s_maxbytes = old_sb->s_maxbytes;
2503         sb->s_time_gran = 1;
2504         sb->s_op = old_sb->s_op;
2505         /*
2506          * The VFS shouldn't apply the umask to mode bits. We will do
2507          * so ourselves when necessary.
2508          */
2509         sb->s_flags  |= MS_POSIXACL;
2510         sb->s_xattr  = old_sb->s_xattr;
2511         nfs_initialise_sb(sb);
2512 }
2513
2514 /*
2515  * Set up an NFS4 superblock
2516  */
2517 static void nfs4_fill_super(struct super_block *sb)
2518 {
2519         sb->s_time_gran = 1;
2520         sb->s_op = &nfs4_sops;
2521         /*
2522          * The VFS shouldn't apply the umask to mode bits. We will do
2523          * so ourselves when necessary.
2524          */
2525         sb->s_flags  |= MS_POSIXACL;
2526         sb->s_xattr = nfs4_xattr_handlers;
2527         nfs_initialise_sb(sb);
2528 }
2529
2530 static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
2531 {
2532         args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
2533                          NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
2534 }
2535
2536 static int nfs4_validate_text_mount_data(void *options,
2537                                          struct nfs_parsed_mount_data *args,
2538                                          const char *dev_name)
2539 {
2540         struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
2541
2542         nfs_set_port(sap, &args->nfs_server.port, NFS_PORT);
2543
2544         nfs_validate_transport_protocol(args);
2545
2546         nfs4_validate_mount_flags(args);
2547
2548         if (args->version != 4) {
2549                 dfprintk(MOUNT,
2550                          "NFS4: Illegal mount version\n");
2551                 return -EINVAL;
2552         }
2553
2554         if (args->auth_flavor_len > 1) {
2555                 dfprintk(MOUNT,
2556                          "NFS4: Too many RPC auth flavours specified\n");
2557                 return -EINVAL;
2558         }
2559
2560         if (args->client_address == NULL) {
2561                 dfprintk(MOUNT,
2562                          "NFS4: mount program didn't pass callback address\n");
2563                 return -EINVAL;
2564         }
2565
2566         return nfs_parse_devname(dev_name,
2567                                    &args->nfs_server.hostname,
2568                                    NFS4_MAXNAMLEN,
2569                                    &args->nfs_server.export_path,
2570                                    NFS4_MAXPATHLEN);
2571 }
2572
2573 /*
2574  * Validate NFSv4 mount options
2575  */
2576 static int nfs4_validate_mount_data(void *options,
2577                                     struct nfs_parsed_mount_data *args,
2578                                     const char *dev_name)
2579 {
2580         struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
2581         struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
2582         char *c;
2583
2584         if (data == NULL)
2585                 goto out_no_data;
2586
2587         switch (data->version) {
2588         case 1:
2589                 if (data->host_addrlen > sizeof(args->nfs_server.address))
2590                         goto out_no_address;
2591                 if (data->host_addrlen == 0)
2592                         goto out_no_address;
2593                 args->nfs_server.addrlen = data->host_addrlen;
2594                 if (copy_from_user(sap, data->host_addr, data->host_addrlen))
2595                         return -EFAULT;
2596                 if (!nfs_verify_server_address(sap))
2597                         goto out_no_address;
2598
2599                 if (data->auth_flavourlen) {
2600                         if (data->auth_flavourlen > 1)
2601                                 goto out_inval_auth;
2602                         if (copy_from_user(&args->auth_flavors[0],
2603                                            data->auth_flavours,
2604                                            sizeof(args->auth_flavors[0])))
2605                                 return -EFAULT;
2606                 }
2607
2608                 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
2609                 if (IS_ERR(c))
2610                         return PTR_ERR(c);
2611                 args->nfs_server.hostname = c;
2612
2613                 c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
2614                 if (IS_ERR(c))
2615                         return PTR_ERR(c);
2616                 args->nfs_server.export_path = c;
2617                 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
2618
2619                 c = strndup_user(data->client_addr.data, 16);
2620                 if (IS_ERR(c))
2621                         return PTR_ERR(c);
2622                 args->client_address = c;
2623
2624                 /*
2625                  * Translate to nfs_parsed_mount_data, which nfs4_fill_super
2626                  * can deal with.
2627                  */
2628
2629                 args->flags     = data->flags & NFS4_MOUNT_FLAGMASK;
2630                 args->rsize     = data->rsize;
2631                 args->wsize     = data->wsize;
2632                 args->timeo     = data->timeo;
2633                 args->retrans   = data->retrans;
2634                 args->acregmin  = data->acregmin;
2635                 args->acregmax  = data->acregmax;
2636                 args->acdirmin  = data->acdirmin;
2637                 args->acdirmax  = data->acdirmax;
2638                 args->nfs_server.protocol = data->proto;
2639                 nfs_validate_transport_protocol(args);
2640
2641                 break;
2642         default:
2643                 if (nfs_parse_mount_options((char *)options, args) == 0)
2644                         return -EINVAL;
2645
2646                 if (!nfs_verify_server_address(sap))
2647                         return -EINVAL;
2648
2649                 return nfs4_validate_text_mount_data(options, args, dev_name);
2650         }
2651
2652         return 0;
2653
2654 out_no_data:
2655         dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
2656         return -EINVAL;
2657
2658 out_inval_auth:
2659         dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
2660                  data->auth_flavourlen);
2661         return -EINVAL;
2662
2663 out_no_address:
2664         dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
2665         return -EINVAL;
2666 }
2667
2668 /*
2669  * Get the superblock for the NFS4 root partition
2670  */
2671 static struct dentry *
2672 nfs4_remote_mount(struct file_system_type *fs_type, int flags,
2673                   const char *dev_name, void *raw_data)
2674 {
2675         struct nfs_parsed_mount_data *data = raw_data;
2676         struct super_block *s;
2677         struct nfs_server *server;
2678         struct nfs_fh *mntfh;
2679         struct dentry *mntroot;
2680         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2681         struct nfs_sb_mountdata sb_mntdata = {
2682                 .mntflags = flags,
2683         };
2684         int error = -ENOMEM;
2685
2686         mntfh = nfs_alloc_fhandle();
2687         if (data == NULL || mntfh == NULL)
2688                 goto out;
2689
2690         /* Get a volume representation */
2691         server = nfs4_create_server(data, mntfh);
2692         if (IS_ERR(server)) {
2693                 error = PTR_ERR(server);
2694                 goto out;
2695         }
2696         sb_mntdata.server = server;
2697
2698         if (server->flags & NFS4_MOUNT_UNSHARED)
2699                 compare_super = NULL;
2700
2701         /* -o noac implies -o sync */
2702         if (server->flags & NFS_MOUNT_NOAC)
2703                 sb_mntdata.mntflags |= MS_SYNCHRONOUS;
2704
2705         /* Get a superblock - note that we may end up sharing one that already exists */
2706         s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
2707         if (IS_ERR(s)) {
2708                 error = PTR_ERR(s);
2709                 goto out_free;
2710         }
2711
2712         if (s->s_fs_info != server) {
2713                 nfs_free_server(server);
2714                 server = NULL;
2715         } else {
2716                 error = nfs_bdi_register(server);
2717                 if (error)
2718                         goto error_splat_bdi;
2719         }
2720
2721         if (!s->s_root) {
2722                 /* initial superblock/root creation */
2723                 nfs4_fill_super(s);
2724                 nfs_fscache_get_super_cookie(s, data->fscache_uniq, NULL);
2725         }
2726
2727         mntroot = nfs4_get_root(s, mntfh, dev_name);
2728         if (IS_ERR(mntroot)) {
2729                 error = PTR_ERR(mntroot);
2730                 goto error_splat_super;
2731         }
2732
2733         error = security_sb_set_mnt_opts(s, &data->lsm_opts);
2734         if (error)
2735                 goto error_splat_root;
2736
2737         s->s_flags |= MS_ACTIVE;
2738
2739         nfs_free_fhandle(mntfh);
2740         return mntroot;
2741
2742 out:
2743         nfs_free_fhandle(mntfh);
2744         return ERR_PTR(error);
2745
2746 out_free:
2747         nfs_free_server(server);
2748         goto out;
2749
2750 error_splat_root:
2751         dput(mntroot);
2752 error_splat_super:
2753         if (server && !s->s_root)
2754                 bdi_unregister(&server->backing_dev_info);
2755 error_splat_bdi:
2756         deactivate_locked_super(s);
2757         goto out;
2758 }
2759
2760 static struct vfsmount *nfs_do_root_mount(struct file_system_type *fs_type,
2761                 int flags, void *data, const char *hostname)
2762 {
2763         struct vfsmount *root_mnt;
2764         char *root_devname;
2765         size_t len;
2766
2767         len = strlen(hostname) + 3;
2768         root_devname = kmalloc(len, GFP_KERNEL);
2769         if (root_devname == NULL)
2770                 return ERR_PTR(-ENOMEM);
2771         snprintf(root_devname, len, "%s:/", hostname);
2772         root_mnt = vfs_kern_mount(fs_type, flags, root_devname, data);
2773         kfree(root_devname);
2774         return root_mnt;
2775 }
2776
2777 struct nfs_referral_count {
2778         struct list_head list;
2779         const struct task_struct *task;
2780         unsigned int referral_count;
2781 };
2782
2783 static LIST_HEAD(nfs_referral_count_list);
2784 static DEFINE_SPINLOCK(nfs_referral_count_list_lock);
2785
2786 static struct nfs_referral_count *nfs_find_referral_count(void)
2787 {
2788         struct nfs_referral_count *p;
2789
2790         list_for_each_entry(p, &nfs_referral_count_list, list) {
2791                 if (p->task == current)
2792                         return p;
2793         }
2794         return NULL;
2795 }
2796
2797 #define NFS_MAX_NESTED_REFERRALS 2
2798
2799 static int nfs_referral_loop_protect(void)
2800 {
2801         struct nfs_referral_count *p, *new;
2802         int ret = -ENOMEM;
2803
2804         new = kmalloc(sizeof(*new), GFP_KERNEL);
2805         if (!new)
2806                 goto out;
2807         new->task = current;
2808         new->referral_count = 1;
2809
2810         ret = 0;
2811         spin_lock(&nfs_referral_count_list_lock);
2812         p = nfs_find_referral_count();
2813         if (p != NULL) {
2814                 if (p->referral_count >= NFS_MAX_NESTED_REFERRALS)
2815                         ret = -ELOOP;
2816                 else
2817                         p->referral_count++;
2818         } else {
2819                 list_add(&new->list, &nfs_referral_count_list);
2820                 new = NULL;
2821         }
2822         spin_unlock(&nfs_referral_count_list_lock);
2823         kfree(new);
2824 out:
2825         return ret;
2826 }
2827
2828 static void nfs_referral_loop_unprotect(void)
2829 {
2830         struct nfs_referral_count *p;
2831
2832         spin_lock(&nfs_referral_count_list_lock);
2833         p = nfs_find_referral_count();
2834         p->referral_count--;
2835         if (p->referral_count == 0)
2836                 list_del(&p->list);
2837         else
2838                 p = NULL;
2839         spin_unlock(&nfs_referral_count_list_lock);
2840         kfree(p);
2841 }
2842
2843 static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
2844                 const char *export_path)
2845 {
2846         struct dentry *dentry;
2847         int err;
2848
2849         if (IS_ERR(root_mnt))
2850                 return ERR_CAST(root_mnt);
2851
2852         err = nfs_referral_loop_protect();
2853         if (err) {
2854                 mntput(root_mnt);
2855                 return ERR_PTR(err);
2856         }
2857
2858         dentry = mount_subtree(root_mnt, export_path);
2859         nfs_referral_loop_unprotect();
2860
2861         return dentry;
2862 }
2863
2864 static struct dentry *nfs4_try_mount(int flags, const char *dev_name,
2865                          struct nfs_parsed_mount_data *data)
2866 {
2867         char *export_path;
2868         struct vfsmount *root_mnt;
2869         struct dentry *res;
2870
2871         dfprintk(MOUNT, "--> nfs4_try_mount()\n");
2872
2873         export_path = data->nfs_server.export_path;
2874         data->nfs_server.export_path = "/";
2875         root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, data,
2876                         data->nfs_server.hostname);
2877         data->nfs_server.export_path = export_path;
2878
2879         res = nfs_follow_remote_path(root_mnt, export_path);
2880
2881         dfprintk(MOUNT, "<-- nfs4_try_mount() = %ld%s\n",
2882                         IS_ERR(res) ? PTR_ERR(res) : 0,
2883                         IS_ERR(res) ? " [error]" : "");
2884         return res;
2885 }
2886
2887 /*
2888  * Get the superblock for an NFS4 mountpoint
2889  */
2890 static struct dentry *nfs4_mount(struct file_system_type *fs_type,
2891         int flags, const char *dev_name, void *raw_data)
2892 {
2893         struct nfs_parsed_mount_data *data;
2894         int error = -ENOMEM;
2895         struct dentry *res = ERR_PTR(-ENOMEM);
2896
2897         data = nfs_alloc_parsed_mount_data(4);
2898         if (data == NULL)
2899                 goto out;
2900
2901         /* Validate the mount data */
2902         error = nfs4_validate_mount_data(raw_data, data, dev_name);
2903         if (error < 0) {
2904                 res = ERR_PTR(error);
2905                 goto out;
2906         }
2907
2908         res = nfs4_try_mount(flags, dev_name, data);
2909         if (IS_ERR(res))
2910                 error = PTR_ERR(res);
2911
2912 out:
2913         nfs_free_parsed_mount_data(data);
2914         dprintk("<-- nfs4_mount() = %d%s\n", error,
2915                         error != 0 ? " [error]" : "");
2916         return res;
2917 }
2918
2919 static void nfs4_kill_super(struct super_block *sb)
2920 {
2921         struct nfs_server *server = NFS_SB(sb);
2922
2923         dprintk("--> %s\n", __func__);
2924         nfs_super_return_all_delegations(sb);
2925         kill_anon_super(sb);
2926         nfs_fscache_release_super_cookie(sb);
2927         nfs_free_server(server);
2928         dprintk("<-- %s\n", __func__);
2929 }
2930
2931 /*
2932  * Clone an NFS4 server record on xdev traversal (FSID-change)
2933  */
2934 static struct dentry *
2935 nfs4_xdev_mount(struct file_system_type *fs_type, int flags,
2936                  const char *dev_name, void *raw_data)
2937 {
2938         struct nfs_clone_mount *data = raw_data;
2939         struct super_block *s;
2940         struct nfs_server *server;
2941         struct dentry *mntroot;
2942         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2943         struct nfs_sb_mountdata sb_mntdata = {
2944                 .mntflags = flags,
2945         };
2946         int error;
2947
2948         dprintk("--> nfs4_xdev_mount()\n");
2949
2950         /* create a new volume representation */
2951         server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
2952         if (IS_ERR(server)) {
2953                 error = PTR_ERR(server);
2954                 goto out_err_noserver;
2955         }
2956         sb_mntdata.server = server;
2957
2958         if (server->flags & NFS4_MOUNT_UNSHARED)
2959                 compare_super = NULL;
2960
2961         /* -o noac implies -o sync */
2962         if (server->flags & NFS_MOUNT_NOAC)
2963                 sb_mntdata.mntflags |= MS_SYNCHRONOUS;
2964
2965         /* Get a superblock - note that we may end up sharing one that already exists */
2966         s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
2967         if (IS_ERR(s)) {
2968                 error = PTR_ERR(s);
2969                 goto out_err_nosb;
2970         }
2971
2972         if (s->s_fs_info != server) {
2973                 nfs_free_server(server);
2974                 server = NULL;
2975         } else {
2976                 error = nfs_bdi_register(server);
2977                 if (error)
2978                         goto error_splat_bdi;
2979         }
2980
2981         if (!s->s_root) {
2982                 /* initial superblock/root creation */
2983                 nfs4_clone_super(s, data->sb);
2984                 nfs_fscache_get_super_cookie(s, NULL, data);
2985         }
2986
2987         mntroot = nfs4_get_root(s, data->fh, dev_name);
2988         if (IS_ERR(mntroot)) {
2989                 error = PTR_ERR(mntroot);
2990                 goto error_splat_super;
2991         }
2992         if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
2993                 dput(mntroot);
2994                 error = -ESTALE;
2995                 goto error_splat_super;
2996         }
2997
2998         s->s_flags |= MS_ACTIVE;
2999
3000         security_sb_clone_mnt_opts(data->sb, s);
3001
3002         dprintk("<-- nfs4_xdev_mount() = 0\n");
3003         return mntroot;
3004
3005 out_err_nosb:
3006         nfs_free_server(server);
3007 out_err_noserver:
3008         dprintk("<-- nfs4_xdev_mount() = %d [error]\n", error);
3009         return ERR_PTR(error);
3010
3011 error_splat_super:
3012         if (server && !s->s_root)
3013                 bdi_unregister(&server->backing_dev_info);
3014 error_splat_bdi:
3015         deactivate_locked_super(s);
3016         dprintk("<-- nfs4_xdev_mount() = %d [splat]\n", error);
3017         return ERR_PTR(error);
3018 }
3019
3020 static struct dentry *
3021 nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags,
3022                            const char *dev_name, void *raw_data)
3023 {
3024         struct nfs_clone_mount *data = raw_data;
3025         struct super_block *s;
3026         struct nfs_server *server;
3027         struct dentry *mntroot;
3028         struct nfs_fh *mntfh;
3029         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
3030         struct nfs_sb_mountdata sb_mntdata = {
3031                 .mntflags = flags,
3032         };
3033         int error = -ENOMEM;
3034
3035         dprintk("--> nfs4_referral_get_sb()\n");
3036
3037         mntfh = nfs_alloc_fhandle();
3038         if (mntfh == NULL)
3039                 goto out_err_nofh;
3040
3041         /* create a new volume representation */
3042         server = nfs4_create_referral_server(data, mntfh);
3043         if (IS_ERR(server)) {
3044                 error = PTR_ERR(server);
3045                 goto out_err_noserver;
3046         }
3047         sb_mntdata.server = server;
3048
3049         if (server->flags & NFS4_MOUNT_UNSHARED)
3050                 compare_super = NULL;
3051
3052         /* -o noac implies -o sync */
3053         if (server->flags & NFS_MOUNT_NOAC)
3054                 sb_mntdata.mntflags |= MS_SYNCHRONOUS;
3055
3056         /* Get a superblock - note that we may end up sharing one that already exists */
3057         s = sget(&nfs4_fs_type, compare_super, nfs_set_super, &sb_mntdata);
3058         if (IS_ERR(s)) {
3059                 error = PTR_ERR(s);
3060                 goto out_err_nosb;
3061         }
3062
3063         if (s->s_fs_info != server) {
3064                 nfs_free_server(server);
3065                 server = NULL;
3066         } else {
3067                 error = nfs_bdi_register(server);
3068                 if (error)
3069                         goto error_splat_bdi;
3070         }
3071
3072         if (!s->s_root) {
3073                 /* initial superblock/root creation */
3074                 nfs4_fill_super(s);
3075                 nfs_fscache_get_super_cookie(s, NULL, data);
3076         }
3077
3078         mntroot = nfs4_get_root(s, mntfh, dev_name);
3079         if (IS_ERR(mntroot)) {
3080                 error = PTR_ERR(mntroot);
3081                 goto error_splat_super;
3082         }
3083         if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) {
3084                 dput(mntroot);
3085                 error = -ESTALE;
3086                 goto error_splat_super;
3087         }
3088
3089         s->s_flags |= MS_ACTIVE;
3090
3091         security_sb_clone_mnt_opts(data->sb, s);
3092
3093         nfs_free_fhandle(mntfh);
3094         dprintk("<-- nfs4_referral_get_sb() = 0\n");
3095         return mntroot;
3096
3097 out_err_nosb:
3098         nfs_free_server(server);
3099 out_err_noserver:
3100         nfs_free_fhandle(mntfh);
3101 out_err_nofh:
3102         dprintk("<-- nfs4_referral_get_sb() = %d [error]\n", error);
3103         return ERR_PTR(error);
3104
3105 error_splat_super:
3106         if (server && !s->s_root)
3107                 bdi_unregister(&server->backing_dev_info);
3108 error_splat_bdi:
3109         deactivate_locked_super(s);
3110         nfs_free_fhandle(mntfh);
3111         dprintk("<-- nfs4_referral_get_sb() = %d [splat]\n", error);
3112         return ERR_PTR(error);
3113 }
3114
3115 /*
3116  * Create an NFS4 server record on referral traversal
3117  */
3118 static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
3119                 int flags, const char *dev_name, void *raw_data)
3120 {
3121         struct nfs_clone_mount *data = raw_data;
3122         char *export_path;
3123         struct vfsmount *root_mnt;
3124         struct dentry *res;
3125
3126         dprintk("--> nfs4_referral_mount()\n");
3127
3128         export_path = data->mnt_path;
3129         data->mnt_path = "/";
3130
3131         root_mnt = nfs_do_root_mount(&nfs4_remote_referral_fs_type,
3132                         flags, data, data->hostname);
3133         data->mnt_path = export_path;
3134
3135         res = nfs_follow_remote_path(root_mnt, export_path);
3136         dprintk("<-- nfs4_referral_mount() = %ld%s\n",
3137                         IS_ERR(res) ? PTR_ERR(res) : 0,
3138                         IS_ERR(res) ? " [error]" : "");
3139         return res;
3140 }
3141
3142 #endif /* CONFIG_NFS_V4 */