> On Sep 11, 2019, at 12:16 PM, Scott Mayhew <smay...@redhat.com> wrote:
> 
> From: David Howells <dhowe...@redhat.com>
> 
> Split various bits relating to mount parameterisation out from
> fs/nfs/super.c into their own file to form the basis of filesystem context
> handling for NFS.
> 
> No other changes are made to the code beyond removing 'static' qualifiers.
> 
> Signed-off-by: David Howells <dhowe...@redhat.com>
> Signed-off-by: Al Viro <v...@zeniv.linux.org.uk>
> ---
> fs/nfs/Makefile     |    2 +-
> fs/nfs/fs_context.c | 1418 +++++++++++++++++++++++++++++++++++++++++++
> fs/nfs/internal.h   |   29 +
> fs/nfs/super.c      | 1411 ------------------------------------------
> 4 files changed, 1448 insertions(+), 1412 deletions(-)
> create mode 100644 fs/nfs/fs_context.c
> 
> diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
> index 34cdeaecccf6..2433c3e03cfa 100644
> --- a/fs/nfs/Makefile
> +++ b/fs/nfs/Makefile
> @@ -9,7 +9,7 @@ CFLAGS_nfstrace.o += -I$(src)
> nfs-y                         := client.o dir.o file.o getroot.o inode.o 
> super.o \
>                          io.o direct.o pagelist.o read.o symlink.o unlink.o \
>                          write.o namespace.o mount_clnt.o nfstrace.o \
> -                        export.o sysfs.o
> +                        export.o sysfs.o fs_context.o
> nfs-$(CONFIG_ROOT_NFS)        += nfsroot.o
> nfs-$(CONFIG_SYSCTL)  += sysctl.o
> nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o
> diff --git a/fs/nfs/fs_context.c b/fs/nfs/fs_context.c
> new file mode 100644
> index 000000000000..82b312a5cdde
> --- /dev/null
> +++ b/fs/nfs/fs_context.c
> @@ -0,0 +1,1418 @@
> +/* NFS mount handling.
> + *
> + * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowe...@redhat.com)
> + *
> + * Split from fs/nfs/super.c:
> + *
> + *  Copyright (C) 1992  Rick Sladkey
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public Licence
> + * as published by the Free Software Foundation; either version
> + * 2 of the Licence, or (at your option) any later version.
> + */

New source files should have an SPDX tag instead of boilerplate.
I suggest:

// SPDX-License-Identifier: GPL-2.0-only


> +
> +#include <linux/module.h>
> +#include <linux/fs.h>
> +#include <linux/parser.h>
> +#include <linux/nfs_fs.h>
> +#include <linux/nfs_mount.h>
> +#include <linux/nfs4_mount.h>
> +#include "nfs.h"
> +#include "internal.h"
> +
> +#define NFSDBG_FACILITY              NFSDBG_MOUNT
> +
> +#if IS_ENABLED(CONFIG_NFS_V3)
> +#define NFS_DEFAULT_VERSION 3
> +#else
> +#define NFS_DEFAULT_VERSION 2
> +#endif
> +
> +#define NFS_MAX_CONNECTIONS 16
> +
> +enum {
> +     /* Mount options that take no arguments */
> +     Opt_soft, Opt_softerr, Opt_hard,
> +     Opt_posix, Opt_noposix,
> +     Opt_cto, Opt_nocto,
> +     Opt_ac, Opt_noac,
> +     Opt_lock, Opt_nolock,
> +     Opt_udp, Opt_tcp, Opt_rdma,
> +     Opt_acl, Opt_noacl,
> +     Opt_rdirplus, Opt_nordirplus,
> +     Opt_sharecache, Opt_nosharecache,
> +     Opt_resvport, Opt_noresvport,
> +     Opt_fscache, Opt_nofscache,
> +     Opt_migration, Opt_nomigration,
> +
> +     /* Mount options that take integer arguments */
> +     Opt_port,
> +     Opt_rsize, Opt_wsize, Opt_bsize,
> +     Opt_timeo, Opt_retrans,
> +     Opt_acregmin, Opt_acregmax,
> +     Opt_acdirmin, Opt_acdirmax,
> +     Opt_actimeo,
> +     Opt_namelen,
> +     Opt_mountport,
> +     Opt_mountvers,
> +     Opt_minorversion,
> +
> +     /* Mount options that take string arguments */
> +     Opt_nfsvers,
> +     Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
> +     Opt_addr, Opt_mountaddr, Opt_clientaddr,
> +     Opt_nconnect,
> +     Opt_lookupcache,
> +     Opt_fscache_uniq,
> +     Opt_local_lock,
> +
> +     /* Special mount options */
> +     Opt_userspace, Opt_deprecated, Opt_sloppy,
> +
> +     Opt_err
> +};
> +
> +static const match_table_t nfs_mount_option_tokens = {
> +     { Opt_userspace, "bg" },
> +     { Opt_userspace, "fg" },
> +     { Opt_userspace, "retry=%s" },
> +
> +     { Opt_sloppy, "sloppy" },
> +
> +     { Opt_soft, "soft" },
> +     { Opt_softerr, "softerr" },
> +     { Opt_hard, "hard" },
> +     { Opt_deprecated, "intr" },
> +     { Opt_deprecated, "nointr" },
> +     { Opt_posix, "posix" },
> +     { Opt_noposix, "noposix" },
> +     { Opt_cto, "cto" },
> +     { Opt_nocto, "nocto" },
> +     { Opt_ac, "ac" },
> +     { Opt_noac, "noac" },
> +     { Opt_lock, "lock" },
> +     { Opt_nolock, "nolock" },
> +     { Opt_udp, "udp" },
> +     { Opt_tcp, "tcp" },
> +     { Opt_rdma, "rdma" },
> +     { Opt_acl, "acl" },
> +     { Opt_noacl, "noacl" },
> +     { Opt_rdirplus, "rdirplus" },
> +     { Opt_nordirplus, "nordirplus" },
> +     { Opt_sharecache, "sharecache" },
> +     { Opt_nosharecache, "nosharecache" },
> +     { Opt_resvport, "resvport" },
> +     { Opt_noresvport, "noresvport" },
> +     { Opt_fscache, "fsc" },
> +     { Opt_nofscache, "nofsc" },
> +     { Opt_migration, "migration" },
> +     { Opt_nomigration, "nomigration" },
> +
> +     { Opt_port, "port=%s" },
> +     { Opt_rsize, "rsize=%s" },
> +     { Opt_wsize, "wsize=%s" },
> +     { Opt_bsize, "bsize=%s" },
> +     { Opt_timeo, "timeo=%s" },
> +     { Opt_retrans, "retrans=%s" },
> +     { Opt_acregmin, "acregmin=%s" },
> +     { Opt_acregmax, "acregmax=%s" },
> +     { Opt_acdirmin, "acdirmin=%s" },
> +     { Opt_acdirmax, "acdirmax=%s" },
> +     { Opt_actimeo, "actimeo=%s" },
> +     { Opt_namelen, "namlen=%s" },
> +     { Opt_mountport, "mountport=%s" },
> +     { Opt_mountvers, "mountvers=%s" },
> +     { Opt_minorversion, "minorversion=%s" },
> +
> +     { Opt_nfsvers, "nfsvers=%s" },
> +     { Opt_nfsvers, "vers=%s" },
> +
> +     { Opt_sec, "sec=%s" },
> +     { Opt_proto, "proto=%s" },
> +     { Opt_mountproto, "mountproto=%s" },
> +     { Opt_addr, "addr=%s" },
> +     { Opt_clientaddr, "clientaddr=%s" },
> +     { Opt_mounthost, "mounthost=%s" },
> +     { Opt_mountaddr, "mountaddr=%s" },
> +
> +     { Opt_nconnect, "nconnect=%s" },
> +
> +     { Opt_lookupcache, "lookupcache=%s" },
> +     { Opt_fscache_uniq, "fsc=%s" },
> +     { Opt_local_lock, "local_lock=%s" },
> +
> +     /* The following needs to be listed after all other options */
> +     { Opt_nfsvers, "v%s" },
> +
> +     { Opt_err, NULL }
> +};
> +
> +enum {
> +     Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
> +     Opt_xprt_rdma6,
> +
> +     Opt_xprt_err
> +};
> +
> +static const match_table_t nfs_xprt_protocol_tokens = {
> +     { Opt_xprt_udp, "udp" },
> +     { Opt_xprt_udp6, "udp6" },
> +     { Opt_xprt_tcp, "tcp" },
> +     { Opt_xprt_tcp6, "tcp6" },
> +     { Opt_xprt_rdma, "rdma" },
> +     { Opt_xprt_rdma6, "rdma6" },
> +
> +     { Opt_xprt_err, NULL }
> +};
> +
> +enum {
> +     Opt_sec_none, Opt_sec_sys,
> +     Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
> +     Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
> +     Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
> +
> +     Opt_sec_err
> +};
> +
> +static const match_table_t nfs_secflavor_tokens = {
> +     { Opt_sec_none, "none" },
> +     { Opt_sec_none, "null" },
> +     { Opt_sec_sys, "sys" },
> +
> +     { Opt_sec_krb5, "krb5" },
> +     { Opt_sec_krb5i, "krb5i" },
> +     { Opt_sec_krb5p, "krb5p" },
> +
> +     { Opt_sec_lkey, "lkey" },
> +     { Opt_sec_lkeyi, "lkeyi" },
> +     { Opt_sec_lkeyp, "lkeyp" },
> +
> +     { Opt_sec_spkm, "spkm3" },
> +     { Opt_sec_spkmi, "spkm3i" },
> +     { Opt_sec_spkmp, "spkm3p" },
> +
> +     { Opt_sec_err, NULL }
> +};
> +
> +enum {
> +     Opt_lookupcache_all, Opt_lookupcache_positive,
> +     Opt_lookupcache_none,
> +
> +     Opt_lookupcache_err
> +};
> +
> +static match_table_t nfs_lookupcache_tokens = {
> +     { Opt_lookupcache_all, "all" },
> +     { Opt_lookupcache_positive, "pos" },
> +     { Opt_lookupcache_positive, "positive" },
> +     { Opt_lookupcache_none, "none" },
> +
> +     { Opt_lookupcache_err, NULL }
> +};
> +
> +enum {
> +     Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
> +     Opt_local_lock_none,
> +
> +     Opt_local_lock_err
> +};
> +
> +static match_table_t nfs_local_lock_tokens = {
> +     { Opt_local_lock_all, "all" },
> +     { Opt_local_lock_flock, "flock" },
> +     { Opt_local_lock_posix, "posix" },
> +     { Opt_local_lock_none, "none" },
> +
> +     { Opt_local_lock_err, NULL }
> +};
> +
> +enum {
> +     Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
> +     Opt_vers_4_1, Opt_vers_4_2,
> +
> +     Opt_vers_err
> +};
> +
> +static match_table_t nfs_vers_tokens = {
> +     { Opt_vers_2, "2" },
> +     { Opt_vers_3, "3" },
> +     { Opt_vers_4, "4" },
> +     { Opt_vers_4_0, "4.0" },
> +     { Opt_vers_4_1, "4.1" },
> +     { Opt_vers_4_2, "4.2" },
> +
> +     { Opt_vers_err, NULL }
> +};
> +
> +struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
> +{
> +     struct nfs_parsed_mount_data *data;
> +
> +     data = kzalloc(sizeof(*data), GFP_KERNEL);
> +     if (data) {
> +             data->timeo             = NFS_UNSPEC_TIMEO;
> +             data->retrans           = NFS_UNSPEC_RETRANS;
> +             data->acregmin          = NFS_DEF_ACREGMIN;
> +             data->acregmax          = NFS_DEF_ACREGMAX;
> +             data->acdirmin          = NFS_DEF_ACDIRMIN;
> +             data->acdirmax          = NFS_DEF_ACDIRMAX;
> +             data->mount_server.port = NFS_UNSPEC_PORT;
> +             data->nfs_server.port   = NFS_UNSPEC_PORT;
> +             data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> +             data->selected_flavor   = RPC_AUTH_MAXFLAVOR;
> +             data->minorversion      = 0;
> +             data->need_mount        = true;
> +             data->net               = current->nsproxy->net_ns;
> +             data->lsm_opts          = NULL;
> +     }
> +     return data;
> +}
> +
> +void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
> +{
> +     if (data) {
> +             kfree(data->client_address);
> +             kfree(data->mount_server.hostname);
> +             kfree(data->nfs_server.export_path);
> +             kfree(data->nfs_server.hostname);
> +             kfree(data->fscache_uniq);
> +             security_free_mnt_opts(&data->lsm_opts);
> +             kfree(data);
> +     }
> +}
> +
> +/*
> + * Sanity-check a server address provided by the mount command.
> + *
> + * Address family must be initialized, and address must not be
> + * the ANY address for that family.
> + */
> +static int nfs_verify_server_address(struct sockaddr *addr)
> +{
> +     switch (addr->sa_family) {
> +     case AF_INET: {
> +             struct sockaddr_in *sa = (struct sockaddr_in *)addr;
> +             return sa->sin_addr.s_addr != htonl(INADDR_ANY);
> +     }
> +     case AF_INET6: {
> +             struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
> +             return !ipv6_addr_any(sa);
> +     }
> +     }
> +
> +     dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
> +     return 0;
> +}
> +
> +/*
> + * Sanity check the NFS transport protocol.
> + *
> + */
> +static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data 
> *mnt)
> +{
> +     switch (mnt->nfs_server.protocol) {
> +     case XPRT_TRANSPORT_UDP:
> +     case XPRT_TRANSPORT_TCP:
> +     case XPRT_TRANSPORT_RDMA:
> +             break;
> +     default:
> +             mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> +     }
> +}
> +
> +/*
> + * For text based NFSv2/v3 mounts, the mount protocol transport default
> + * settings should depend upon the specified NFS transport.
> + */
> +static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data 
> *mnt)
> +{
> +     nfs_validate_transport_protocol(mnt);
> +
> +     if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
> +         mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
> +                     return;
> +     switch (mnt->nfs_server.protocol) {
> +     case XPRT_TRANSPORT_UDP:
> +             mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
> +             break;
> +     case XPRT_TRANSPORT_TCP:
> +     case XPRT_TRANSPORT_RDMA:
> +             mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
> +     }
> +}
> +
> +/*
> + * Add 'flavor' to 'auth_info' if not already present.
> + * Returns true if 'flavor' ends up in the list, false otherwise
> + */
> +static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
> +                           rpc_authflavor_t flavor)
> +{
> +     unsigned int i;
> +     unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
> +
> +     /* make sure this flavor isn't already in the list */
> +     for (i = 0; i < auth_info->flavor_len; i++) {
> +             if (flavor == auth_info->flavors[i])
> +                     return true;
> +     }
> +
> +     if (auth_info->flavor_len + 1 >= max_flavor_len) {
> +             dfprintk(MOUNT, "NFS: too many sec= flavors\n");
> +             return false;
> +     }
> +
> +     auth_info->flavors[auth_info->flavor_len++] = flavor;
> +     return true;
> +}
> +
> +/*
> + * Parse the value of the 'sec=' option.
> + */
> +static int nfs_parse_security_flavors(char *value,
> +                                   struct nfs_parsed_mount_data *mnt)
> +{
> +     substring_t args[MAX_OPT_ARGS];
> +     rpc_authflavor_t pseudoflavor;
> +     char *p;
> +
> +     dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
> +
> +     while ((p = strsep(&value, ":")) != NULL) {
> +             switch (match_token(p, nfs_secflavor_tokens, args)) {
> +             case Opt_sec_none:
> +                     pseudoflavor = RPC_AUTH_NULL;
> +                     break;
> +             case Opt_sec_sys:
> +                     pseudoflavor = RPC_AUTH_UNIX;
> +                     break;
> +             case Opt_sec_krb5:
> +                     pseudoflavor = RPC_AUTH_GSS_KRB5;
> +                     break;
> +             case Opt_sec_krb5i:
> +                     pseudoflavor = RPC_AUTH_GSS_KRB5I;
> +                     break;
> +             case Opt_sec_krb5p:
> +                     pseudoflavor = RPC_AUTH_GSS_KRB5P;
> +                     break;
> +             case Opt_sec_lkey:
> +                     pseudoflavor = RPC_AUTH_GSS_LKEY;
> +                     break;
> +             case Opt_sec_lkeyi:
> +                     pseudoflavor = RPC_AUTH_GSS_LKEYI;
> +                     break;
> +             case Opt_sec_lkeyp:
> +                     pseudoflavor = RPC_AUTH_GSS_LKEYP;
> +                     break;
> +             case Opt_sec_spkm:
> +                     pseudoflavor = RPC_AUTH_GSS_SPKM;
> +                     break;
> +             case Opt_sec_spkmi:
> +                     pseudoflavor = RPC_AUTH_GSS_SPKMI;
> +                     break;
> +             case Opt_sec_spkmp:
> +                     pseudoflavor = RPC_AUTH_GSS_SPKMP;
> +                     break;
> +             default:
> +                     dfprintk(MOUNT,
> +                              "NFS: sec= option '%s' not recognized\n", p);
> +                     return 0;
> +             }
> +
> +             if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
> +                     return 0;
> +     }
> +
> +     return 1;
> +}
> +
> +static int nfs_parse_version_string(char *string,
> +             struct nfs_parsed_mount_data *mnt,
> +             substring_t *args)
> +{
> +     mnt->flags &= ~NFS_MOUNT_VER3;
> +     switch (match_token(string, nfs_vers_tokens, args)) {
> +     case Opt_vers_2:
> +             mnt->version = 2;
> +             break;
> +     case Opt_vers_3:
> +             mnt->flags |= NFS_MOUNT_VER3;
> +             mnt->version = 3;
> +             break;
> +     case Opt_vers_4:
> +             /* Backward compatibility option. In future,
> +              * the mount program should always supply
> +              * a NFSv4 minor version number.
> +              */
> +             mnt->version = 4;
> +             break;
> +     case Opt_vers_4_0:
> +             mnt->version = 4;
> +             mnt->minorversion = 0;
> +             break;
> +     case Opt_vers_4_1:
> +             mnt->version = 4;
> +             mnt->minorversion = 1;
> +             break;
> +     case Opt_vers_4_2:
> +             mnt->version = 4;
> +             mnt->minorversion = 2;
> +             break;
> +     default:
> +             return 0;
> +     }
> +     return 1;
> +}
> +
> +static int nfs_get_option_str(substring_t args[], char **option)
> +{
> +     kfree(*option);
> +     *option = match_strdup(args);
> +     return !*option;
> +}
> +
> +static int nfs_get_option_ul(substring_t args[], unsigned long *option)
> +{
> +     int rc;
> +     char *string;
> +
> +     string = match_strdup(args);
> +     if (string == NULL)
> +             return -ENOMEM;
> +     rc = kstrtoul(string, 10, option);
> +     kfree(string);
> +
> +     return rc;
> +}
> +
> +static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
> +             unsigned long l_bound, unsigned long u_bound)
> +{
> +     int ret;
> +
> +     ret = nfs_get_option_ul(args, option);
> +     if (ret != 0)
> +             return ret;
> +     if (*option < l_bound || *option > u_bound)
> +             return -ERANGE;
> +     return 0;
> +}
> +
> +/*
> + * Error-check and convert a string of mount options from user space into
> + * a data structure.  The whole mount string is processed; bad options are
> + * skipped as they are encountered.  If there were no errors, return 1;
> + * otherwise return 0 (zero).
> + */
> +int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
> +{
> +     char *p, *string;
> +     int rc, sloppy = 0, invalid_option = 0;
> +     unsigned short protofamily = AF_UNSPEC;
> +     unsigned short mountfamily = AF_UNSPEC;
> +
> +     if (!raw) {
> +             dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
> +             return 1;
> +     }
> +     dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
> +
> +     rc = security_sb_eat_lsm_opts(raw, &mnt->lsm_opts);
> +     if (rc)
> +             goto out_security_failure;
> +
> +     while ((p = strsep(&raw, ",")) != NULL) {
> +             substring_t args[MAX_OPT_ARGS];
> +             unsigned long option;
> +             int token;
> +
> +             if (!*p)
> +                     continue;
> +
> +             dfprintk(MOUNT, "NFS:   parsing nfs mount option '%s'\n", p);
> +
> +             token = match_token(p, nfs_mount_option_tokens, args);
> +             switch (token) {
> +
> +             /*
> +              * boolean options:  foo/nofoo
> +              */
> +             case Opt_soft:
> +                     mnt->flags |= NFS_MOUNT_SOFT;
> +                     mnt->flags &= ~NFS_MOUNT_SOFTERR;
> +                     break;
> +             case Opt_softerr:
> +                     mnt->flags |= NFS_MOUNT_SOFTERR;
> +                     mnt->flags &= ~NFS_MOUNT_SOFT;
> +                     break;
> +             case Opt_hard:
> +                     mnt->flags &= ~(NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR);
> +                     break;
> +             case Opt_posix:
> +                     mnt->flags |= NFS_MOUNT_POSIX;
> +                     break;
> +             case Opt_noposix:
> +                     mnt->flags &= ~NFS_MOUNT_POSIX;
> +                     break;
> +             case Opt_cto:
> +                     mnt->flags &= ~NFS_MOUNT_NOCTO;
> +                     break;
> +             case Opt_nocto:
> +                     mnt->flags |= NFS_MOUNT_NOCTO;
> +                     break;
> +             case Opt_ac:
> +                     mnt->flags &= ~NFS_MOUNT_NOAC;
> +                     break;
> +             case Opt_noac:
> +                     mnt->flags |= NFS_MOUNT_NOAC;
> +                     break;
> +             case Opt_lock:
> +                     mnt->flags &= ~NFS_MOUNT_NONLM;
> +                     mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
> +                                     NFS_MOUNT_LOCAL_FCNTL);
> +                     break;
> +             case Opt_nolock:
> +                     mnt->flags |= NFS_MOUNT_NONLM;
> +                     mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
> +                                    NFS_MOUNT_LOCAL_FCNTL);
> +                     break;
> +             case Opt_udp:
> +                     mnt->flags &= ~NFS_MOUNT_TCP;
> +                     mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
> +                     break;
> +             case Opt_tcp:
> +                     mnt->flags |= NFS_MOUNT_TCP;
> +                     mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> +                     break;
> +             case Opt_rdma:
> +                     mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
> +                     mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
> +                     xprt_load_transport(p);
> +                     break;
> +             case Opt_acl:
> +                     mnt->flags &= ~NFS_MOUNT_NOACL;
> +                     break;
> +             case Opt_noacl:
> +                     mnt->flags |= NFS_MOUNT_NOACL;
> +                     break;
> +             case Opt_rdirplus:
> +                     mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
> +                     break;
> +             case Opt_nordirplus:
> +                     mnt->flags |= NFS_MOUNT_NORDIRPLUS;
> +                     break;
> +             case Opt_sharecache:
> +                     mnt->flags &= ~NFS_MOUNT_UNSHARED;
> +                     break;
> +             case Opt_nosharecache:
> +                     mnt->flags |= NFS_MOUNT_UNSHARED;
> +                     break;
> +             case Opt_resvport:
> +                     mnt->flags &= ~NFS_MOUNT_NORESVPORT;
> +                     break;
> +             case Opt_noresvport:
> +                     mnt->flags |= NFS_MOUNT_NORESVPORT;
> +                     break;
> +             case Opt_fscache:
> +                     mnt->options |= NFS_OPTION_FSCACHE;
> +                     kfree(mnt->fscache_uniq);
> +                     mnt->fscache_uniq = NULL;
> +                     break;
> +             case Opt_nofscache:
> +                     mnt->options &= ~NFS_OPTION_FSCACHE;
> +                     kfree(mnt->fscache_uniq);
> +                     mnt->fscache_uniq = NULL;
> +                     break;
> +             case Opt_migration:
> +                     mnt->options |= NFS_OPTION_MIGRATION;
> +                     break;
> +             case Opt_nomigration:
> +                     mnt->options &= ~NFS_OPTION_MIGRATION;
> +                     break;
> +
> +             /*
> +              * options that take numeric values
> +              */
> +             case Opt_port:
> +                     if (nfs_get_option_ul(args, &option) ||
> +                         option > USHRT_MAX)
> +                             goto out_invalid_value;
> +                     mnt->nfs_server.port = option;
> +                     break;
> +             case Opt_rsize:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->rsize = option;
> +                     break;
> +             case Opt_wsize:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->wsize = option;
> +                     break;
> +             case Opt_bsize:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->bsize = option;
> +                     break;
> +             case Opt_timeo:
> +                     if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
> +                             goto out_invalid_value;
> +                     mnt->timeo = option;
> +                     break;
> +             case Opt_retrans:
> +                     if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
> +                             goto out_invalid_value;
> +                     mnt->retrans = option;
> +                     break;
> +             case Opt_acregmin:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->acregmin = option;
> +                     break;
> +             case Opt_acregmax:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->acregmax = option;
> +                     break;
> +             case Opt_acdirmin:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->acdirmin = option;
> +                     break;
> +             case Opt_acdirmax:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->acdirmax = option;
> +                     break;
> +             case Opt_actimeo:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->acregmin = mnt->acregmax =
> +                     mnt->acdirmin = mnt->acdirmax = option;
> +                     break;
> +             case Opt_namelen:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     mnt->namlen = option;
> +                     break;
> +             case Opt_mountport:
> +                     if (nfs_get_option_ul(args, &option) ||
> +                         option > USHRT_MAX)
> +                             goto out_invalid_value;
> +                     mnt->mount_server.port = option;
> +                     break;
> +             case Opt_mountvers:
> +                     if (nfs_get_option_ul(args, &option) ||
> +                         option < NFS_MNT_VERSION ||
> +                         option > NFS_MNT3_VERSION)
> +                             goto out_invalid_value;
> +                     mnt->mount_server.version = option;
> +                     break;
> +             case Opt_minorversion:
> +                     if (nfs_get_option_ul(args, &option))
> +                             goto out_invalid_value;
> +                     if (option > NFS4_MAX_MINOR_VERSION)
> +                             goto out_invalid_value;
> +                     mnt->minorversion = option;
> +                     break;
> +
> +             /*
> +              * options that take text values
> +              */
> +             case Opt_nfsvers:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     rc = nfs_parse_version_string(string, mnt, args);
> +                     kfree(string);
> +                     if (!rc)
> +                             goto out_invalid_value;
> +                     break;
> +             case Opt_sec:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     rc = nfs_parse_security_flavors(string, mnt);
> +                     kfree(string);
> +                     if (!rc) {
> +                             dfprintk(MOUNT, "NFS:   unrecognized "
> +                                             "security flavor\n");
> +                             return 0;
> +                     }
> +                     break;
> +             case Opt_proto:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     token = match_token(string,
> +                                         nfs_xprt_protocol_tokens, args);
> +
> +                     protofamily = AF_INET;
> +                     switch (token) {
> +                     case Opt_xprt_udp6:
> +                             protofamily = AF_INET6;
> +                             /* fall through */
> +                     case Opt_xprt_udp:
> +                             mnt->flags &= ~NFS_MOUNT_TCP;
> +                             mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
> +                             break;
> +                     case Opt_xprt_tcp6:
> +                             protofamily = AF_INET6;
> +                             /* fall through */
> +                     case Opt_xprt_tcp:
> +                             mnt->flags |= NFS_MOUNT_TCP;
> +                             mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> +                             break;
> +                     case Opt_xprt_rdma6:
> +                             protofamily = AF_INET6;
> +                             /* fall through */
> +                     case Opt_xprt_rdma:
> +                             /* vector side protocols to TCP */
> +                             mnt->flags |= NFS_MOUNT_TCP;
> +                             mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
> +                             xprt_load_transport(string);
> +                             break;
> +                     default:
> +                             dfprintk(MOUNT, "NFS:   unrecognized "
> +                                             "transport protocol\n");
> +                             kfree(string);
> +                             return 0;
> +                     }
> +                     kfree(string);
> +                     break;
> +             case Opt_mountproto:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     token = match_token(string,
> +                                         nfs_xprt_protocol_tokens, args);
> +                     kfree(string);
> +
> +                     mountfamily = AF_INET;
> +                     switch (token) {
> +                     case Opt_xprt_udp6:
> +                             mountfamily = AF_INET6;
> +                             /* fall through */
> +                     case Opt_xprt_udp:
> +                             mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
> +                             break;
> +                     case Opt_xprt_tcp6:
> +                             mountfamily = AF_INET6;
> +                             /* fall through */
> +                     case Opt_xprt_tcp:
> +                             mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
> +                             break;
> +                     case Opt_xprt_rdma: /* not used for side protocols */
> +                     default:
> +                             dfprintk(MOUNT, "NFS:   unrecognized "
> +                                             "transport protocol\n");
> +                             return 0;
> +                     }
> +                     break;
> +             case Opt_addr:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     mnt->nfs_server.addrlen =
> +                             rpc_pton(mnt->net, string, strlen(string),
> +                                     (struct sockaddr *)
> +                                     &mnt->nfs_server.address,
> +                                     sizeof(mnt->nfs_server.address));
> +                     kfree(string);
> +                     if (mnt->nfs_server.addrlen == 0)
> +                             goto out_invalid_address;
> +                     break;
> +             case Opt_clientaddr:
> +                     if (nfs_get_option_str(args, &mnt->client_address))
> +                             goto out_nomem;
> +                     break;
> +             case Opt_mounthost:
> +                     if (nfs_get_option_str(args,
> +                                            &mnt->mount_server.hostname))
> +                             goto out_nomem;
> +                     break;
> +             case Opt_mountaddr:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     mnt->mount_server.addrlen =
> +                             rpc_pton(mnt->net, string, strlen(string),
> +                                     (struct sockaddr *)
> +                                     &mnt->mount_server.address,
> +                                     sizeof(mnt->mount_server.address));
> +                     kfree(string);
> +                     if (mnt->mount_server.addrlen == 0)
> +                             goto out_invalid_address;
> +                     break;
> +             case Opt_nconnect:
> +                     if (nfs_get_option_ul_bound(args, &option, 1, 
> NFS_MAX_CONNECTIONS))
> +                             goto out_invalid_value;
> +                     mnt->nfs_server.nconnect = option;
> +                     break;
> +             case Opt_lookupcache:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     token = match_token(string,
> +                                     nfs_lookupcache_tokens, args);
> +                     kfree(string);
> +                     switch (token) {
> +                             case Opt_lookupcache_all:
> +                                     mnt->flags &= 
> ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
> +                                     break;
> +                             case Opt_lookupcache_positive:
> +                                     mnt->flags &= 
> ~NFS_MOUNT_LOOKUP_CACHE_NONE;
> +                                     mnt->flags |= 
> NFS_MOUNT_LOOKUP_CACHE_NONEG;
> +                                     break;
> +                             case Opt_lookupcache_none:
> +                                     mnt->flags |= 
> NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
> +                                     break;
> +                             default:
> +                                     dfprintk(MOUNT, "NFS:   invalid "
> +                                                     "lookupcache 
> argument\n");
> +                                     return 0;
> +                     };
> +                     break;
> +             case Opt_fscache_uniq:
> +                     if (nfs_get_option_str(args, &mnt->fscache_uniq))
> +                             goto out_nomem;
> +                     mnt->options |= NFS_OPTION_FSCACHE;
> +                     break;
> +             case Opt_local_lock:
> +                     string = match_strdup(args);
> +                     if (string == NULL)
> +                             goto out_nomem;
> +                     token = match_token(string, nfs_local_lock_tokens,
> +                                     args);
> +                     kfree(string);
> +                     switch (token) {
> +                     case Opt_local_lock_all:
> +                             mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
> +                                            NFS_MOUNT_LOCAL_FCNTL);
> +                             break;
> +                     case Opt_local_lock_flock:
> +                             mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
> +                             break;
> +                     case Opt_local_lock_posix:
> +                             mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
> +                             break;
> +                     case Opt_local_lock_none:
> +                             mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
> +                                             NFS_MOUNT_LOCAL_FCNTL);
> +                             break;
> +                     default:
> +                             dfprintk(MOUNT, "NFS:   invalid "
> +                                             "local_lock argument\n");
> +                             return 0;
> +                     };
> +                     break;
> +
> +             /*
> +              * Special options
> +              */
> +             case Opt_sloppy:
> +                     sloppy = 1;
> +                     dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
> +                     break;
> +             case Opt_userspace:
> +             case Opt_deprecated:
> +                     dfprintk(MOUNT, "NFS:   ignoring mount option "
> +                                     "'%s'\n", p);
> +                     break;
> +
> +             default:
> +                     invalid_option = 1;
> +                     dfprintk(MOUNT, "NFS:   unrecognized mount option "
> +                                     "'%s'\n", p);
> +             }
> +     }
> +
> +     if (!sloppy && invalid_option)
> +             return 0;
> +
> +     if (mnt->minorversion && mnt->version != 4)
> +             goto out_minorversion_mismatch;
> +
> +     if (mnt->options & NFS_OPTION_MIGRATION &&
> +         (mnt->version != 4 || mnt->minorversion != 0))
> +             goto out_migration_misuse;
> +
> +     /*
> +      * verify that any proto=/mountproto= options match the address
> +      * families in the addr=/mountaddr= options.
> +      */
> +     if (protofamily != AF_UNSPEC &&
> +         protofamily != mnt->nfs_server.address.ss_family)
> +             goto out_proto_mismatch;
> +
> +     if (mountfamily != AF_UNSPEC) {
> +             if (mnt->mount_server.addrlen) {
> +                     if (mountfamily != mnt->mount_server.address.ss_family)
> +                             goto out_mountproto_mismatch;
> +             } else {
> +                     if (mountfamily != mnt->nfs_server.address.ss_family)
> +                             goto out_mountproto_mismatch;
> +             }
> +     }
> +
> +     return 1;
> +
> +out_mountproto_mismatch:
> +     printk(KERN_INFO "NFS: mount server address does not match mountproto= "
> +                      "option\n");
> +     return 0;
> +out_proto_mismatch:
> +     printk(KERN_INFO "NFS: server address does not match proto= option\n");
> +     return 0;
> +out_invalid_address:
> +     printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
> +     return 0;
> +out_invalid_value:
> +     printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
> +     return 0;
> +out_minorversion_mismatch:
> +     printk(KERN_INFO "NFS: mount option vers=%u does not support "
> +                      "minorversion=%u\n", mnt->version, mnt->minorversion);
> +     return 0;
> +out_migration_misuse:
> +     printk(KERN_INFO
> +             "NFS: 'migration' not supported for this NFS version\n");
> +     return 0;
> +out_nomem:
> +     printk(KERN_INFO "NFS: not enough memory to parse option\n");
> +     return 0;
> +out_security_failure:
> +     printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
> +     return 0;
> +}
> +
> +/*
> + * Split "dev_name" into "hostname:export_path".
> + *
> + * The leftmost colon demarks the split between the server's hostname
> + * and the export path.  If the hostname starts with a left square
> + * bracket, then it may contain colons.
> + *
> + * Note: caller frees hostname and export path, even on error.
> + */
> +static int nfs_parse_devname(const char *dev_name,
> +                          char **hostname, size_t maxnamlen,
> +                          char **export_path, size_t maxpathlen)
> +{
> +     size_t len;
> +     char *end;
> +
> +     if (unlikely(!dev_name || !*dev_name)) {
> +             dfprintk(MOUNT, "NFS: device name not specified\n");
> +             return -EINVAL;
> +     }
> +
> +     /* Is the host name protected with square brakcets? */
> +     if (*dev_name == '[') {
> +             end = strchr(++dev_name, ']');
> +             if (end == NULL || end[1] != ':')
> +                     goto out_bad_devname;
> +
> +             len = end - dev_name;
> +             end++;
> +     } else {
> +             char *comma;
> +
> +             end = strchr(dev_name, ':');
> +             if (end == NULL)
> +                     goto out_bad_devname;
> +             len = end - dev_name;
> +
> +             /* kill possible hostname list: not supported */
> +             comma = strchr(dev_name, ',');
> +             if (comma != NULL && comma < end)
> +                     len = comma - dev_name;
> +     }
> +
> +     if (len > maxnamlen)
> +             goto out_hostname;
> +
> +     /* N.B. caller will free nfs_server.hostname in all cases */
> +     *hostname = kstrndup(dev_name, len, GFP_KERNEL);
> +     if (*hostname == NULL)
> +             goto out_nomem;
> +     len = strlen(++end);
> +     if (len > maxpathlen)
> +             goto out_path;
> +     *export_path = kstrndup(end, len, GFP_KERNEL);
> +     if (!*export_path)
> +             goto out_nomem;
> +
> +     dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
> +     return 0;
> +
> +out_bad_devname:
> +     dfprintk(MOUNT, "NFS: device name not in host:path format\n");
> +     return -EINVAL;
> +
> +out_nomem:
> +     dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
> +     return -ENOMEM;
> +
> +out_hostname:
> +     dfprintk(MOUNT, "NFS: server hostname too long\n");
> +     return -ENAMETOOLONG;
> +
> +out_path:
> +     dfprintk(MOUNT, "NFS: export pathname too long\n");
> +     return -ENAMETOOLONG;
> +}
> +
> +/*
> + * Validate the NFS2/NFS3 mount data
> + * - fills in the mount root filehandle
> + *
> + * For option strings, user space handles the following behaviors:
> + *
> + * + DNS: mapping server host name to IP address ("addr=" option)
> + *
> + * + failure mode: how to behave if a mount request can't be handled
> + *   immediately ("fg/bg" option)
> + *
> + * + retry: how often to retry a mount request ("retry=" option)
> + *
> + * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
> + *   mountproto=tcp after mountproto=udp, and so on
> + */
> +static int nfs23_validate_mount_data(void *options,
> +                                  struct nfs_parsed_mount_data *args,
> +                                  struct nfs_fh *mntfh,
> +                                  const char *dev_name)
> +{
> +     struct nfs_mount_data *data = (struct nfs_mount_data *)options;
> +     struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
> +     int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
> +
> +     if (data == NULL)
> +             goto out_no_data;
> +
> +     args->version = NFS_DEFAULT_VERSION;
> +     switch (data->version) {
> +     case 1:
> +             data->namlen = 0; /* fall through */
> +     case 2:
> +             data->bsize = 0; /* fall through */
> +     case 3:
> +             if (data->flags & NFS_MOUNT_VER3)
> +                     goto out_no_v3;
> +             data->root.size = NFS2_FHSIZE;
> +             memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
> +             /* Turn off security negotiation */
> +             extra_flags |= NFS_MOUNT_SECFLAVOUR;
> +             /* fall through */
> +     case 4:
> +             if (data->flags & NFS_MOUNT_SECFLAVOUR)
> +                     goto out_no_sec;
> +             /* fall through */
> +     case 5:
> +             memset(data->context, 0, sizeof(data->context));
> +             /* fall through */
> +     case 6:
> +             if (data->flags & NFS_MOUNT_VER3) {
> +                     if (data->root.size > NFS3_FHSIZE || data->root.size == 
> 0)
> +                             goto out_invalid_fh;
> +                     mntfh->size = data->root.size;
> +                     args->version = 3;
> +             } else {
> +                     mntfh->size = NFS2_FHSIZE;
> +                     args->version = 2;
> +             }
> +
> +
> +             memcpy(mntfh->data, data->root.data, mntfh->size);
> +             if (mntfh->size < sizeof(mntfh->data))
> +                     memset(mntfh->data + mntfh->size, 0,
> +                            sizeof(mntfh->data) - mntfh->size);
> +
> +             /*
> +              * Translate to nfs_parsed_mount_data, which nfs_fill_super
> +              * can deal with.
> +              */
> +             args->flags             = data->flags & NFS_MOUNT_FLAGMASK;
> +             args->flags             |= extra_flags;
> +             args->rsize             = data->rsize;
> +             args->wsize             = data->wsize;
> +             args->timeo             = data->timeo;
> +             args->retrans           = data->retrans;
> +             args->acregmin          = data->acregmin;
> +             args->acregmax          = data->acregmax;
> +             args->acdirmin          = data->acdirmin;
> +             args->acdirmax          = data->acdirmax;
> +             args->need_mount        = false;
> +
> +             memcpy(sap, &data->addr, sizeof(data->addr));
> +             args->nfs_server.addrlen = sizeof(data->addr);
> +             args->nfs_server.port = ntohs(data->addr.sin_port);
> +             if (sap->sa_family != AF_INET ||
> +                 !nfs_verify_server_address(sap))
> +                     goto out_no_address;
> +
> +             if (!(data->flags & NFS_MOUNT_TCP))
> +                     args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
> +             /* N.B. caller will free nfs_server.hostname in all cases */
> +             args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
> +             args->namlen            = data->namlen;
> +             args->bsize             = data->bsize;
> +
> +             if (data->flags & NFS_MOUNT_SECFLAVOUR)
> +                     args->selected_flavor = data->pseudoflavor;
> +             else
> +                     args->selected_flavor = RPC_AUTH_UNIX;
> +             if (!args->nfs_server.hostname)
> +                     goto out_nomem;
> +
> +             if (!(data->flags & NFS_MOUNT_NONLM))
> +                     args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
> +                                      NFS_MOUNT_LOCAL_FCNTL);
> +             else
> +                     args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
> +                                     NFS_MOUNT_LOCAL_FCNTL);
> +             /*
> +              * The legacy version 6 binary mount data from userspace has a
> +              * field used only to transport selinux information into the
> +              * the kernel.  To continue to support that functionality we
> +              * have a touch of selinux knowledge here in the NFS code. The
> +              * userspace code converted context=blah to just blah so we are
> +              * converting back to the full string selinux understands.
> +              */
> +             if (data->context[0]){
> +#ifdef CONFIG_SECURITY_SELINUX
> +                     int rc;
> +                     data->context[NFS_MAX_CONTEXT_LEN] = '\0';
> +                     rc = security_add_mnt_opt("context", data->context,
> +                                     strlen(data->context), &args->lsm_opts);
> +                     if (rc)
> +                             return rc;
> +#else
> +                     return -EINVAL;
> +#endif
> +             }
> +
> +             break;
> +     default:
> +             return NFS_TEXT_DATA;
> +     }
> +
> +     return 0;
> +
> +out_no_data:
> +     dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
> +     return -EINVAL;
> +
> +out_no_v3:
> +     dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
> +              data->version);
> +     return -EINVAL;
> +
> +out_no_sec:
> +     dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
> +     return -EINVAL;
> +
> +out_nomem:
> +     dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
> +     return -ENOMEM;
> +
> +out_no_address:
> +     dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
> +     return -EINVAL;
> +
> +out_invalid_fh:
> +     dfprintk(MOUNT, "NFS: invalid root filehandle\n");
> +     return -EINVAL;
> +}
> +
> +#if IS_ENABLED(CONFIG_NFS_V4)
> +
> +static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
> +{
> +     args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
> +                      NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
> +}
> +
> +/*
> + * Validate NFSv4 mount options
> + */
> +static int nfs4_validate_mount_data(void *options,
> +                                 struct nfs_parsed_mount_data *args,
> +                                 const char *dev_name)
> +{
> +     struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
> +     struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
> +     char *c;
> +
> +     if (data == NULL)
> +             goto out_no_data;
> +
> +     args->version = 4;
> +
> +     switch (data->version) {
> +     case 1:
> +             if (data->host_addrlen > sizeof(args->nfs_server.address))
> +                     goto out_no_address;
> +             if (data->host_addrlen == 0)
> +                     goto out_no_address;
> +             args->nfs_server.addrlen = data->host_addrlen;
> +             if (copy_from_user(sap, data->host_addr, data->host_addrlen))
> +                     return -EFAULT;
> +             if (!nfs_verify_server_address(sap))
> +                     goto out_no_address;
> +             args->nfs_server.port = ntohs(((struct sockaddr_in 
> *)sap)->sin_port);
> +
> +             if (data->auth_flavourlen) {
> +                     rpc_authflavor_t pseudoflavor;
> +                     if (data->auth_flavourlen > 1)
> +                             goto out_inval_auth;
> +                     if (copy_from_user(&pseudoflavor,
> +                                        data->auth_flavours,
> +                                        sizeof(pseudoflavor)))
> +                             return -EFAULT;
> +                     args->selected_flavor = pseudoflavor;
> +             } else
> +                     args->selected_flavor = RPC_AUTH_UNIX;
> +
> +             c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
> +             if (IS_ERR(c))
> +                     return PTR_ERR(c);
> +             args->nfs_server.hostname = c;
> +
> +             c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
> +             if (IS_ERR(c))
> +                     return PTR_ERR(c);
> +             args->nfs_server.export_path = c;
> +             dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
> +
> +             c = strndup_user(data->client_addr.data, 16);
> +             if (IS_ERR(c))
> +                     return PTR_ERR(c);
> +             args->client_address = c;
> +
> +             /*
> +              * Translate to nfs_parsed_mount_data, which nfs4_fill_super
> +              * can deal with.
> +              */
> +
> +             args->flags     = data->flags & NFS4_MOUNT_FLAGMASK;
> +             args->rsize     = data->rsize;
> +             args->wsize     = data->wsize;
> +             args->timeo     = data->timeo;
> +             args->retrans   = data->retrans;
> +             args->acregmin  = data->acregmin;
> +             args->acregmax  = data->acregmax;
> +             args->acdirmin  = data->acdirmin;
> +             args->acdirmax  = data->acdirmax;
> +             args->nfs_server.protocol = data->proto;
> +             nfs_validate_transport_protocol(args);
> +             if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
> +                     goto out_invalid_transport_udp;
> +
> +             break;
> +     default:
> +             return NFS_TEXT_DATA;
> +     }
> +
> +     return 0;
> +
> +out_no_data:
> +     dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
> +     return -EINVAL;
> +
> +out_inval_auth:
> +     dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
> +              data->auth_flavourlen);
> +     return -EINVAL;
> +
> +out_no_address:
> +     dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
> +     return -EINVAL;
> +
> +out_invalid_transport_udp:
> +     dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
> +     return -EINVAL;
> +}
> +
> +int nfs_validate_mount_data(struct file_system_type *fs_type,
> +                         void *options,
> +                         struct nfs_parsed_mount_data *args,
> +                         struct nfs_fh *mntfh,
> +                         const char *dev_name)
> +{
> +     if (fs_type == &nfs_fs_type)
> +             return nfs23_validate_mount_data(options, args, mntfh, 
> dev_name);
> +     return nfs4_validate_mount_data(options, args, dev_name);
> +}
> +#else
> +int nfs_validate_mount_data(struct file_system_type *fs_type,
> +                         void *options,
> +                         struct nfs_parsed_mount_data *args,
> +                         struct nfs_fh *mntfh,
> +                         const char *dev_name)
> +{
> +     return nfs23_validate_mount_data(options, args, mntfh, dev_name);
> +}
> +#endif
> +
> +int nfs_validate_text_mount_data(void *options,
> +                              struct nfs_parsed_mount_data *args,
> +                              const char *dev_name)
> +{
> +     int port = 0;
> +     int max_namelen = PAGE_SIZE;
> +     int max_pathlen = NFS_MAXPATHLEN;
> +     struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
> +
> +     if (nfs_parse_mount_options((char *)options, args) == 0)
> +             return -EINVAL;
> +
> +     if (!nfs_verify_server_address(sap))
> +             goto out_no_address;
> +
> +     if (args->version == 4) {
> +#if IS_ENABLED(CONFIG_NFS_V4)
> +             if (args->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
> +                     port = NFS_RDMA_PORT;
> +             else
> +                     port = NFS_PORT;
> +             max_namelen = NFS4_MAXNAMLEN;
> +             max_pathlen = NFS4_MAXPATHLEN;
> +             nfs_validate_transport_protocol(args);
> +             if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
> +                     goto out_invalid_transport_udp;
> +             nfs4_validate_mount_flags(args);
> +#else
> +             goto out_v4_not_compiled;
> +#endif /* CONFIG_NFS_V4 */
> +     } else {
> +             nfs_set_mount_transport_protocol(args);
> +             if (args->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
> +                     port = NFS_RDMA_PORT;
> +     }
> +
> +     nfs_set_port(sap, &args->nfs_server.port, port);
> +
> +     return nfs_parse_devname(dev_name,
> +                                &args->nfs_server.hostname,
> +                                max_namelen,
> +                                &args->nfs_server.export_path,
> +                                max_pathlen);
> +
> +#if !IS_ENABLED(CONFIG_NFS_V4)
> +out_v4_not_compiled:
> +     dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
> +     return -EPROTONOSUPPORT;
> +#else
> +out_invalid_transport_udp:
> +     dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
> +     return -EINVAL;
> +#endif /* !CONFIG_NFS_V4 */
> +
> +out_no_address:
> +     dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
> +     return -EINVAL;
> +}
> diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
> index d512ec394559..b66fd35993b3 100644
> --- a/fs/nfs/internal.h
> +++ b/fs/nfs/internal.h
> @@ -7,6 +7,7 @@
> #include <linux/mount.h>
> #include <linux/security.h>
> #include <linux/crc32.h>
> +#include <linux/sunrpc/addr.h>
> #include <linux/nfs_page.h>
> #include <linux/wait_bit.h>
> 
> @@ -232,6 +233,22 @@ extern const struct svc_version nfs4_callback_version1;
> extern const struct svc_version nfs4_callback_version4;
> 
> struct nfs_pageio_descriptor;
> +
> +/* mount.c */
> +#define NFS_TEXT_DATA                1
> +
> +extern struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void);
> +extern void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data);
> +extern int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data 
> *mnt);
> +extern int nfs_validate_mount_data(struct file_system_type *fs_type,
> +                                void *options,
> +                                struct nfs_parsed_mount_data *args,
> +                                struct nfs_fh *mntfh,
> +                                const char *dev_name);
> +extern int nfs_validate_text_mount_data(void *options,
> +                                     struct nfs_parsed_mount_data *args,
> +                                     const char *dev_name);
> +
> /* pagelist.c */
> extern int __init nfs_init_nfspagecache(void);
> extern void nfs_destroy_nfspagecache(void);
> @@ -763,3 +780,15 @@ static inline bool nfs_error_is_fatal(int err)
>       }
> }
> 
> +/*
> + * Select between a default port value and a user-specified port value.
> + * If a zero value is set, then autobind will be used.
> + */
> +static inline void nfs_set_port(struct sockaddr *sap, int *port,
> +                             const unsigned short default_port)
> +{
> +     if (*port == NFS_UNSPEC_PORT)
> +             *port = default_port;
> +
> +     rpc_set_port(sap, *port);
> +}
> diff --git a/fs/nfs/super.c b/fs/nfs/super.c
> index d8702e57f7fc..886220d2da4e 100644
> --- a/fs/nfs/super.c
> +++ b/fs/nfs/super.c
> @@ -69,229 +69,6 @@
> #include "nfs.h"
> 
> #define NFSDBG_FACILITY               NFSDBG_VFS
> -#define NFS_TEXT_DATA                1
> -
> -#if IS_ENABLED(CONFIG_NFS_V3)
> -#define NFS_DEFAULT_VERSION 3
> -#else
> -#define NFS_DEFAULT_VERSION 2
> -#endif
> -
> -#define NFS_MAX_CONNECTIONS 16
> -
> -enum {
> -     /* Mount options that take no arguments */
> -     Opt_soft, Opt_softerr, Opt_hard,
> -     Opt_posix, Opt_noposix,
> -     Opt_cto, Opt_nocto,
> -     Opt_ac, Opt_noac,
> -     Opt_lock, Opt_nolock,
> -     Opt_udp, Opt_tcp, Opt_rdma,
> -     Opt_acl, Opt_noacl,
> -     Opt_rdirplus, Opt_nordirplus,
> -     Opt_sharecache, Opt_nosharecache,
> -     Opt_resvport, Opt_noresvport,
> -     Opt_fscache, Opt_nofscache,
> -     Opt_migration, Opt_nomigration,
> -
> -     /* Mount options that take integer arguments */
> -     Opt_port,
> -     Opt_rsize, Opt_wsize, Opt_bsize,
> -     Opt_timeo, Opt_retrans,
> -     Opt_acregmin, Opt_acregmax,
> -     Opt_acdirmin, Opt_acdirmax,
> -     Opt_actimeo,
> -     Opt_namelen,
> -     Opt_mountport,
> -     Opt_mountvers,
> -     Opt_minorversion,
> -
> -     /* Mount options that take string arguments */
> -     Opt_nfsvers,
> -     Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
> -     Opt_addr, Opt_mountaddr, Opt_clientaddr,
> -     Opt_nconnect,
> -     Opt_lookupcache,
> -     Opt_fscache_uniq,
> -     Opt_local_lock,
> -
> -     /* Special mount options */
> -     Opt_userspace, Opt_deprecated, Opt_sloppy,
> -
> -     Opt_err
> -};
> -
> -static const match_table_t nfs_mount_option_tokens = {
> -     { Opt_userspace, "bg" },
> -     { Opt_userspace, "fg" },
> -     { Opt_userspace, "retry=%s" },
> -
> -     { Opt_sloppy, "sloppy" },
> -
> -     { Opt_soft, "soft" },
> -     { Opt_softerr, "softerr" },
> -     { Opt_hard, "hard" },
> -     { Opt_deprecated, "intr" },
> -     { Opt_deprecated, "nointr" },
> -     { Opt_posix, "posix" },
> -     { Opt_noposix, "noposix" },
> -     { Opt_cto, "cto" },
> -     { Opt_nocto, "nocto" },
> -     { Opt_ac, "ac" },
> -     { Opt_noac, "noac" },
> -     { Opt_lock, "lock" },
> -     { Opt_nolock, "nolock" },
> -     { Opt_udp, "udp" },
> -     { Opt_tcp, "tcp" },
> -     { Opt_rdma, "rdma" },
> -     { Opt_acl, "acl" },
> -     { Opt_noacl, "noacl" },
> -     { Opt_rdirplus, "rdirplus" },
> -     { Opt_nordirplus, "nordirplus" },
> -     { Opt_sharecache, "sharecache" },
> -     { Opt_nosharecache, "nosharecache" },
> -     { Opt_resvport, "resvport" },
> -     { Opt_noresvport, "noresvport" },
> -     { Opt_fscache, "fsc" },
> -     { Opt_nofscache, "nofsc" },
> -     { Opt_migration, "migration" },
> -     { Opt_nomigration, "nomigration" },
> -
> -     { Opt_port, "port=%s" },
> -     { Opt_rsize, "rsize=%s" },
> -     { Opt_wsize, "wsize=%s" },
> -     { Opt_bsize, "bsize=%s" },
> -     { Opt_timeo, "timeo=%s" },
> -     { Opt_retrans, "retrans=%s" },
> -     { Opt_acregmin, "acregmin=%s" },
> -     { Opt_acregmax, "acregmax=%s" },
> -     { Opt_acdirmin, "acdirmin=%s" },
> -     { Opt_acdirmax, "acdirmax=%s" },
> -     { Opt_actimeo, "actimeo=%s" },
> -     { Opt_namelen, "namlen=%s" },
> -     { Opt_mountport, "mountport=%s" },
> -     { Opt_mountvers, "mountvers=%s" },
> -     { Opt_minorversion, "minorversion=%s" },
> -
> -     { Opt_nfsvers, "nfsvers=%s" },
> -     { Opt_nfsvers, "vers=%s" },
> -
> -     { Opt_sec, "sec=%s" },
> -     { Opt_proto, "proto=%s" },
> -     { Opt_mountproto, "mountproto=%s" },
> -     { Opt_addr, "addr=%s" },
> -     { Opt_clientaddr, "clientaddr=%s" },
> -     { Opt_mounthost, "mounthost=%s" },
> -     { Opt_mountaddr, "mountaddr=%s" },
> -
> -     { Opt_nconnect, "nconnect=%s" },
> -
> -     { Opt_lookupcache, "lookupcache=%s" },
> -     { Opt_fscache_uniq, "fsc=%s" },
> -     { Opt_local_lock, "local_lock=%s" },
> -
> -     /* The following needs to be listed after all other options */
> -     { Opt_nfsvers, "v%s" },
> -
> -     { Opt_err, NULL }
> -};
> -
> -enum {
> -     Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
> -     Opt_xprt_rdma6,
> -
> -     Opt_xprt_err
> -};
> -
> -static const match_table_t nfs_xprt_protocol_tokens = {
> -     { Opt_xprt_udp, "udp" },
> -     { Opt_xprt_udp6, "udp6" },
> -     { Opt_xprt_tcp, "tcp" },
> -     { Opt_xprt_tcp6, "tcp6" },
> -     { Opt_xprt_rdma, "rdma" },
> -     { Opt_xprt_rdma6, "rdma6" },
> -
> -     { Opt_xprt_err, NULL }
> -};
> -
> -enum {
> -     Opt_sec_none, Opt_sec_sys,
> -     Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
> -     Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
> -     Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
> -
> -     Opt_sec_err
> -};
> -
> -static const match_table_t nfs_secflavor_tokens = {
> -     { Opt_sec_none, "none" },
> -     { Opt_sec_none, "null" },
> -     { Opt_sec_sys, "sys" },
> -
> -     { Opt_sec_krb5, "krb5" },
> -     { Opt_sec_krb5i, "krb5i" },
> -     { Opt_sec_krb5p, "krb5p" },
> -
> -     { Opt_sec_lkey, "lkey" },
> -     { Opt_sec_lkeyi, "lkeyi" },
> -     { Opt_sec_lkeyp, "lkeyp" },
> -
> -     { Opt_sec_spkm, "spkm3" },
> -     { Opt_sec_spkmi, "spkm3i" },
> -     { Opt_sec_spkmp, "spkm3p" },
> -
> -     { Opt_sec_err, NULL }
> -};
> -
> -enum {
> -     Opt_lookupcache_all, Opt_lookupcache_positive,
> -     Opt_lookupcache_none,
> -
> -     Opt_lookupcache_err
> -};
> -
> -static match_table_t nfs_lookupcache_tokens = {
> -     { Opt_lookupcache_all, "all" },
> -     { Opt_lookupcache_positive, "pos" },
> -     { Opt_lookupcache_positive, "positive" },
> -     { Opt_lookupcache_none, "none" },
> -
> -     { Opt_lookupcache_err, NULL }
> -};
> -
> -enum {
> -     Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
> -     Opt_local_lock_none,
> -
> -     Opt_local_lock_err
> -};
> -
> -static match_table_t nfs_local_lock_tokens = {
> -     { Opt_local_lock_all, "all" },
> -     { Opt_local_lock_flock, "flock" },
> -     { Opt_local_lock_posix, "posix" },
> -     { Opt_local_lock_none, "none" },
> -
> -     { Opt_local_lock_err, NULL }
> -};
> -
> -enum {
> -     Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
> -     Opt_vers_4_1, Opt_vers_4_2,
> -
> -     Opt_vers_err
> -};
> -
> -static match_table_t nfs_vers_tokens = {
> -     { Opt_vers_2, "2" },
> -     { Opt_vers_3, "3" },
> -     { Opt_vers_4, "4" },
> -     { Opt_vers_4_0, "4.0" },
> -     { Opt_vers_4_1, "4.1" },
> -     { Opt_vers_4_2, "4.2" },
> -
> -     { Opt_vers_err, NULL }
> -};
> 
> static struct dentry *nfs_prepared_mount(struct file_system_type *fs_type,
>               int flags, const char *dev_name, void *raw_data);
> @@ -332,10 +109,6 @@ const struct super_operations nfs_sops = {
> EXPORT_SYMBOL_GPL(nfs_sops);
> 
> #if IS_ENABLED(CONFIG_NFS_V4)
> -static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *);
> -static int nfs4_validate_mount_data(void *options,
> -     struct nfs_parsed_mount_data *args, const char *dev_name);
> -
> struct file_system_type nfs4_fs_type = {
>       .owner          = THIS_MODULE,
>       .name           = "nfs4",
> @@ -932,141 +705,6 @@ void nfs_umount_begin(struct super_block *sb)
> }
> EXPORT_SYMBOL_GPL(nfs_umount_begin);
> 
> -static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
> -{
> -     struct nfs_parsed_mount_data *data;
> -
> -     data = kzalloc(sizeof(*data), GFP_KERNEL);
> -     if (data) {
> -             data->timeo             = NFS_UNSPEC_TIMEO;
> -             data->retrans           = NFS_UNSPEC_RETRANS;
> -             data->acregmin          = NFS_DEF_ACREGMIN;
> -             data->acregmax          = NFS_DEF_ACREGMAX;
> -             data->acdirmin          = NFS_DEF_ACDIRMIN;
> -             data->acdirmax          = NFS_DEF_ACDIRMAX;
> -             data->mount_server.port = NFS_UNSPEC_PORT;
> -             data->nfs_server.port   = NFS_UNSPEC_PORT;
> -             data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> -             data->selected_flavor   = RPC_AUTH_MAXFLAVOR;
> -             data->minorversion      = 0;
> -             data->need_mount        = true;
> -             data->net               = current->nsproxy->net_ns;
> -             data->lsm_opts          = NULL;
> -     }
> -     return data;
> -}
> -
> -static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
> -{
> -     if (data) {
> -             kfree(data->client_address);
> -             kfree(data->mount_server.hostname);
> -             kfree(data->nfs_server.export_path);
> -             kfree(data->nfs_server.hostname);
> -             kfree(data->fscache_uniq);
> -             security_free_mnt_opts(&data->lsm_opts);
> -             kfree(data);
> -     }
> -}
> -
> -/*
> - * Sanity-check a server address provided by the mount command.
> - *
> - * Address family must be initialized, and address must not be
> - * the ANY address for that family.
> - */
> -static int nfs_verify_server_address(struct sockaddr *addr)
> -{
> -     switch (addr->sa_family) {
> -     case AF_INET: {
> -             struct sockaddr_in *sa = (struct sockaddr_in *)addr;
> -             return sa->sin_addr.s_addr != htonl(INADDR_ANY);
> -     }
> -     case AF_INET6: {
> -             struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
> -             return !ipv6_addr_any(sa);
> -     }
> -     }
> -
> -     dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
> -     return 0;
> -}
> -
> -/*
> - * Select between a default port value and a user-specified port value.
> - * If a zero value is set, then autobind will be used.
> - */
> -static void nfs_set_port(struct sockaddr *sap, int *port,
> -                              const unsigned short default_port)
> -{
> -     if (*port == NFS_UNSPEC_PORT)
> -             *port = default_port;
> -
> -     rpc_set_port(sap, *port);
> -}
> -
> -/*
> - * Sanity check the NFS transport protocol.
> - *
> - */
> -static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data 
> *mnt)
> -{
> -     switch (mnt->nfs_server.protocol) {
> -     case XPRT_TRANSPORT_UDP:
> -     case XPRT_TRANSPORT_TCP:
> -     case XPRT_TRANSPORT_RDMA:
> -             break;
> -     default:
> -             mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> -     }
> -}
> -
> -/*
> - * For text based NFSv2/v3 mounts, the mount protocol transport default
> - * settings should depend upon the specified NFS transport.
> - */
> -static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data 
> *mnt)
> -{
> -     nfs_validate_transport_protocol(mnt);
> -
> -     if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
> -         mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
> -                     return;
> -     switch (mnt->nfs_server.protocol) {
> -     case XPRT_TRANSPORT_UDP:
> -             mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
> -             break;
> -     case XPRT_TRANSPORT_TCP:
> -     case XPRT_TRANSPORT_RDMA:
> -             mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
> -     }
> -}
> -
> -/*
> - * Add 'flavor' to 'auth_info' if not already present.
> - * Returns true if 'flavor' ends up in the list, false otherwise
> - */
> -static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
> -                           rpc_authflavor_t flavor)
> -{
> -     unsigned int i;
> -     unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
> -
> -     /* make sure this flavor isn't already in the list */
> -     for (i = 0; i < auth_info->flavor_len; i++) {
> -             if (flavor == auth_info->flavors[i])
> -                     return true;
> -     }
> -
> -     if (auth_info->flavor_len + 1 >= max_flavor_len) {
> -             dfprintk(MOUNT, "NFS: too many sec= flavors\n");
> -             return false;
> -     }
> -
> -     auth_info->flavors[auth_info->flavor_len++] = flavor;
> -     return true;
> -}
> -
> /*
>  * Return true if 'match' is in auth_info or auth_info is empty.
>  * Return false otherwise.
> @@ -1087,627 +725,6 @@ bool nfs_auth_info_match(const struct nfs_auth_info 
> *auth_info,
> }
> EXPORT_SYMBOL_GPL(nfs_auth_info_match);
> 
> -/*
> - * Parse the value of the 'sec=' option.
> - */
> -static int nfs_parse_security_flavors(char *value,
> -                                   struct nfs_parsed_mount_data *mnt)
> -{
> -     substring_t args[MAX_OPT_ARGS];
> -     rpc_authflavor_t pseudoflavor;
> -     char *p;
> -
> -     dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
> -
> -     while ((p = strsep(&value, ":")) != NULL) {
> -             switch (match_token(p, nfs_secflavor_tokens, args)) {
> -             case Opt_sec_none:
> -                     pseudoflavor = RPC_AUTH_NULL;
> -                     break;
> -             case Opt_sec_sys:
> -                     pseudoflavor = RPC_AUTH_UNIX;
> -                     break;
> -             case Opt_sec_krb5:
> -                     pseudoflavor = RPC_AUTH_GSS_KRB5;
> -                     break;
> -             case Opt_sec_krb5i:
> -                     pseudoflavor = RPC_AUTH_GSS_KRB5I;
> -                     break;
> -             case Opt_sec_krb5p:
> -                     pseudoflavor = RPC_AUTH_GSS_KRB5P;
> -                     break;
> -             case Opt_sec_lkey:
> -                     pseudoflavor = RPC_AUTH_GSS_LKEY;
> -                     break;
> -             case Opt_sec_lkeyi:
> -                     pseudoflavor = RPC_AUTH_GSS_LKEYI;
> -                     break;
> -             case Opt_sec_lkeyp:
> -                     pseudoflavor = RPC_AUTH_GSS_LKEYP;
> -                     break;
> -             case Opt_sec_spkm:
> -                     pseudoflavor = RPC_AUTH_GSS_SPKM;
> -                     break;
> -             case Opt_sec_spkmi:
> -                     pseudoflavor = RPC_AUTH_GSS_SPKMI;
> -                     break;
> -             case Opt_sec_spkmp:
> -                     pseudoflavor = RPC_AUTH_GSS_SPKMP;
> -                     break;
> -             default:
> -                     dfprintk(MOUNT,
> -                              "NFS: sec= option '%s' not recognized\n", p);
> -                     return 0;
> -             }
> -
> -             if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
> -                     return 0;
> -     }
> -
> -     return 1;
> -}
> -
> -static int nfs_parse_version_string(char *string,
> -             struct nfs_parsed_mount_data *mnt,
> -             substring_t *args)
> -{
> -     mnt->flags &= ~NFS_MOUNT_VER3;
> -     switch (match_token(string, nfs_vers_tokens, args)) {
> -     case Opt_vers_2:
> -             mnt->version = 2;
> -             break;
> -     case Opt_vers_3:
> -             mnt->flags |= NFS_MOUNT_VER3;
> -             mnt->version = 3;
> -             break;
> -     case Opt_vers_4:
> -             /* Backward compatibility option. In future,
> -              * the mount program should always supply
> -              * a NFSv4 minor version number.
> -              */
> -             mnt->version = 4;
> -             break;
> -     case Opt_vers_4_0:
> -             mnt->version = 4;
> -             mnt->minorversion = 0;
> -             break;
> -     case Opt_vers_4_1:
> -             mnt->version = 4;
> -             mnt->minorversion = 1;
> -             break;
> -     case Opt_vers_4_2:
> -             mnt->version = 4;
> -             mnt->minorversion = 2;
> -             break;
> -     default:
> -             return 0;
> -     }
> -     return 1;
> -}
> -
> -static int nfs_get_option_str(substring_t args[], char **option)
> -{
> -     kfree(*option);
> -     *option = match_strdup(args);
> -     return !*option;
> -}
> -
> -static int nfs_get_option_ul(substring_t args[], unsigned long *option)
> -{
> -     int rc;
> -     char *string;
> -
> -     string = match_strdup(args);
> -     if (string == NULL)
> -             return -ENOMEM;
> -     rc = kstrtoul(string, 10, option);
> -     kfree(string);
> -
> -     return rc;
> -}
> -
> -static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
> -             unsigned long l_bound, unsigned long u_bound)
> -{
> -     int ret;
> -
> -     ret = nfs_get_option_ul(args, option);
> -     if (ret != 0)
> -             return ret;
> -     if (*option < l_bound || *option > u_bound)
> -             return -ERANGE;
> -     return 0;
> -}
> -
> -/*
> - * Error-check and convert a string of mount options from user space into
> - * a data structure.  The whole mount string is processed; bad options are
> - * skipped as they are encountered.  If there were no errors, return 1;
> - * otherwise return 0 (zero).
> - */
> -static int nfs_parse_mount_options(char *raw,
> -                                struct nfs_parsed_mount_data *mnt)
> -{
> -     char *p, *string;
> -     int rc, sloppy = 0, invalid_option = 0;
> -     unsigned short protofamily = AF_UNSPEC;
> -     unsigned short mountfamily = AF_UNSPEC;
> -
> -     if (!raw) {
> -             dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
> -             return 1;
> -     }
> -     dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
> -
> -     rc = security_sb_eat_lsm_opts(raw, &mnt->lsm_opts);
> -     if (rc)
> -             goto out_security_failure;
> -
> -     while ((p = strsep(&raw, ",")) != NULL) {
> -             substring_t args[MAX_OPT_ARGS];
> -             unsigned long option;
> -             int token;
> -
> -             if (!*p)
> -                     continue;
> -
> -             dfprintk(MOUNT, "NFS:   parsing nfs mount option '%s'\n", p);
> -
> -             token = match_token(p, nfs_mount_option_tokens, args);
> -             switch (token) {
> -
> -             /*
> -              * boolean options:  foo/nofoo
> -              */
> -             case Opt_soft:
> -                     mnt->flags |= NFS_MOUNT_SOFT;
> -                     mnt->flags &= ~NFS_MOUNT_SOFTERR;
> -                     break;
> -             case Opt_softerr:
> -                     mnt->flags |= NFS_MOUNT_SOFTERR;
> -                     mnt->flags &= ~NFS_MOUNT_SOFT;
> -                     break;
> -             case Opt_hard:
> -                     mnt->flags &= ~(NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR);
> -                     break;
> -             case Opt_posix:
> -                     mnt->flags |= NFS_MOUNT_POSIX;
> -                     break;
> -             case Opt_noposix:
> -                     mnt->flags &= ~NFS_MOUNT_POSIX;
> -                     break;
> -             case Opt_cto:
> -                     mnt->flags &= ~NFS_MOUNT_NOCTO;
> -                     break;
> -             case Opt_nocto:
> -                     mnt->flags |= NFS_MOUNT_NOCTO;
> -                     break;
> -             case Opt_ac:
> -                     mnt->flags &= ~NFS_MOUNT_NOAC;
> -                     break;
> -             case Opt_noac:
> -                     mnt->flags |= NFS_MOUNT_NOAC;
> -                     break;
> -             case Opt_lock:
> -                     mnt->flags &= ~NFS_MOUNT_NONLM;
> -                     mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
> -                                     NFS_MOUNT_LOCAL_FCNTL);
> -                     break;
> -             case Opt_nolock:
> -                     mnt->flags |= NFS_MOUNT_NONLM;
> -                     mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
> -                                    NFS_MOUNT_LOCAL_FCNTL);
> -                     break;
> -             case Opt_udp:
> -                     mnt->flags &= ~NFS_MOUNT_TCP;
> -                     mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
> -                     break;
> -             case Opt_tcp:
> -                     mnt->flags |= NFS_MOUNT_TCP;
> -                     mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> -                     break;
> -             case Opt_rdma:
> -                     mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
> -                     mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
> -                     xprt_load_transport(p);
> -                     break;
> -             case Opt_acl:
> -                     mnt->flags &= ~NFS_MOUNT_NOACL;
> -                     break;
> -             case Opt_noacl:
> -                     mnt->flags |= NFS_MOUNT_NOACL;
> -                     break;
> -             case Opt_rdirplus:
> -                     mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
> -                     break;
> -             case Opt_nordirplus:
> -                     mnt->flags |= NFS_MOUNT_NORDIRPLUS;
> -                     break;
> -             case Opt_sharecache:
> -                     mnt->flags &= ~NFS_MOUNT_UNSHARED;
> -                     break;
> -             case Opt_nosharecache:
> -                     mnt->flags |= NFS_MOUNT_UNSHARED;
> -                     break;
> -             case Opt_resvport:
> -                     mnt->flags &= ~NFS_MOUNT_NORESVPORT;
> -                     break;
> -             case Opt_noresvport:
> -                     mnt->flags |= NFS_MOUNT_NORESVPORT;
> -                     break;
> -             case Opt_fscache:
> -                     mnt->options |= NFS_OPTION_FSCACHE;
> -                     kfree(mnt->fscache_uniq);
> -                     mnt->fscache_uniq = NULL;
> -                     break;
> -             case Opt_nofscache:
> -                     mnt->options &= ~NFS_OPTION_FSCACHE;
> -                     kfree(mnt->fscache_uniq);
> -                     mnt->fscache_uniq = NULL;
> -                     break;
> -             case Opt_migration:
> -                     mnt->options |= NFS_OPTION_MIGRATION;
> -                     break;
> -             case Opt_nomigration:
> -                     mnt->options &= ~NFS_OPTION_MIGRATION;
> -                     break;
> -
> -             /*
> -              * options that take numeric values
> -              */
> -             case Opt_port:
> -                     if (nfs_get_option_ul(args, &option) ||
> -                         option > USHRT_MAX)
> -                             goto out_invalid_value;
> -                     mnt->nfs_server.port = option;
> -                     break;
> -             case Opt_rsize:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->rsize = option;
> -                     break;
> -             case Opt_wsize:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->wsize = option;
> -                     break;
> -             case Opt_bsize:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->bsize = option;
> -                     break;
> -             case Opt_timeo:
> -                     if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
> -                             goto out_invalid_value;
> -                     mnt->timeo = option;
> -                     break;
> -             case Opt_retrans:
> -                     if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
> -                             goto out_invalid_value;
> -                     mnt->retrans = option;
> -                     break;
> -             case Opt_acregmin:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->acregmin = option;
> -                     break;
> -             case Opt_acregmax:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->acregmax = option;
> -                     break;
> -             case Opt_acdirmin:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->acdirmin = option;
> -                     break;
> -             case Opt_acdirmax:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->acdirmax = option;
> -                     break;
> -             case Opt_actimeo:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->acregmin = mnt->acregmax =
> -                     mnt->acdirmin = mnt->acdirmax = option;
> -                     break;
> -             case Opt_namelen:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     mnt->namlen = option;
> -                     break;
> -             case Opt_mountport:
> -                     if (nfs_get_option_ul(args, &option) ||
> -                         option > USHRT_MAX)
> -                             goto out_invalid_value;
> -                     mnt->mount_server.port = option;
> -                     break;
> -             case Opt_mountvers:
> -                     if (nfs_get_option_ul(args, &option) ||
> -                         option < NFS_MNT_VERSION ||
> -                         option > NFS_MNT3_VERSION)
> -                             goto out_invalid_value;
> -                     mnt->mount_server.version = option;
> -                     break;
> -             case Opt_minorversion:
> -                     if (nfs_get_option_ul(args, &option))
> -                             goto out_invalid_value;
> -                     if (option > NFS4_MAX_MINOR_VERSION)
> -                             goto out_invalid_value;
> -                     mnt->minorversion = option;
> -                     break;
> -
> -             /*
> -              * options that take text values
> -              */
> -             case Opt_nfsvers:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     rc = nfs_parse_version_string(string, mnt, args);
> -                     kfree(string);
> -                     if (!rc)
> -                             goto out_invalid_value;
> -                     break;
> -             case Opt_sec:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     rc = nfs_parse_security_flavors(string, mnt);
> -                     kfree(string);
> -                     if (!rc) {
> -                             dfprintk(MOUNT, "NFS:   unrecognized "
> -                                             "security flavor\n");
> -                             return 0;
> -                     }
> -                     break;
> -             case Opt_proto:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     token = match_token(string,
> -                                         nfs_xprt_protocol_tokens, args);
> -
> -                     protofamily = AF_INET;
> -                     switch (token) {
> -                     case Opt_xprt_udp6:
> -                             protofamily = AF_INET6;
> -                             /* fall through */
> -                     case Opt_xprt_udp:
> -                             mnt->flags &= ~NFS_MOUNT_TCP;
> -                             mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
> -                             break;
> -                     case Opt_xprt_tcp6:
> -                             protofamily = AF_INET6;
> -                             /* fall through */
> -                     case Opt_xprt_tcp:
> -                             mnt->flags |= NFS_MOUNT_TCP;
> -                             mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> -                             break;
> -                     case Opt_xprt_rdma6:
> -                             protofamily = AF_INET6;
> -                             /* fall through */
> -                     case Opt_xprt_rdma:
> -                             /* vector side protocols to TCP */
> -                             mnt->flags |= NFS_MOUNT_TCP;
> -                             mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
> -                             xprt_load_transport(string);
> -                             break;
> -                     default:
> -                             dfprintk(MOUNT, "NFS:   unrecognized "
> -                                             "transport protocol\n");
> -                             kfree(string);
> -                             return 0;
> -                     }
> -                     kfree(string);
> -                     break;
> -             case Opt_mountproto:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     token = match_token(string,
> -                                         nfs_xprt_protocol_tokens, args);
> -                     kfree(string);
> -
> -                     mountfamily = AF_INET;
> -                     switch (token) {
> -                     case Opt_xprt_udp6:
> -                             mountfamily = AF_INET6;
> -                             /* fall through */
> -                     case Opt_xprt_udp:
> -                             mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
> -                             break;
> -                     case Opt_xprt_tcp6:
> -                             mountfamily = AF_INET6;
> -                             /* fall through */
> -                     case Opt_xprt_tcp:
> -                             mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
> -                             break;
> -                     case Opt_xprt_rdma: /* not used for side protocols */
> -                     default:
> -                             dfprintk(MOUNT, "NFS:   unrecognized "
> -                                             "transport protocol\n");
> -                             return 0;
> -                     }
> -                     break;
> -             case Opt_addr:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     mnt->nfs_server.addrlen =
> -                             rpc_pton(mnt->net, string, strlen(string),
> -                                     (struct sockaddr *)
> -                                     &mnt->nfs_server.address,
> -                                     sizeof(mnt->nfs_server.address));
> -                     kfree(string);
> -                     if (mnt->nfs_server.addrlen == 0)
> -                             goto out_invalid_address;
> -                     break;
> -             case Opt_clientaddr:
> -                     if (nfs_get_option_str(args, &mnt->client_address))
> -                             goto out_nomem;
> -                     break;
> -             case Opt_mounthost:
> -                     if (nfs_get_option_str(args,
> -                                            &mnt->mount_server.hostname))
> -                             goto out_nomem;
> -                     break;
> -             case Opt_mountaddr:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     mnt->mount_server.addrlen =
> -                             rpc_pton(mnt->net, string, strlen(string),
> -                                     (struct sockaddr *)
> -                                     &mnt->mount_server.address,
> -                                     sizeof(mnt->mount_server.address));
> -                     kfree(string);
> -                     if (mnt->mount_server.addrlen == 0)
> -                             goto out_invalid_address;
> -                     break;
> -             case Opt_nconnect:
> -                     if (nfs_get_option_ul_bound(args, &option, 1, 
> NFS_MAX_CONNECTIONS))
> -                             goto out_invalid_value;
> -                     mnt->nfs_server.nconnect = option;
> -                     break;
> -             case Opt_lookupcache:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     token = match_token(string,
> -                                     nfs_lookupcache_tokens, args);
> -                     kfree(string);
> -                     switch (token) {
> -                             case Opt_lookupcache_all:
> -                                     mnt->flags &= 
> ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
> -                                     break;
> -                             case Opt_lookupcache_positive:
> -                                     mnt->flags &= 
> ~NFS_MOUNT_LOOKUP_CACHE_NONE;
> -                                     mnt->flags |= 
> NFS_MOUNT_LOOKUP_CACHE_NONEG;
> -                                     break;
> -                             case Opt_lookupcache_none:
> -                                     mnt->flags |= 
> NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
> -                                     break;
> -                             default:
> -                                     dfprintk(MOUNT, "NFS:   invalid "
> -                                                     "lookupcache 
> argument\n");
> -                                     return 0;
> -                     };
> -                     break;
> -             case Opt_fscache_uniq:
> -                     if (nfs_get_option_str(args, &mnt->fscache_uniq))
> -                             goto out_nomem;
> -                     mnt->options |= NFS_OPTION_FSCACHE;
> -                     break;
> -             case Opt_local_lock:
> -                     string = match_strdup(args);
> -                     if (string == NULL)
> -                             goto out_nomem;
> -                     token = match_token(string, nfs_local_lock_tokens,
> -                                     args);
> -                     kfree(string);
> -                     switch (token) {
> -                     case Opt_local_lock_all:
> -                             mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
> -                                            NFS_MOUNT_LOCAL_FCNTL);
> -                             break;
> -                     case Opt_local_lock_flock:
> -                             mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
> -                             break;
> -                     case Opt_local_lock_posix:
> -                             mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
> -                             break;
> -                     case Opt_local_lock_none:
> -                             mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
> -                                             NFS_MOUNT_LOCAL_FCNTL);
> -                             break;
> -                     default:
> -                             dfprintk(MOUNT, "NFS:   invalid "
> -                                             "local_lock argument\n");
> -                             return 0;
> -                     };
> -                     break;
> -
> -             /*
> -              * Special options
> -              */
> -             case Opt_sloppy:
> -                     sloppy = 1;
> -                     dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
> -                     break;
> -             case Opt_userspace:
> -             case Opt_deprecated:
> -                     dfprintk(MOUNT, "NFS:   ignoring mount option "
> -                                     "'%s'\n", p);
> -                     break;
> -
> -             default:
> -                     invalid_option = 1;
> -                     dfprintk(MOUNT, "NFS:   unrecognized mount option "
> -                                     "'%s'\n", p);
> -             }
> -     }
> -
> -     if (!sloppy && invalid_option)
> -             return 0;
> -
> -     if (mnt->minorversion && mnt->version != 4)
> -             goto out_minorversion_mismatch;
> -
> -     if (mnt->options & NFS_OPTION_MIGRATION &&
> -         (mnt->version != 4 || mnt->minorversion != 0))
> -             goto out_migration_misuse;
> -
> -     /*
> -      * verify that any proto=/mountproto= options match the address
> -      * families in the addr=/mountaddr= options.
> -      */
> -     if (protofamily != AF_UNSPEC &&
> -         protofamily != mnt->nfs_server.address.ss_family)
> -             goto out_proto_mismatch;
> -
> -     if (mountfamily != AF_UNSPEC) {
> -             if (mnt->mount_server.addrlen) {
> -                     if (mountfamily != mnt->mount_server.address.ss_family)
> -                             goto out_mountproto_mismatch;
> -             } else {
> -                     if (mountfamily != mnt->nfs_server.address.ss_family)
> -                             goto out_mountproto_mismatch;
> -             }
> -     }
> -
> -     return 1;
> -
> -out_mountproto_mismatch:
> -     printk(KERN_INFO "NFS: mount server address does not match mountproto= "
> -                      "option\n");
> -     return 0;
> -out_proto_mismatch:
> -     printk(KERN_INFO "NFS: server address does not match proto= option\n");
> -     return 0;
> -out_invalid_address:
> -     printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
> -     return 0;
> -out_invalid_value:
> -     printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
> -     return 0;
> -out_minorversion_mismatch:
> -     printk(KERN_INFO "NFS: mount option vers=%u does not support "
> -                      "minorversion=%u\n", mnt->version, mnt->minorversion);
> -     return 0;
> -out_migration_misuse:
> -     printk(KERN_INFO
> -             "NFS: 'migration' not supported for this NFS version\n");
> -     return 0;
> -out_nomem:
> -     printk(KERN_INFO "NFS: not enough memory to parse option\n");
> -     return 0;
> -out_security_failure:
> -     printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
> -     return 0;
> -}
> -
> /*
>  * Ensure that a specified authtype in args->auth_info is supported by
>  * the server. Returns 0 and sets args->selected_flavor if it's ok, and
> @@ -1908,327 +925,6 @@ struct dentry *nfs_try_mount(int flags, const char 
> *dev_name,
> }
> EXPORT_SYMBOL_GPL(nfs_try_mount);
> 
> -/*
> - * Split "dev_name" into "hostname:export_path".
> - *
> - * The leftmost colon demarks the split between the server's hostname
> - * and the export path.  If the hostname starts with a left square
> - * bracket, then it may contain colons.
> - *
> - * Note: caller frees hostname and export path, even on error.
> - */
> -static int nfs_parse_devname(const char *dev_name,
> -                          char **hostname, size_t maxnamlen,
> -                          char **export_path, size_t maxpathlen)
> -{
> -     size_t len;
> -     char *end;
> -
> -     if (unlikely(!dev_name || !*dev_name)) {
> -             dfprintk(MOUNT, "NFS: device name not specified\n");
> -             return -EINVAL;
> -     }
> -
> -     /* Is the host name protected with square brakcets? */
> -     if (*dev_name == '[') {
> -             end = strchr(++dev_name, ']');
> -             if (end == NULL || end[1] != ':')
> -                     goto out_bad_devname;
> -
> -             len = end - dev_name;
> -             end++;
> -     } else {
> -             char *comma;
> -
> -             end = strchr(dev_name, ':');
> -             if (end == NULL)
> -                     goto out_bad_devname;
> -             len = end - dev_name;
> -
> -             /* kill possible hostname list: not supported */
> -             comma = strchr(dev_name, ',');
> -             if (comma != NULL && comma < end)
> -                     len = comma - dev_name;
> -     }
> -
> -     if (len > maxnamlen)
> -             goto out_hostname;
> -
> -     /* N.B. caller will free nfs_server.hostname in all cases */
> -     *hostname = kstrndup(dev_name, len, GFP_KERNEL);
> -     if (*hostname == NULL)
> -             goto out_nomem;
> -     len = strlen(++end);
> -     if (len > maxpathlen)
> -             goto out_path;
> -     *export_path = kstrndup(end, len, GFP_KERNEL);
> -     if (!*export_path)
> -             goto out_nomem;
> -
> -     dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
> -     return 0;
> -
> -out_bad_devname:
> -     dfprintk(MOUNT, "NFS: device name not in host:path format\n");
> -     return -EINVAL;
> -
> -out_nomem:
> -     dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
> -     return -ENOMEM;
> -
> -out_hostname:
> -     dfprintk(MOUNT, "NFS: server hostname too long\n");
> -     return -ENAMETOOLONG;
> -
> -out_path:
> -     dfprintk(MOUNT, "NFS: export pathname too long\n");
> -     return -ENAMETOOLONG;
> -}
> -
> -/*
> - * Validate the NFS2/NFS3 mount data
> - * - fills in the mount root filehandle
> - *
> - * For option strings, user space handles the following behaviors:
> - *
> - * + DNS: mapping server host name to IP address ("addr=" option)
> - *
> - * + failure mode: how to behave if a mount request can't be handled
> - *   immediately ("fg/bg" option)
> - *
> - * + retry: how often to retry a mount request ("retry=" option)
> - *
> - * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
> - *   mountproto=tcp after mountproto=udp, and so on
> - */
> -static int nfs23_validate_mount_data(void *options,
> -                                  struct nfs_parsed_mount_data *args,
> -                                  struct nfs_fh *mntfh,
> -                                  const char *dev_name)
> -{
> -     struct nfs_mount_data *data = (struct nfs_mount_data *)options;
> -     struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
> -     int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
> -
> -     if (data == NULL)
> -             goto out_no_data;
> -
> -     args->version = NFS_DEFAULT_VERSION;
> -     switch (data->version) {
> -     case 1:
> -             data->namlen = 0; /* fall through */
> -     case 2:
> -             data->bsize = 0; /* fall through */
> -     case 3:
> -             if (data->flags & NFS_MOUNT_VER3)
> -                     goto out_no_v3;
> -             data->root.size = NFS2_FHSIZE;
> -             memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
> -             /* Turn off security negotiation */
> -             extra_flags |= NFS_MOUNT_SECFLAVOUR;
> -             /* fall through */
> -     case 4:
> -             if (data->flags & NFS_MOUNT_SECFLAVOUR)
> -                     goto out_no_sec;
> -             /* fall through */
> -     case 5:
> -             memset(data->context, 0, sizeof(data->context));
> -             /* fall through */
> -     case 6:
> -             if (data->flags & NFS_MOUNT_VER3) {
> -                     if (data->root.size > NFS3_FHSIZE || data->root.size == 
> 0)
> -                             goto out_invalid_fh;
> -                     mntfh->size = data->root.size;
> -                     args->version = 3;
> -             } else {
> -                     mntfh->size = NFS2_FHSIZE;
> -                     args->version = 2;
> -             }
> -
> -
> -             memcpy(mntfh->data, data->root.data, mntfh->size);
> -             if (mntfh->size < sizeof(mntfh->data))
> -                     memset(mntfh->data + mntfh->size, 0,
> -                            sizeof(mntfh->data) - mntfh->size);
> -
> -             /*
> -              * Translate to nfs_parsed_mount_data, which nfs_fill_super
> -              * can deal with.
> -              */
> -             args->flags             = data->flags & NFS_MOUNT_FLAGMASK;
> -             args->flags             |= extra_flags;
> -             args->rsize             = data->rsize;
> -             args->wsize             = data->wsize;
> -             args->timeo             = data->timeo;
> -             args->retrans           = data->retrans;
> -             args->acregmin          = data->acregmin;
> -             args->acregmax          = data->acregmax;
> -             args->acdirmin          = data->acdirmin;
> -             args->acdirmax          = data->acdirmax;
> -             args->need_mount        = false;
> -
> -             memcpy(sap, &data->addr, sizeof(data->addr));
> -             args->nfs_server.addrlen = sizeof(data->addr);
> -             args->nfs_server.port = ntohs(data->addr.sin_port);
> -             if (sap->sa_family != AF_INET ||
> -                 !nfs_verify_server_address(sap))
> -                     goto out_no_address;
> -
> -             if (!(data->flags & NFS_MOUNT_TCP))
> -                     args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
> -             /* N.B. caller will free nfs_server.hostname in all cases */
> -             args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
> -             args->namlen            = data->namlen;
> -             args->bsize             = data->bsize;
> -
> -             if (data->flags & NFS_MOUNT_SECFLAVOUR)
> -                     args->selected_flavor = data->pseudoflavor;
> -             else
> -                     args->selected_flavor = RPC_AUTH_UNIX;
> -             if (!args->nfs_server.hostname)
> -                     goto out_nomem;
> -
> -             if (!(data->flags & NFS_MOUNT_NONLM))
> -                     args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
> -                                      NFS_MOUNT_LOCAL_FCNTL);
> -             else
> -                     args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
> -                                     NFS_MOUNT_LOCAL_FCNTL);
> -             /*
> -              * The legacy version 6 binary mount data from userspace has a
> -              * field used only to transport selinux information into the
> -              * the kernel.  To continue to support that functionality we
> -              * have a touch of selinux knowledge here in the NFS code. The
> -              * userspace code converted context=blah to just blah so we are
> -              * converting back to the full string selinux understands.
> -              */
> -             if (data->context[0]){
> -#ifdef CONFIG_SECURITY_SELINUX
> -                     int rc;
> -                     data->context[NFS_MAX_CONTEXT_LEN] = '\0';
> -                     rc = security_add_mnt_opt("context", data->context,
> -                                     strlen(data->context), &args->lsm_opts);
> -                     if (rc)
> -                             return rc;
> -#else
> -                     return -EINVAL;
> -#endif
> -             }
> -
> -             break;
> -     default:
> -             return NFS_TEXT_DATA;
> -     }
> -
> -     return 0;
> -
> -out_no_data:
> -     dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
> -     return -EINVAL;
> -
> -out_no_v3:
> -     dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
> -              data->version);
> -     return -EINVAL;
> -
> -out_no_sec:
> -     dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
> -     return -EINVAL;
> -
> -out_nomem:
> -     dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
> -     return -ENOMEM;
> -
> -out_no_address:
> -     dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
> -     return -EINVAL;
> -
> -out_invalid_fh:
> -     dfprintk(MOUNT, "NFS: invalid root filehandle\n");
> -     return -EINVAL;
> -}
> -
> -#if IS_ENABLED(CONFIG_NFS_V4)
> -static int nfs_validate_mount_data(struct file_system_type *fs_type,
> -                                void *options,
> -                                struct nfs_parsed_mount_data *args,
> -                                struct nfs_fh *mntfh,
> -                                const char *dev_name)
> -{
> -     if (fs_type == &nfs_fs_type)
> -             return nfs23_validate_mount_data(options, args, mntfh, 
> dev_name);
> -     return nfs4_validate_mount_data(options, args, dev_name);
> -}
> -#else
> -static int nfs_validate_mount_data(struct file_system_type *fs_type,
> -                                void *options,
> -                                struct nfs_parsed_mount_data *args,
> -                                struct nfs_fh *mntfh,
> -                                const char *dev_name)
> -{
> -     return nfs23_validate_mount_data(options, args, mntfh, dev_name);
> -}
> -#endif
> -
> -static int nfs_validate_text_mount_data(void *options,
> -                                     struct nfs_parsed_mount_data *args,
> -                                     const char *dev_name)
> -{
> -     int port = 0;
> -     int max_namelen = PAGE_SIZE;
> -     int max_pathlen = NFS_MAXPATHLEN;
> -     struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
> -
> -     if (nfs_parse_mount_options((char *)options, args) == 0)
> -             return -EINVAL;
> -
> -     if (!nfs_verify_server_address(sap))
> -             goto out_no_address;
> -
> -     if (args->version == 4) {
> -#if IS_ENABLED(CONFIG_NFS_V4)
> -             if (args->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
> -                     port = NFS_RDMA_PORT;
> -             else
> -                     port = NFS_PORT;
> -             max_namelen = NFS4_MAXNAMLEN;
> -             max_pathlen = NFS4_MAXPATHLEN;
> -             nfs_validate_transport_protocol(args);
> -             if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
> -                     goto out_invalid_transport_udp;
> -             nfs4_validate_mount_flags(args);
> -#else
> -             goto out_v4_not_compiled;
> -#endif /* CONFIG_NFS_V4 */
> -     } else {
> -             nfs_set_mount_transport_protocol(args);
> -             if (args->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
> -                     port = NFS_RDMA_PORT;
> -     }
> -
> -     nfs_set_port(sap, &args->nfs_server.port, port);
> -
> -     return nfs_parse_devname(dev_name,
> -                                &args->nfs_server.hostname,
> -                                max_namelen,
> -                                &args->nfs_server.export_path,
> -                                max_pathlen);
> -
> -#if !IS_ENABLED(CONFIG_NFS_V4)
> -out_v4_not_compiled:
> -     dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
> -     return -EPROTONOSUPPORT;
> -#else
> -out_invalid_transport_udp:
> -     dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
> -     return -EINVAL;
> -#endif /* !CONFIG_NFS_V4 */
> -
> -out_no_address:
> -     dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
> -     return -EINVAL;
> -}
> -
> #define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
>               | NFS_MOUNT_SECURE \
>               | NFS_MOUNT_TCP \
> @@ -2719,113 +1415,6 @@ nfs_prepared_mount(struct file_system_type *fs_type, 
> int flags,
> 
> #if IS_ENABLED(CONFIG_NFS_V4)
> 
> -static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
> -{
> -     args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
> -                      NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
> -}
> -
> -/*
> - * Validate NFSv4 mount options
> - */
> -static int nfs4_validate_mount_data(void *options,
> -                                 struct nfs_parsed_mount_data *args,
> -                                 const char *dev_name)
> -{
> -     struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
> -     struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
> -     char *c;
> -
> -     if (data == NULL)
> -             goto out_no_data;
> -
> -     args->version = 4;
> -
> -     switch (data->version) {
> -     case 1:
> -             if (data->host_addrlen > sizeof(args->nfs_server.address))
> -                     goto out_no_address;
> -             if (data->host_addrlen == 0)
> -                     goto out_no_address;
> -             args->nfs_server.addrlen = data->host_addrlen;
> -             if (copy_from_user(sap, data->host_addr, data->host_addrlen))
> -                     return -EFAULT;
> -             if (!nfs_verify_server_address(sap))
> -                     goto out_no_address;
> -             args->nfs_server.port = ntohs(((struct sockaddr_in 
> *)sap)->sin_port);
> -
> -             if (data->auth_flavourlen) {
> -                     rpc_authflavor_t pseudoflavor;
> -                     if (data->auth_flavourlen > 1)
> -                             goto out_inval_auth;
> -                     if (copy_from_user(&pseudoflavor,
> -                                        data->auth_flavours,
> -                                        sizeof(pseudoflavor)))
> -                             return -EFAULT;
> -                     args->selected_flavor = pseudoflavor;
> -             } else
> -                     args->selected_flavor = RPC_AUTH_UNIX;
> -
> -             c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
> -             if (IS_ERR(c))
> -                     return PTR_ERR(c);
> -             args->nfs_server.hostname = c;
> -
> -             c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
> -             if (IS_ERR(c))
> -                     return PTR_ERR(c);
> -             args->nfs_server.export_path = c;
> -             dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
> -
> -             c = strndup_user(data->client_addr.data, 16);
> -             if (IS_ERR(c))
> -                     return PTR_ERR(c);
> -             args->client_address = c;
> -
> -             /*
> -              * Translate to nfs_parsed_mount_data, which nfs4_fill_super
> -              * can deal with.
> -              */
> -
> -             args->flags     = data->flags & NFS4_MOUNT_FLAGMASK;
> -             args->rsize     = data->rsize;
> -             args->wsize     = data->wsize;
> -             args->timeo     = data->timeo;
> -             args->retrans   = data->retrans;
> -             args->acregmin  = data->acregmin;
> -             args->acregmax  = data->acregmax;
> -             args->acdirmin  = data->acdirmin;
> -             args->acdirmax  = data->acdirmax;
> -             args->nfs_server.protocol = data->proto;
> -             nfs_validate_transport_protocol(args);
> -             if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
> -                     goto out_invalid_transport_udp;
> -
> -             break;
> -     default:
> -             return NFS_TEXT_DATA;
> -     }
> -
> -     return 0;
> -
> -out_no_data:
> -     dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
> -     return -EINVAL;
> -
> -out_inval_auth:
> -     dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
> -              data->auth_flavourlen);
> -     return -EINVAL;
> -
> -out_no_address:
> -     dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
> -     return -EINVAL;
> -
> -out_invalid_transport_udp:
> -     dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
> -     return -EINVAL;
> -}
> -
> /*
>  * NFS v4 module parameters need to stay in the
>  * NFS client for backwards compatibility
> -- 
> 2.17.2
> 

--
Chuck Lever
chuckle...@gmail.com



Reply via email to