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