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