Re: [PATCH 24/27] NFS: Add fs_context support. [ver #5]

[Anna Schumaker]

Hi David,

Several comments below:

On 06/14/2017 11:18 AM, David Howells wrote:
> Add filesystem context support to NFS, parsing the options in advance and
> attaching the information to struct nfs_fs_context.  The highlights are:
> 
>  (*) Merge nfs_mount_info and nfs_clone_mount into nfs_fs_context.  This
>      structure represents NFS's superblock config.
> 
>  (*) Make use of the VFS's parsing support to split comma-separated lists.
> 
>  (*) Pin the NFS protocol module in the nfs_fs_context.
> 
>  (*) Attach supplementary error information to fs_context.  This has the
>      downside that these strings must be static and can't be formatted.
> 
>  (*) Remove the auxiliary file_system_type structs since the information
>      necessary can be conveyed in the nfs_fs_context struct instead.
> 
>  (*) Root mounts are made by duplicating the config for the requested mount
>      so as to have the same parameters.  Submounts pick up their parameters
>      from the parent superblock.
> 
> Signed-off-by: David Howells <dhowells@xxxxxxxxxx>
> ---
> 
>  fs/nfs/client.c         |   74 +++--
>  fs/nfs/fs_context.c     |  652 ++++++++++++++++++++++++++++-------------------
>  fs/nfs/getroot.c        |   72 +++--
>  fs/nfs/internal.h       |  104 +++----
>  fs/nfs/namespace.c      |   76 ++++-
>  fs/nfs/nfs3_fs.h        |    2 
>  fs/nfs/nfs3client.c     |    6 
>  fs/nfs/nfs3proc.c       |    2 
>  fs/nfs/nfs4_fs.h        |    4 
>  fs/nfs/nfs4client.c     |   44 ++-
>  fs/nfs/nfs4namespace.c  |  208 +++++++++------
>  fs/nfs/nfs4proc.c       |    3 
>  fs/nfs/nfs4super.c      |  220 ++++++++--------
>  fs/nfs/proc.c           |    2 
>  fs/nfs/super.c          |  381 ++++++++-------------------
>  include/linux/nfs_xdr.h |    7 -
>  16 files changed, 940 insertions(+), 917 deletions(-)
> 
> diff --git a/fs/nfs/client.c b/fs/nfs/client.c
> index d25dfa15f2ec..8c9b610ca952 100644
> --- a/fs/nfs/client.c
> +++ b/fs/nfs/client.c
> @@ -635,25 +635,24 @@ EXPORT_SYMBOL_GPL(nfs_init_client);
>   * Create a version 2 or 3 client
>   */
>  static int nfs_init_server(struct nfs_server *server,
> -			   const struct nfs_fs_context *cfg,
> -			   struct nfs_subversion *nfs_mod)
> +			   const struct nfs_fs_context *ctx)
>  {
>  	struct rpc_timeout timeparms;
>  	struct nfs_client_initdata cl_init = {
> -		.hostname = cfg->nfs_server.hostname,
> -		.addr = (const struct sockaddr *)&cfg->nfs_server.address,
> -		.addrlen = cfg->nfs_server.addrlen,
> -		.nfs_mod = nfs_mod,
> -		.proto = cfg->nfs_server.protocol,
> -		.net = cfg->net,
> +		.hostname = ctx->nfs_server.hostname,
> +		.addr = (const struct sockaddr *)&ctx->nfs_server.address,
> +		.addrlen = ctx->nfs_server.addrlen,
> +		.nfs_mod = ctx->nfs_mod,
> +		.proto = ctx->nfs_server.protocol,
> +		.net = ctx->fc.net_ns,
>  		.timeparms = &timeparms,
>  	};
>  	struct nfs_client *clp;
>  	int error;
>  
> -	nfs_init_timeout_values(&timeparms, cfg->nfs_server.protocol,
> -				cfg->timeo, cfg->retrans);
> -	if (cfg->flags & NFS_MOUNT_NORESVPORT)
> +	nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
> +				ctx->timeo, ctx->retrans);
> +	if (ctx->flags & NFS_MOUNT_NORESVPORT)
>  		set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
>  
>  	/* Allocate or find a client reference we can use */
> @@ -664,46 +663,46 @@ static int nfs_init_server(struct nfs_server *server,
>  	server->nfs_client = clp;
>  
>  	/* Initialise the client representation from the mount data */
> -	server->flags = cfg->flags;
> -	server->options = cfg->options;
> +	server->flags = ctx->flags;
> +	server->options = ctx->options;
>  	server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
>  		NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
>  		NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
>  
> -	if (cfg->rsize)
> -		server->rsize = nfs_block_size(cfg->rsize, NULL);
> -	if (cfg->wsize)
> -		server->wsize = nfs_block_size(cfg->wsize, NULL);
> +	if (ctx->rsize)
> +		server->rsize = nfs_block_size(ctx->rsize, NULL);
> +	if (ctx->wsize)
> +		server->wsize = nfs_block_size(ctx->wsize, NULL);
>  
> -	server->acregmin = cfg->acregmin * HZ;
> -	server->acregmax = cfg->acregmax * HZ;
> -	server->acdirmin = cfg->acdirmin * HZ;
> -	server->acdirmax = cfg->acdirmax * HZ;
> +	server->acregmin = ctx->acregmin * HZ;
> +	server->acregmax = ctx->acregmax * HZ;
> +	server->acdirmin = ctx->acdirmin * HZ;
> +	server->acdirmax = ctx->acdirmax * HZ;
>  
>  	/* Start lockd here, before we might error out */
>  	error = nfs_start_lockd(server);
>  	if (error < 0)
>  		goto error;
>  
> -	server->port = cfg->nfs_server.port;
> -	server->auth_info = cfg->auth_info;
> +	server->port = ctx->nfs_server.port;
> +	server->auth_info = ctx->auth_info;
>  
>  	error = nfs_init_server_rpcclient(server, &timeparms,
> -					  cfg->selected_flavor);
> +					  ctx->selected_flavor);
>  	if (error < 0)
>  		goto error;
>  
>  	/* Preserve the values of mount_server-related mount options */
> -	if (cfg->mount_server.addrlen) {
> -		memcpy(&server->mountd_address, &cfg->mount_server.address,
> -			cfg->mount_server.addrlen);
> -		server->mountd_addrlen = cfg->mount_server.addrlen;
> +	if (ctx->mount_server.addrlen) {
> +		memcpy(&server->mountd_address, &ctx->mount_server.address,
> +			ctx->mount_server.addrlen);
> +		server->mountd_addrlen = ctx->mount_server.addrlen;
>  	}
> -	server->mountd_version = cfg->mount_server.version;
> -	server->mountd_port = cfg->mount_server.port;
> -	server->mountd_protocol = cfg->mount_server.protocol;
> +	server->mountd_version = ctx->mount_server.version;
> +	server->mountd_port = ctx->mount_server.port;
> +	server->mountd_protocol = ctx->mount_server.protocol;
>  
> -	server->namelen  = cfg->namlen;
> +	server->namelen  = ctx->namlen;
>  	return 0;
>  
>  error:
> @@ -921,8 +920,7 @@ EXPORT_SYMBOL_GPL(nfs_free_server);
>   * Create a version 2 or 3 volume record
>   * - keyed on server and FSID
>   */
> -struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
> -				     struct nfs_subversion *nfs_mod)
> +struct nfs_server *nfs_create_server(struct nfs_fs_context *ctx)
>  {
>  	struct nfs_server *server;
>  	struct nfs_fattr *fattr;
> @@ -938,18 +936,18 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
>  		goto error;
>  
>  	/* Get a client representation */
> -	error = nfs_init_server(server, mount_info->ctx, nfs_mod);
> +	error = nfs_init_server(server, ctx);
>  	if (error < 0)
>  		goto error;
>  
>  	/* Probe the root fh to retrieve its FSID */
> -	error = nfs_probe_fsinfo(server, mount_info->mntfh, fattr);
> +	error = nfs_probe_fsinfo(server, ctx->mntfh, fattr);
>  	if (error < 0)
>  		goto error;
>  	if (server->nfs_client->rpc_ops->version == 3) {
>  		if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
>  			server->namelen = NFS3_MAXNAMLEN;
> -		if (!(mount_info->ctx->flags & NFS_MOUNT_NORDIRPLUS))
> +		if (!(ctx->flags & NFS_MOUNT_NORDIRPLUS))
>  			server->caps |= NFS_CAP_READDIRPLUS;
>  	} else {
>  		if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
> @@ -957,7 +955,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
>  	}
>  
>  	if (!(fattr->valid & NFS_ATTR_FATTR)) {
> -		error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr, NULL);
> +		error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh, fattr, NULL);
>  		if (error < 0) {
>  			dprintk("nfs_create_server: getattr error = %d\n", -error);
>  			goto error;
> diff --git a/fs/nfs/fs_context.c b/fs/nfs/fs_context.c
> index 24becb82540f..e8e88aaa5164 100644
> --- a/fs/nfs/fs_context.c
> +++ b/fs/nfs/fs_context.c
> @@ -240,42 +240,8 @@ static const match_table_t nfs_vers_tokens = {
>  	{ Opt_vers_err, NULL }
>  };
>  
> -struct nfs_fs_context *nfs_alloc_parsed_mount_data(void)
> -{
> -	struct nfs_fs_context *ctx;
> -
> -	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
> -	if (ctx) {
> -		ctx->timeo		= NFS_UNSPEC_TIMEO;
> -		ctx->retrans		= NFS_UNSPEC_RETRANS;
> -		ctx->acregmin		= NFS_DEF_ACREGMIN;
> -		ctx->acregmax		= NFS_DEF_ACREGMAX;
> -		ctx->acdirmin		= NFS_DEF_ACDIRMIN;
> -		ctx->acdirmax		= NFS_DEF_ACDIRMAX;
> -		ctx->mount_server.port	= NFS_UNSPEC_PORT;
> -		ctx->nfs_server.port	= NFS_UNSPEC_PORT;
> -		ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> -		ctx->selected_flavor	= RPC_AUTH_MAXFLAVOR;
> -		ctx->minorversion	= 0;
> -		ctx->need_mount	= true;
> -		ctx->net		= current->nsproxy->net_ns;
> -		security_init_mnt_opts(&ctx->lsm_opts);
> -	}
> -	return ctx;
> -}
> -
> -void nfs_free_parsed_mount_data(struct nfs_fs_context *ctx)
> -{
> -	if (ctx) {
> -		kfree(ctx->client_address);
> -		kfree(ctx->mount_server.hostname);
> -		kfree(ctx->nfs_server.export_path);
> -		kfree(ctx->nfs_server.hostname);
> -		kfree(ctx->fscache_uniq);
> -		security_free_mnt_opts(&ctx->lsm_opts);
> -		kfree(ctx);
> -	}
> -}
> +const char nfs_slash[] = "/";
> +EXPORT_SYMBOL_GPL(nfs_slash);
>  
>  /*
>   * Sanity-check a server address provided by the mount command.
> @@ -354,10 +320,8 @@ static int nfs_auth_info_add(struct nfs_fs_context *ctx,
>  			return 0;
>  	}
>  
> -	if (auth_info->flavor_len + 1 >= max_flavor_len) {
> -		dfprintk(MOUNT, "NFS: too many sec= flavors\n");
> -		return -EINVAL;
> -	}
> +	if (auth_info->flavor_len + 1 >= max_flavor_len)
> +		return invalf("NFS: too many sec= flavors");
>  
>  	auth_info->flavors[auth_info->flavor_len++] = flavor;
>  	return 0;
> @@ -411,9 +375,7 @@ static int nfs_parse_security_flavors(struct nfs_fs_context *ctx, char *value)
>  			pseudoflavor = RPC_AUTH_GSS_SPKMP;
>  			break;
>  		default:
> -			dfprintk(MOUNT,
> -				 "NFS: sec= option '%s' not recognized\n", p);
> -			return -EINVAL;
> +			return invalf("NFS: sec=%s option not recognized", p);
>  		}
>  
>  		ret = nfs_auth_info_add(ctx, &ctx->auth_info, pseudoflavor);
> @@ -457,8 +419,7 @@ static int nfs_parse_version_string(struct nfs_fs_context *ctx,
>  		ctx->minorversion = 2;
>  		break;
>  	default:
> -		dfprintk(MOUNT, "NFS:   Unsupported NFS version\n");
> -		return -EINVAL;
> +		return invalf("NFS: Unsupported NFS version");
>  	}
>  	return 0;
>  }
> @@ -495,8 +456,9 @@ static int nfs_get_option_ui_bound(struct nfs_fs_context *ctx,
>  /*
>   * Parse a single mount option in "key[=val]" form.
>   */
> -static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
> +static int nfs_fs_context_parse_option(struct fs_context *fc, char *p)
>  {
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
>  	substring_t args[MAX_OPT_ARGS];
>  	char *string;
>  	int ret, token;
> @@ -715,8 +677,7 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  			break;
>  		default:
>  			kfree(string);
> -			dfprintk(MOUNT, "NFS:   unrecognized transport protocol\n");
> -			return -EINVAL;
> +			return invalf("NFS: Unrecognized transport protocol");
>  		}
>  		kfree(string);
>  		break;
> @@ -741,8 +702,7 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  			break;
>  		case Opt_xprt_rdma: /* not used for side protocols */
>  		default:
> -			dfprintk(MOUNT, "NFS:   unrecognized transport protocol\n");
> -			return -EINVAL;
> +			return invalf("NFS: Unrecognized transport protocol");
>  		}
>  		break;
>  	case Opt_addr:
> @@ -750,7 +710,7 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  		if (string == NULL)
>  			goto out_nomem;
>  		ctx->nfs_server.addrlen =
> -			rpc_pton(ctx->net, string, strlen(string),
> +			rpc_pton(fc->net_ns, string, strlen(string),
>  				 &ctx->nfs_server.address,
>  				 sizeof(ctx->nfs_server._address));
>  		kfree(string);
> @@ -770,7 +730,7 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  		if (string == NULL)
>  			goto out_nomem;
>  		ctx->mount_server.addrlen =
> -			rpc_pton(ctx->net, string, strlen(string),
> +			rpc_pton(fc->net_ns, string, strlen(string),
>  				 &ctx->mount_server.address,
>  				 sizeof(ctx->mount_server._address));
>  		kfree(string);
> @@ -795,8 +755,7 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  			ctx->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
>  			break;
>  		default:
> -			dfprintk(MOUNT, "NFS:   invalid lookupcache argument\n");
> -			return -EINVAL;
> +			return invalf("NFS: Invalid lookupcache argument");
>  		}
>  		break;
>  	case Opt_fscache_uniq:
> @@ -826,16 +785,15 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  					NFS_MOUNT_LOCAL_FCNTL);
>  			break;
>  		default:
> -			dfprintk(MOUNT, "NFS:	invalid	local_lock argument\n");
> -			return -EINVAL;
> -		};
> +			return invalf("NFS: invalid local_lock argument");
> +		}
>  		break;
>  
>  		/*
>  		 * Special options
>  		 */
>  	case Opt_sloppy:
> -		ctx->sloppy = 1;
> +		fc->sloppy = 1;
>  		dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
>  		break;
>  	case Opt_userspace:
> @@ -845,116 +803,24 @@ static int nfs_fs_context_parse_option(struct nfs_fs_context *ctx, char *p)
>  
>  	default:
>  		dfprintk(MOUNT, "NFS:   unrecognized mount option '%s'\n", p);
> -		return -EINVAL;
> +		if (!fc->sloppy)
> +			return invalf("NFS: Unrecognized mount option '%s'", p);

Did you mean to remove the dfprintk() above with this change, too?  I wonder if the invalf() / errorf() changeover could go into its own patch to make it easier to catch any issues.

> +		break;
>  	}
>  
>  	return 0;
>  
> -out_invalid_address:
> -	printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
> -	return -EINVAL;
> -out_invalid_value:
> -	printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
> -	return -EINVAL;
>  out_nomem:
>  	printk(KERN_INFO "NFS: not enough memory to parse option\n");
>  	return -ENOMEM;
> +out_invalid_value:
> +	return invalf("NFS: Bad mount option value specified");
> +out_invalid_address:
> +	return invalf("NFS: Bad IP address specified");
>  }
>  
>  /*
> - * 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_fs_context *ctx)
> -{
> -	char *p, *secdata;
> -	int rc, sloppy = 0, invalid_option = 0;
> -
> -	if (!raw) {
> -		dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
> -		return 1;
> -	}
> -	dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
> -
> -	secdata = alloc_secdata();
> -	if (!secdata)
> -		goto out_nomem;
> -
> -	rc = security_sb_copy_data(raw, secdata);
> -	if (rc)
> -		goto out_security_failure;
> -
> -	rc = security_sb_parse_opts_str(secdata, &ctx->lsm_opts);
> -	if (rc)
> -		goto out_security_failure;
> -
> -	free_secdata(secdata);
> -
> -	while ((p = strsep(&raw, ",")) != NULL) {
> -		if (!*p)
> -			continue;
> -		if (nfs_fs_context_parse_option(ctx, p) < 0)
> -			invalid_option = true;
> -	}
> -
> -	if (!sloppy && invalid_option)
> -		return 0;
> -
> -	if (ctx->minorversion && ctx->version != 4)
> -		goto out_minorversion_mismatch;
> -
> -	if (ctx->options & NFS_OPTION_MIGRATION &&
> -	    (ctx->version != 4 || ctx->minorversion != 0))
> -		goto out_migration_misuse;
> -
> -	/*
> -	 * verify that any proto=/mountproto= options match the address
> -	 * families in the addr=/mountaddr= options.
> -	 */
> -	if (ctx->protofamily != AF_UNSPEC &&
> -	    ctx->protofamily != ctx->nfs_server.address.sa_family)
> -		goto out_proto_mismatch;
> -
> -	if (ctx->mountfamily != AF_UNSPEC) {
> -		if (ctx->mount_server.addrlen) {
> -			if (ctx->mountfamily != ctx->mount_server.address.sa_family)
> -				goto out_mountproto_mismatch;
> -		} else {
> -			if (ctx->mountfamily != ctx->nfs_server.address.sa_family)
> -				goto out_mountproto_mismatch;
> -		}
> -	}
> -
> -	return 1;
> -
> -out_minorversion_mismatch:
> -	printk(KERN_INFO "NFS: mount option vers=%u does not support "
> -			 "minorversion=%u\n", ctx->version, ctx->minorversion);
> -	return 0;
> -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_migration_misuse:
> -	printk(KERN_INFO
> -		"NFS: 'migration' not supported for this NFS version\n");
> -	return -EINVAL;
> -out_nomem:
> -	printk(KERN_INFO "NFS: not enough memory to parse option\n");
> -	return 0;
> -out_security_failure:
> -	free_secdata(secdata);
> -	printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
> -	return 0;
> -}
> -
> -/*
> - * Split "dev_name" into "hostname:export_path".
> + * Split sc->device 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
> @@ -963,9 +829,9 @@ int nfs_parse_mount_options(char *raw, struct nfs_fs_context *ctx)
>   * Note: caller frees hostname and export path, even on error.
>   */
>  static int nfs_parse_devname(struct nfs_fs_context *ctx,
> -			     const char *dev_name,
>  			     size_t maxnamlen, size_t maxpathlen)
>  {
> +	char *dev_name = ctx->fc.device;
>  	size_t len;
>  	char *end;
>  
> @@ -1009,19 +875,15 @@ static int nfs_parse_devname(struct nfs_fs_context *ctx,
>  	return 0;
>  
>  out_bad_devname:
> -	dfprintk(MOUNT, "NFS: device name not in host:path format\n");
> -	return -EINVAL;
> -
> +	return invalf("NFS: device name not in host:path format");
>  out_nomem:
> -	dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
> +	errorf("NFS: not enough memory to parse device name");
>  	return -ENOMEM;
> -
>  out_hostname:
> -	dfprintk(MOUNT, "NFS: server hostname too long\n");
> +	errorf("NFS: server hostname too long");
>  	return -ENAMETOOLONG;
> -
>  out_path:
> -	dfprintk(MOUNT, "NFS: export pathname too long\n");
> +	errorf("NFS: export pathname too long");
>  	return -ENAMETOOLONG;
>  }
>  
> @@ -1041,14 +903,14 @@ static int nfs_parse_devname(struct nfs_fs_context *ctx,
>   * + 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_fs_context *ctx,
> -				     struct nfs_fh *mntfh,
> -				     const char *dev_name)
> +static int nfs23_monolithic_mount_data(struct fs_context *fc,
> +				       struct nfs_mount_data *data)
>  {
> -	struct nfs_mount_data *data = (struct nfs_mount_data *)options;
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +	struct nfs_fh *mntfh = ctx->mntfh;
>  	struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
>  	int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
> +	int ret;

If I set SECURITY_SELINUX=n and compile, I see this:

fs/nfs/fs_context.c:913:6: error: unused variable 'ret' [-Werror=unused-variable]
  int ret;  

>  
>  	if (data == NULL)
>  		goto out_no_data;
> @@ -1114,6 +976,9 @@ static int nfs23_validate_mount_data(void *options,
>  			ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
>  		/* N.B. caller will free nfs_server.hostname in all cases */
>  		ctx->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
> +		if (!ctx->nfs_server.hostname)
> +			goto out_nomem;
> +
>  		ctx->namlen		= data->namlen;
>  		ctx->bsize		= data->bsize;
>  
> @@ -1121,8 +986,6 @@ static int nfs23_validate_mount_data(void *options,
>  			ctx->selected_flavor = data->pseudoflavor;
>  		else
>  			ctx->selected_flavor = RPC_AUTH_UNIX;
> -		if (!ctx->nfs_server.hostname)
> -			goto out_nomem;
>  
>  		if (!(data->flags & NFS_MOUNT_NONLM))
>  			ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
> @@ -1130,6 +993,7 @@ static int nfs23_validate_mount_data(void *options,
>  		else
>  			ctx->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
> @@ -1140,17 +1004,16 @@ static int nfs23_validate_mount_data(void *options,
>  		 */
>  		if (data->context[0]){
>  #ifdef CONFIG_SECURITY_SELINUX
> -			int rc;

Keeping rc here would fix the problem I just mentioned

>  			char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
>  			if (!opts_str)
>  				return -ENOMEM;
>  			strcpy(opts_str, "context=");
>  			data->context[NFS_MAX_CONTEXT_LEN] = '\0';
>  			strcat(opts_str, &data->context[0]);
> -			rc = security_sb_parse_opts_str(opts_str, &ctx->lsm_opts);
> +			ret = vfs_parse_mount_option(fc, opts_str);
>  			kfree(opts_str);
> -			if (rc)
> -				return rc;
> +			if (ret)
> +				return ret;
>  #else
>  			return -EINVAL;
>  #endif
> @@ -1158,54 +1021,44 @@ static int nfs23_validate_mount_data(void *options,
>  
>  		break;
>  	default:
> -		return NFS_TEXT_DATA;
> +		return generic_monolithic_mount_data(fc, data);
>  	}
>  
> +	ctx->skip_remount_option_check = true;
>  	return 0;
>  
>  out_no_data:
> -	dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
> -	return -EINVAL;
> +	if (fc->sb_flags & MS_REMOUNT) {
> +		ctx->skip_remount_option_check = true;
> +		return 0;
> +	}
> +	return invalf("NFS: mount program didn't pass any mount data");
>  
>  out_no_v3:
> -	dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
> -		 data->version);
> -	return -EINVAL;
> +	return invalf("NFS: nfs_mount_data version does not support v3");
>  
>  out_no_sec:
> -	dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
> -	return -EINVAL;
> +	return invalf("NFS: nfs_mount_data version supports only AUTH_SYS");
>  
>  out_nomem:
> -	dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
> +	dfprintk(MOUNT, "NFS: not enough memory to handle mount options");
>  	return -ENOMEM;
>  
>  out_no_address:
> -	dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
> -	return -EINVAL;
> +	return invalf("NFS: mount program didn't pass remote address");
>  
>  out_invalid_fh:
> -	dfprintk(MOUNT, "NFS: invalid root filehandle\n");
> -	return -EINVAL;
> -}
> -
> -#if IS_ENABLED(CONFIG_NFS_V4)

I think the "IS_ENABLED(CONFIG_NFS_V4)" check needs to stay here, otherwise gcc wtill complain that nfs4_monolithic_mount_data() is defined but not used

> -
> -static void nfs4_validate_mount_flags(struct nfs_fs_context *ctx)
> -{
> -	ctx->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
> -			 NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
> +	return invalf("NFS: invalid root filehandle");
>  }
>  
>  /*
>   * Validate NFSv4 mount options
>   */
> -static int nfs4_validate_mount_data(void *options,
> -				    struct nfs_fs_context *ctx,
> -				    const char *dev_name)
> +static int nfs4_monolithic_mount_data(struct fs_context *fc,
> +				      struct nfs4_mount_data *data)
>  {
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
>  	struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
> -	struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
>  	char *c;
>  
>  	if (data == NULL)
> @@ -1255,7 +1108,7 @@ static int nfs4_validate_mount_data(void *options,
>  		ctx->client_address = c;
>  
>  		/*
> -		 * Translate to nfs_fs_context, which nfs4_fill_super
> +		 * Translate to nfs_fs_context, which nfs_fill_super
>  		 * can deal with.
>  		 */
>  
> @@ -1275,95 +1128,372 @@ static int nfs4_validate_mount_data(void *options,
>  
>  		break;
>  	default:
> -		return NFS_TEXT_DATA;
> +		return generic_monolithic_mount_data(fc, data);
>  	}
>  
> +	ctx->skip_remount_option_check = true;
>  	return 0;
>  
>  out_no_data:
> -	dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
> -	return -EINVAL;
> +	if (fc->sb_flags & MS_REMOUNT) {
> +		ctx->skip_remount_option_check = true;
> +		return 0;
> +	}
> +	return invalf("NFS4: mount program didn't pass any mount data");
>  
>  out_inval_auth:
> -	dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
> -		 data->auth_flavourlen);
> -	return -EINVAL;
> +	return invalf("NFS4: Invalid number of RPC auth flavours %d",
> +		      data->auth_flavourlen);
>  
>  out_no_address:
> -	dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
> -	return -EINVAL;
> +	return invalf("NFS4: mount program didn't pass remote address");
>  
>  out_invalid_transport_udp:
> -	dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
> -	return -EINVAL;
> +	return invalf("NFSv4: Unsupported transport protocol udp");
>  }
>  
> -int nfs_validate_mount_data(struct file_system_type *fs_type,
> -			    void *options,
> -			    struct nfs_fs_context *ctx,
> -			    struct nfs_fh *mntfh,
> -			    const char *dev_name)
> -{
> -	if (fs_type == &nfs_fs_type)
> -		return nfs23_validate_mount_data(options, ctx, mntfh, dev_name);
> -	return nfs4_validate_mount_data(options, ctx, dev_name);
> -}
> -#else
> -int nfs_validate_mount_data(struct file_system_type *fs_type,
> -			    void *options,
> -			    struct nfs_fs_context *ctx,
> -			    struct nfs_fh *mntfh,
> -			    const char *dev_name)
> +/*
> + * Parse a monolithic block of data from sys_mount().
> + */
> +static int nfs_monolithic_mount_data(struct fs_context *fc, void *data)
>  {
> -	return nfs23_validate_mount_data(options, ctx, mntfh, dev_name);
> -}
> +	if (fc->fs_type == &nfs_fs_type)
> +		return nfs23_monolithic_mount_data(fc, data);
> +
> +#if IS_ENABLED(CONFIG_NFS_V4)
> +	if (fc->fs_type == &nfs4_fs_type)
> +		return nfs4_monolithic_mount_data(fc, data);
>  #endif
>  
> -int nfs_validate_text_mount_data(void *options,
> -				 struct nfs_fs_context *ctx,
> -				 const char *dev_name)
> +	return invalf("NFS: Unsupported monolithic data version");
> +}
> +
> +/*
> + * Validate the preparsed information in the config.
> + */
> +static int nfs_fs_context_validate(struct fs_context *fc)
>  {
> -	int port = 0;
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +	struct nfs_subversion *nfs_mod;
> +	struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
>  	int max_namelen = PAGE_SIZE;
>  	int max_pathlen = NFS_MAXPATHLEN;
> -	struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
> +	int port = 0;
> +	int ret;
>  
> -	if (nfs_parse_mount_options((char *)options, ctx) == 0)
> -		return -EINVAL;
> +	if (ctx->fc.purpose == FS_CONTEXT_FOR_REMOUNT)
> +		return 0;
> +
> +	if (!ctx->fc.device)
> +		goto out_no_device_name;
> +
> +	/* Check for sanity first. */
> +	if (ctx->minorversion && ctx->version != 4)
> +		goto out_minorversion_mismatch;
> +
> +	if (ctx->options & NFS_OPTION_MIGRATION &&
> +	    (ctx->version != 4 || ctx->minorversion != 0))
> +		goto out_migration_misuse;
> +
> +	/* Verify that any proto=/mountproto= options match the address
> +	 * families in the addr=/mountaddr= options.
> +	 */
> +	if (ctx->protofamily != AF_UNSPEC &&
> +	    ctx->protofamily != ctx->nfs_server.address.sa_family)
> +		goto out_proto_mismatch;
> +
> +	if (ctx->mountfamily != AF_UNSPEC) {
> +		if (ctx->mount_server.addrlen) {
> +			if (ctx->mountfamily != ctx->mount_server.address.sa_family)
> +				goto out_mountproto_mismatch;
> +		} else {
> +			if (ctx->mountfamily != ctx->nfs_server.address.sa_family)
> +				goto out_mountproto_mismatch;
> +		}
> +	}
>  
>  	if (!nfs_verify_server_address(sap))
>  		goto out_no_address;
>  
>  	if (ctx->version == 4) {
> -#if IS_ENABLED(CONFIG_NFS_V4)
> -		port = NFS_PORT;
> -		max_namelen = NFS4_MAXNAMLEN;
> -		max_pathlen = NFS4_MAXPATHLEN;
> -		nfs_validate_transport_protocol(ctx);
> -		if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
> -			goto out_invalid_transport_udp;
> -		nfs4_validate_mount_flags(ctx);
> -#else
> -		goto out_v4_not_compiled;
> -#endif /* CONFIG_NFS_V4 */
> -	} else
> +		if (IS_ENABLED(CONFIG_NFS_V4)) {
> +			port = NFS_PORT;
> +			max_namelen = NFS4_MAXNAMLEN;
> +			max_pathlen = NFS4_MAXPATHLEN;
> +			nfs_validate_transport_protocol(ctx);
> +			if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
> +				goto out_invalid_transport_udp;
> +			ctx->flags &= ~(NFS_MOUNT_NONLM | NFS_MOUNT_NOACL |
> +					 NFS_MOUNT_VER3 | NFS_MOUNT_LOCAL_FLOCK |
> +					 NFS_MOUNT_LOCAL_FCNTL);
> +		} else {
> +			goto out_v4_not_compiled;
> +		}
> +	} else {
>  		nfs_set_mount_transport_protocol(ctx);
> +	}
>  
>  	nfs_set_port(sap, &ctx->nfs_server.port, port);
>  
> -	return nfs_parse_devname(ctx, dev_name, max_namelen, max_pathlen);
> +	ret = nfs_parse_devname(ctx, max_namelen, max_pathlen);
> +	if (ret < 0)
> +		return ret;
>  
> -#if !IS_ENABLED(CONFIG_NFS_V4)
> +	/* Load the NFS protocol module if we haven't done so yet */
> +	if (!ctx->nfs_mod) {
> +		nfs_mod = get_nfs_version(ctx->version);
> +		if (IS_ERR(nfs_mod)) {
> +			ret = PTR_ERR(nfs_mod);
> +			goto out_version_unavailable;
> +		}
> +		ctx->nfs_mod = nfs_mod;
> +	}
> +	return 0;
> +
> +out_no_device_name:
> +	return invalf("NFS: Device name not specified");
>  out_v4_not_compiled:
> -	dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
> +	errorf("NFS: NFSv4 is not compiled into kernel");
>  	return -EPROTONOSUPPORT;
> -#else
>  out_invalid_transport_udp:
> -	dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
> -	return -EINVAL;
> -#endif /* !CONFIG_NFS_V4 */
> -
> +	return invalf("NFSv4: Unsupported transport protocol udp");
>  out_no_address:
> -	dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
> -	return -EINVAL;
> +	return invalf("NFS: mount program didn't pass remote address");
> +out_mountproto_mismatch:
> +	return invalf("NFS: Mount server address does not match mountproto= option");
> +out_proto_mismatch:
> +	return invalf("NFS: Server address does not match proto= option");
> +out_minorversion_mismatch:
> +	return invalf("NFS: Mount option vers=%u does not support minorversion=%u",
> +		      ctx->version, ctx->minorversion);
> +out_migration_misuse:
> +	return invalf("NFS: 'Migration' not supported for this NFS version");
> +out_version_unavailable:
> +	errorf("NFS: Version unavailable");
> +	return ret;
> +}
> +
> +/*
> + * Use the preparsed information in the config to effect a mount.
> + */
> +static int nfs_get_ordinary_tree(struct nfs_fs_context *ctx)
> +{
> +	ctx->set_security = nfs_set_sb_security;
> +
> +	return ctx->nfs_mod->rpc_ops->try_get_tree(ctx);
>  }
> +
> +/*
> + * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
> + */
> +static int nfs_get_xdev_tree(struct nfs_fs_context *ctx)
> +{
> +	struct nfs_server *server;
> +	int ret;
> +
> +	dprintk("--> nfs_xdev_mount()\n");

I think the dprintk()s in this function are just going to add noise.  Can you do the patch without them?

Thanks,
Anna

> +
> +	ctx->set_security = nfs_clone_sb_security;
> +
> +	/* create a new volume representation */
> +	server = ctx->nfs_mod->rpc_ops->clone_server(NFS_SB(ctx->clone_data.sb),
> +						     ctx->mntfh,
> +						     ctx->clone_data.fattr,
> +						     ctx->selected_flavor);
> +
> +	if (IS_ERR(server))
> +		ret = PTR_ERR(server);
> +	else
> +		ret = nfs_get_tree_common(server, ctx);
> +
> +	dprintk("<-- nfs_get_xdev_tree() = %d\n", ret);
> +	return ret;
> +}
> +
> +/*
> + * Create an NFS superblock by the appropriate method.
> + */
> +static int nfs_get_tree(struct fs_context *fc)
> +{
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +	int ret;
> +
> +	if (!ctx->nfs_mod) {
> +		pr_warn("Missing nfs_mod\n");
> +		return -EINVAL;
> +	}
> +	if (!ctx->nfs_mod->rpc_ops) {
> +		pr_warn("Missing rpc_ops\n");
> +		return -EINVAL;
> +	}
> +
> +	if (ctx->nfs_mod->rpc_ops->get_tree) {
> +		ret = ctx->nfs_mod->rpc_ops->get_tree(ctx);
> +		if (ret != 1)
> +			return ret;
> +	}
> +
> +	switch (ctx->mount_type) {
> +	case NFS_MOUNT_ORDINARY:
> +		return nfs_get_ordinary_tree(ctx);
> +
> +	case NFS_MOUNT_CROSS_DEV:
> +		return nfs_get_xdev_tree(ctx);
> +
> +	default:
> +		errorf("NFS: Unknown mount type");
> +		return -ENOTSUPP;
> +	}
> +}
> +
> +/*
> + * Handle duplication of a configuration.  The caller copied *src into *sc, but
> + * it can't deal with resource pointers in the filesystem context, so we have
> + * to do that.  We need to clear pointers, copy data or get extra refs as
> + * appropriate.
> + */
> +static int nfs_fs_context_dup(struct fs_context *fc, struct fs_context *src)
> +{
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +
> +	__module_get(ctx->nfs_mod->owner);
> +	ctx->client_address		= NULL;
> +	ctx->mount_server.hostname	= NULL;
> +	ctx->nfs_server.export_path	= NULL;
> +	ctx->nfs_server.hostname	= NULL;
> +	ctx->fscache_uniq		= NULL;
> +
> +	ctx->mntfh = nfs_alloc_fhandle();
> +	if (!ctx->mntfh)
> +		return -ENOMEM;
> +	return 0;
> +}
> +
> +static void nfs_fs_context_free(struct fs_context *fc)
> +{
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +
> +	if (ctx->nfs_mod)
> +		put_nfs_version(ctx->nfs_mod);
> +	kfree(ctx->client_address);
> +	kfree(ctx->mount_server.hostname);
> +	if (ctx->nfs_server.export_path != nfs_slash)
> +		kfree(ctx->nfs_server.export_path);
> +	kfree(ctx->nfs_server.hostname);
> +	kfree(ctx->fscache_uniq);
> +	nfs_free_fhandle(ctx->mntfh);
> +}
> +
> +static const struct fs_context_operations nfs_fs_context_ops = {
> +	.free			= nfs_fs_context_free,
> +	.dup			= nfs_fs_context_dup,
> +	.parse_option		= nfs_fs_context_parse_option,
> +	.monolithic_mount_data	= nfs_monolithic_mount_data,
> +	.validate		= nfs_fs_context_validate,
> +	.get_tree		= nfs_get_tree,
> +};
> +
> +/*
> + * Initialise a configuration from an extant superblock for remounting.
> + */
> +static int nfs_mount_init_from_sb(struct fs_context *fc,
> +				  struct super_block *sb)
> +{
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +	struct nfs_server *nfss = sb->s_fs_info;
> +	struct net *net = nfss->nfs_client->cl_net;
> +
> +	ctx->flags		= nfss->flags;
> +	ctx->rsize		= nfss->rsize;
> +	ctx->wsize		= nfss->wsize;
> +	ctx->retrans		= nfss->client->cl_timeout->to_retries;
> +	ctx->selected_flavor	= nfss->client->cl_auth->au_flavor;
> +	ctx->acregmin		= nfss->acregmin / HZ;
> +	ctx->acregmax		= nfss->acregmax / HZ;
> +	ctx->acdirmin		= nfss->acdirmin / HZ;
> +	ctx->acdirmax		= nfss->acdirmax / HZ;
> +	ctx->timeo		= 10U * nfss->client->cl_timeout->to_initval / HZ;
> +	ctx->nfs_server.port	= nfss->port;
> +	ctx->nfs_server.addrlen	= nfss->nfs_client->cl_addrlen;
> +	ctx->version		= nfss->nfs_client->rpc_ops->version;
> +	ctx->minorversion	= nfss->nfs_client->cl_minorversion;
> +
> +	memcpy(&ctx->nfs_server.address, &nfss->nfs_client->cl_addr,
> +		ctx->nfs_server.addrlen);
> +
> +	if (ctx->fc.net_ns != net) {
> +		put_net(ctx->fc.net_ns);
> +		ctx->fc.net_ns = get_net(net);
> +	}
> +
> +	ctx->nfs_mod = nfss->nfs_client->cl_nfs_mod;
> +	if (!try_module_get(ctx->nfs_mod->owner)) {
> +		ctx->nfs_mod = NULL;
> +		errorf("NFS: Protocol module not available");
> +		return -ENOENT;
> +	}
> +
> +	return 0;
> +}
> +
> +/*
> + * Prepare superblock configuration.  We use the namespaces attached to the
> + * context.  This may be the current process's namespaces, or it may be a
> + * container's namespaces.
> + */
> +static int nfs_init_fs_context(struct fs_context *fc, struct super_block *src_sb)
> +{
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +
> +	ctx->mntfh = nfs_alloc_fhandle();
> +	if (!ctx->mntfh)
> +		return -ENOMEM;
> +
> +	ctx->fc.ops		= &nfs_fs_context_ops;
> +	ctx->mount_type		= NFS_MOUNT_ORDINARY;
> +	ctx->protofamily	= AF_UNSPEC;
> +	ctx->mountfamily	= AF_UNSPEC;
> +	ctx->mount_server.port	= NFS_UNSPEC_PORT;
> +
> +	if (!src_sb) {
> +		ctx->timeo		= NFS_UNSPEC_TIMEO;
> +		ctx->retrans		= NFS_UNSPEC_RETRANS;
> +		ctx->acregmin		= NFS_DEF_ACREGMIN;
> +		ctx->acregmax		= NFS_DEF_ACREGMAX;
> +		ctx->acdirmin		= NFS_DEF_ACDIRMIN;
> +		ctx->acdirmax		= NFS_DEF_ACDIRMAX;
> +		ctx->nfs_server.port	= NFS_UNSPEC_PORT;
> +		ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
> +		ctx->selected_flavor	= RPC_AUTH_MAXFLAVOR;
> +		ctx->minorversion	= 0;
> +		ctx->need_mount		= true;
> +		return 0;
> +	}
> +
> +	return nfs_mount_init_from_sb(fc, src_sb);
> +}
> +
> +struct file_system_type nfs_fs_type = {
> +	.owner			= THIS_MODULE,
> +	.name			= "nfs",
> +	.init_fs_context	= nfs_init_fs_context,
> +	.fs_context_size	= sizeof(struct nfs_fs_context),
> +	.kill_sb		= nfs_kill_super,
> +	.fs_flags		= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> +};
> +MODULE_ALIAS_FS("nfs");
> +EXPORT_SYMBOL_GPL(nfs_fs_type);
> +
> +#if IS_ENABLED(CONFIG_NFS_V4)
> +struct file_system_type nfs4_fs_type = {
> +	.owner			= THIS_MODULE,
> +	.name			= "nfs4",
> +	.fs_context_size	= sizeof(struct nfs_fs_context),
> +	.init_fs_context	= nfs_init_fs_context,
> +	.kill_sb		= nfs_kill_super,
> +	.fs_flags		= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> +};
> +MODULE_ALIAS_FS("nfs4");
> +MODULE_ALIAS("nfs4");
> +EXPORT_SYMBOL_GPL(nfs4_fs_type);
> +#endif /* CONFIG_NFS_V4 */
> diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
> index 391dafaf9182..4a5ee38117b5 100644
> --- a/fs/nfs/getroot.c
> +++ b/fs/nfs/getroot.c
> @@ -68,66 +68,70 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
>  /*
>   * get an NFS2/NFS3 root dentry from the root filehandle
>   */
> -struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
> -			    const char *devname)
> +int nfs_get_root(struct super_block *s, struct nfs_fs_context *ctx)
>  {
> -	struct nfs_server *server = NFS_SB(sb);
> +	struct nfs_server *server = NFS_SB(s);
>  	struct nfs_fsinfo fsinfo;
> -	struct dentry *ret;
> +	struct dentry *root;
>  	struct inode *inode;
> -	void *name = kstrdup(devname, GFP_KERNEL);
> -	int error;
> +	char *name;
> +	int error = -ENOMEM;
>  
> +	name = kstrdup(ctx->fc.device, GFP_KERNEL);
>  	if (!name)
> -		return ERR_PTR(-ENOMEM);
> +		goto out;
>  
>  	/* get the actual root for this mount */
>  	fsinfo.fattr = nfs_alloc_fattr();
> -	if (fsinfo.fattr == NULL) {
> -		kfree(name);
> -		return ERR_PTR(-ENOMEM);
> -	}
> +	if (fsinfo.fattr == NULL)
> +		goto out_name;
>  
> -	error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
> +	error = server->nfs_client->rpc_ops->getroot(server, ctx->mntfh, &fsinfo);
>  	if (error < 0) {
>  		dprintk("nfs_get_root: getattr error = %d\n", -error);
> -		ret = ERR_PTR(error);
> -		goto out;
> +		errorf("NFS: Couldn't getattr on root");
> +		goto out_fattr;
>  	}
>  
> -	inode = nfs_fhget(sb, mntfh, fsinfo.fattr, NULL);
> +	inode = nfs_fhget(s, ctx->mntfh, fsinfo.fattr, NULL);
>  	if (IS_ERR(inode)) {
>  		dprintk("nfs_get_root: get root inode failed\n");
> -		ret = ERR_CAST(inode);
> -		goto out;
> +		error = PTR_ERR(inode);
> +		errorf("NFS: Couldn't get root inode");
> +		goto out_fattr;
>  	}
>  
> -	error = nfs_superblock_set_dummy_root(sb, inode);
> -	if (error != 0) {
> -		ret = ERR_PTR(error);
> -		goto out;
> -	}
> +	error = nfs_superblock_set_dummy_root(s, inode);
> +	if (error != 0)
> +		goto out_fattr;
>  
>  	/* root dentries normally start off anonymous and get spliced in later
>  	 * if the dentry tree reaches them; however if the dentry already
>  	 * exists, we'll pick it up at this point and use it as the root
>  	 */
> -	ret = d_obtain_root(inode);
> -	if (IS_ERR(ret)) {
> +	root = d_obtain_root(inode);
> +	if (IS_ERR(root)) {
>  		dprintk("nfs_get_root: get root dentry failed\n");
> -		goto out;
> +		error = PTR_ERR(root);
> +		errorf("NFS: Couldn't get root dentry");
> +		goto out_fattr;
>  	}
>  
> -	security_d_instantiate(ret, inode);
> -	spin_lock(&ret->d_lock);
> -	if (IS_ROOT(ret) && !ret->d_fsdata &&
> -	    !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
> -		ret->d_fsdata = name;
> +	security_d_instantiate(root, inode);
> +	spin_lock(&root->d_lock);
> +	if (IS_ROOT(root) && !root->d_fsdata &&
> +	    !(root->d_flags & DCACHE_NFSFS_RENAMED)) {
> +		root->d_fsdata = name;
>  		name = NULL;
>  	}
> -	spin_unlock(&ret->d_lock);
> -out:
> -	kfree(name);
> +	spin_unlock(&root->d_lock);
> +	ctx->fc.root = root;
> +	error = 0;
> +
> +out_fattr:
>  	nfs_free_fattr(fsinfo.fattr);
> -	return ret;
> +out_name:
> +	kfree(name);
> +out:
> +	return error;
>  }
> diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
> index fa568407cda8..ef7193479cda 100644
> --- a/fs/nfs/internal.h
> +++ b/fs/nfs/internal.h
> @@ -3,7 +3,7 @@
>   */
>  
>  #include "nfs4_fs.h"
> -#include <linux/mount.h>
> +#include <linux/fs_context.h>
>  #include <linux/security.h>
>  #include <linux/crc32.h>
>  #include <linux/sunrpc/addr.h>
> @@ -36,18 +36,6 @@ static inline int nfs_attr_use_mounted_on_fileid(struct nfs_fattr *fattr)
>  	return 1;
>  }
>  
> -struct nfs_clone_mount {
> -	const struct super_block *sb;
> -	const struct dentry *dentry;
> -	struct nfs_fh *fh;
> -	struct nfs_fattr *fattr;
> -	char *hostname;
> -	char *mnt_path;
> -	struct sockaddr *addr;
> -	size_t addrlen;
> -	rpc_authflavor_t authflavor;
> -};
> -
>  /*
>   * Note: RFC 1813 doesn't limit the number of auth flavors that
>   * a server can return, so make something up.
> @@ -82,10 +70,22 @@ struct nfs_client_initdata {
>  	const struct rpc_timeout *timeparms;
>  };
>  
> +enum nfs_mount_type {
> +	NFS_MOUNT_ORDINARY,
> +	NFS_MOUNT_CROSS_DEV,
> +	NFS4_MOUNT_REMOTE,
> +	NFS4_MOUNT_REFERRAL,
> +	NFS4_MOUNT_REMOTE_REFERRAL,
> +};
> +
>  /*
>   * In-kernel mount arguments
>   */
>  struct nfs_fs_context {
> +	struct fs_context	fc;
> +	enum nfs_mount_type	mount_type : 8;
> +	bool			skip_remount_option_check;
> +	bool			need_mount;
>  	unsigned int		flags;		/* NFS{,4}_MOUNT_* flags */
>  	unsigned int		rsize, wsize;
>  	unsigned int		timeo, retrans;
> @@ -102,8 +102,6 @@ struct nfs_fs_context {
>  	char			*fscache_uniq;
>  	unsigned short		protofamily;
>  	unsigned short		mountfamily;
> -	bool			need_mount;
> -	bool			sloppy;
>  
>  	struct {
>  		union {
> @@ -127,10 +125,22 @@ struct nfs_fs_context {
>  		char			*export_path;
>  		int			port;
>  		unsigned short		protocol;
> +		unsigned short		export_path_len;
>  	} nfs_server;
>  
> -	struct security_mnt_opts lsm_opts;
> -	struct net		*net;
> +	struct nfs_fh		*mntfh;
> +	struct nfs_subversion	*nfs_mod;
> +	struct nfs_server	*server;
> +
> +	int (*set_security)(struct super_block *, struct nfs_fs_context *);
> +
> +	/* Information for a cloned mount. */
> +	struct nfs_clone_mount {
> +		struct super_block	*sb;
> +		struct dentry		*dentry;
> +		struct nfs_fattr	*fattr;
> +		bool			cloned;
> +	} clone_data;
>  
>  	char			buf[32];	/* Parse buffer */
>  };
> @@ -150,14 +160,6 @@ struct nfs_mount_request {
>  	struct net		*net;
>  };
>  
> -struct nfs_mount_info {
> -	void (*fill_super)(struct super_block *, struct nfs_mount_info *);
> -	int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *);
> -	struct nfs_fs_context *ctx;
> -	struct nfs_clone_mount *cloned;
> -	struct nfs_fh *mntfh;
> -};
> -
>  extern int nfs_mount(struct nfs_mount_request *info);
>  extern void nfs_umount(const struct nfs_mount_request *info);
>  
> @@ -183,13 +185,9 @@ extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
>  extern struct nfs_client *
>  nfs4_find_client_sessionid(struct net *, const struct sockaddr *,
>  				struct nfs4_sessionid *, u32);
> -extern struct nfs_server *nfs_create_server(struct nfs_mount_info *,
> -					struct nfs_subversion *);
> -extern struct nfs_server *nfs4_create_server(
> -					struct nfs_mount_info *,
> -					struct nfs_subversion *);
> -extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
> -						      struct nfs_fh *);
> +extern struct nfs_server *nfs_create_server(struct nfs_fs_context *);
> +extern struct nfs_server *nfs4_create_server(struct nfs_fs_context *);
> +extern struct nfs_server *nfs4_create_referral_server(struct nfs_fs_context *);
>  extern int nfs4_update_server(struct nfs_server *server, const char *hostname,
>  					struct sockaddr *sap, size_t salen,
>  					struct net *net);
> @@ -243,19 +241,7 @@ extern struct svc_version nfs4_callback_version4;
>  struct nfs_pageio_descriptor;
>  
>  /* mount.c */
> -#define NFS_TEXT_DATA		1
> -
> -extern struct nfs_fs_context *nfs_alloc_parsed_mount_data(void);
> -extern void nfs_free_parsed_mount_data(struct nfs_fs_context *ctx);
> -extern int nfs_parse_mount_options(char *raw, struct nfs_fs_context *ctx);
> -extern int nfs_validate_mount_data(struct file_system_type *fs_type,
> -				   void *options,
> -				   struct nfs_fs_context *ctx,
> -				   struct nfs_fh *mntfh,
> -				   const char *dev_name);
> -extern int nfs_validate_text_mount_data(void *options,
> -					struct nfs_fs_context *ctx,
> -					const char *dev_name);
> +extern const char nfs_slash[];
>  
>  /* pagelist.c */
>  extern int __init nfs_init_nfspagecache(void);
> @@ -418,23 +404,12 @@ extern int nfs_wait_atomic_killable(atomic_t *p);
>  /* super.c */
>  extern const struct super_operations nfs_sops;
>  extern struct file_system_type nfs_fs_type;
> -extern struct file_system_type nfs_xdev_fs_type;
> -#if IS_ENABLED(CONFIG_NFS_V4)
> -extern struct file_system_type nfs4_xdev_fs_type;
> -extern struct file_system_type nfs4_referral_fs_type;
> -#endif
>  bool nfs_auth_info_match(const struct nfs_auth_info *, rpc_authflavor_t);
> -struct dentry *nfs_try_mount(int, const char *, struct nfs_mount_info *,
> -			struct nfs_subversion *);
> -int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
> -int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
> -struct dentry *nfs_fs_mount_common(struct nfs_server *, int, const char *,
> -				   struct nfs_mount_info *, struct nfs_subversion *);
> -struct dentry *nfs_fs_mount(struct file_system_type *, int, const char *, void *);
> -struct dentry * nfs_xdev_mount_common(struct file_system_type *, int,
> -		const char *, struct nfs_mount_info *);
> +int nfs_try_get_tree(struct nfs_fs_context *);
> +int nfs_set_sb_security(struct super_block *, struct nfs_fs_context *);
> +int nfs_clone_sb_security(struct super_block *, struct nfs_fs_context *);
> +int nfs_get_tree_common(struct nfs_server *, struct nfs_fs_context *);
>  void nfs_kill_super(struct super_block *);
> -void nfs_fill_super(struct super_block *, struct nfs_mount_info *);
>  
>  extern struct rpc_stat nfs_rpcstat;
>  
> @@ -467,12 +442,9 @@ struct vfsmount *nfs_do_submount(struct dentry *, struct nfs_fh *,
>  				 struct nfs_fattr *, rpc_authflavor_t);
>  
>  /* getroot.c */
> -extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *,
> -				   const char *);
> +extern int nfs_get_root(struct super_block *s, struct nfs_fs_context *cfg);
>  #if IS_ENABLED(CONFIG_NFS_V4)
> -extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *,
> -				    const char *);
> -
> +extern int nfs4_get_root(struct super_block *s, struct nfs_fs_context *cfg);
>  extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);
>  #endif
>  
> @@ -491,7 +463,7 @@ int  nfs_show_options(struct seq_file *, struct dentry *);
>  int  nfs_show_devname(struct seq_file *, struct dentry *);
>  int  nfs_show_path(struct seq_file *, struct dentry *);
>  int  nfs_show_stats(struct seq_file *, struct dentry *);
> -int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
> +int nfs_remount(struct super_block *sb, struct fs_context *fc);
>  
>  /* write.c */
>  extern void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
> diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
> index e5686be67be8..f80062d626f9 100644
> --- a/fs/nfs/namespace.c
> +++ b/fs/nfs/namespace.c
> @@ -18,6 +18,7 @@
>  #include <linux/vfs.h>
>  #include <linux/sunrpc/gss_api.h>
>  #include "internal.h"
> +#include "nfs.h"
>  
>  #define NFSDBG_FACILITY		NFSDBG_VFS
>  
> @@ -209,16 +210,6 @@ void nfs_release_automount_timer(void)
>  		cancel_delayed_work(&nfs_automount_task);
>  }
>  
> -/*
> - * Clone a mountpoint of the appropriate type
> - */
> -static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
> -					   const char *devname,
> -					   struct nfs_clone_mount *mountdata)
> -{
> -	return vfs_submount(mountdata->dentry, &nfs_xdev_fs_type, devname, mountdata);
> -}
> -
>  /**
>   * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
>   * @dentry - parent directory
> @@ -230,27 +221,58 @@ static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
>  struct vfsmount *nfs_do_submount(struct dentry *dentry, struct nfs_fh *fh,
>  				 struct nfs_fattr *fattr, rpc_authflavor_t authflavor)
>  {
> -	struct nfs_clone_mount mountdata = {
> -		.sb = dentry->d_sb,
> -		.dentry = dentry,
> -		.fh = fh,
> -		.fattr = fattr,
> -		.authflavor = authflavor,
> -	};
> +	struct nfs_fs_context *ctx;
> +	struct fs_context *fc;
>  	struct vfsmount *mnt;
> -	char *page = (char *) __get_free_page(GFP_USER);
> -	char *devname;
> +	char *buffer, *p;
> +	int ret;
> +
> +	/* Open a new filesystem context, transferring parameters from the
> +	 * parent superblock, including the network namespace.
> +	 */
> +	fc = vfs_new_fs_context(&nfs_fs_type, dentry->d_sb, 0,
> +				FS_CONTEXT_FOR_SUBMOUNT);
> +	if (IS_ERR(fc))
> +		return ERR_CAST(fc);
> +	ctx = container_of(fc, struct nfs_fs_context, fc);
> +
> +	mnt = ERR_PTR(-ENOMEM);
> +	buffer = kmalloc(4096, GFP_USER);
> +	if (!buffer)
> +		goto err_fc;
> +
> +	ctx->mount_type		= NFS_MOUNT_CROSS_DEV;
> +	ctx->selected_flavor	= authflavor;
> +	ctx->clone_data.sb	= dentry->d_sb;
> +	ctx->clone_data.dentry	= dentry;
> +	ctx->clone_data.fattr	= fattr;
> +	ctx->clone_data.cloned	= true;
> +
> +	nfs_copy_fh(ctx->mntfh, fh);
> +
> +	p = nfs_devname(dentry, buffer, 4096);
> +	if (IS_ERR(p)) {
> +		errorf("NFS: Couldn't determine submount pathname");
> +		mnt = ERR_CAST(p);
> +		goto err_buffer;
> +	}
> +
> +	ctx->fc.device = kmemdup(p, buffer + 4096 - p, GFP_KERNEL);
> +	kfree(buffer);
> +	if (!ctx->fc.device)
> +		goto err_fc;
>  
> -	if (page == NULL)
> -		return ERR_PTR(-ENOMEM);
> +	ret = vfs_get_tree(fc);
> +	if (ret < 0)
> +		goto err_fc;
>  
> -	devname = nfs_devname(dentry, page, PAGE_SIZE);
> -	if (IS_ERR(devname))
> -		mnt = ERR_CAST(devname);
> -	else
> -		mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), devname, &mountdata);
> +	mnt = vfs_kern_mount_fc(&ctx->fc);
> +	goto err_fc;
>  
> -	free_page((unsigned long)page);
> +err_buffer:
> +	kfree(buffer);
> +err_fc:
> +	put_fs_context(fc);
>  	return mnt;
>  }
>  EXPORT_SYMBOL_GPL(nfs_do_submount);
> diff --git a/fs/nfs/nfs3_fs.h b/fs/nfs/nfs3_fs.h
> index e134d6548ab7..2094bb1f022e 100644
> --- a/fs/nfs/nfs3_fs.h
> +++ b/fs/nfs/nfs3_fs.h
> @@ -26,7 +26,7 @@ static inline int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
>  #endif /* CONFIG_NFS_V3_ACL */
>  
>  /* nfs3client.c */
> -struct nfs_server *nfs3_create_server(struct nfs_mount_info *, struct nfs_subversion *);
> +struct nfs_server *nfs3_create_server(struct nfs_fs_context *);
>  struct nfs_server *nfs3_clone_server(struct nfs_server *, struct nfs_fh *,
>  				     struct nfs_fattr *, rpc_authflavor_t);
>  
> diff --git a/fs/nfs/nfs3client.c b/fs/nfs/nfs3client.c
> index 7879f2a0fcfd..3b99d4985c4c 100644
> --- a/fs/nfs/nfs3client.c
> +++ b/fs/nfs/nfs3client.c
> @@ -45,10 +45,10 @@ static inline void nfs_init_server_aclclient(struct nfs_server *server)
>  }
>  #endif
>  
> -struct nfs_server *nfs3_create_server(struct nfs_mount_info *mount_info,
> -				      struct nfs_subversion *nfs_mod)
> +struct nfs_server *nfs3_create_server(struct nfs_fs_context *ctx)
>  {
> -	struct nfs_server *server = nfs_create_server(mount_info, nfs_mod);
> +	struct nfs_server *server = nfs_create_server(ctx);
> +
>  	/* Create a client RPC handle for the NFS v3 ACL management interface */
>  	if (!IS_ERR(server))
>  		nfs_init_server_aclclient(server);
> diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
> index 0c07b567118d..96e315916a34 100644
> --- a/fs/nfs/nfs3proc.c
> +++ b/fs/nfs/nfs3proc.c
> @@ -975,7 +975,7 @@ const struct nfs_rpc_ops nfs_v3_clientops = {
>  	.nlmclnt_ops	= &nlmclnt_fl_close_lock_ops,
>  	.getroot	= nfs3_proc_get_root,
>  	.submount	= nfs_submount,
> -	.try_mount	= nfs_try_mount,
> +	.try_get_tree	= nfs_try_get_tree,
>  	.getattr	= nfs3_proc_getattr,
>  	.setattr	= nfs3_proc_setattr,
>  	.lookup		= nfs3_proc_lookup,
> diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
> index af285cc27ccf..c5882668dc8a 100644
> --- a/fs/nfs/nfs4_fs.h
> +++ b/fs/nfs/nfs4_fs.h
> @@ -467,7 +467,6 @@ extern const nfs4_stateid zero_stateid;
>  /* nfs4super.c */
>  struct nfs_mount_info;
>  extern struct nfs_subversion nfs_v4;
> -struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
>  extern bool nfs4_disable_idmapping;
>  extern unsigned short max_session_slots;
>  extern unsigned short max_session_cb_slots;
> @@ -477,6 +476,9 @@ extern bool recover_lost_locks;
>  #define NFS4_CLIENT_ID_UNIQ_LEN		(64)
>  extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
>  
> +extern int nfs4_try_get_tree(struct nfs_fs_context *);
> +extern int nfs4_get_tree(struct nfs_fs_context *);
> +
>  /* nfs4sysctl.c */
>  #ifdef CONFIG_SYSCTL
>  int nfs4_register_sysctl(void);
> diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
> index 0b5e1ecfa8f8..431eae161383 100644
> --- a/fs/nfs/nfs4client.c
> +++ b/fs/nfs/nfs4client.c
> @@ -1032,14 +1032,14 @@ static int nfs4_init_server(struct nfs_server *server,
>  
>  	/* Get a client record */
>  	error = nfs4_set_client(server,
> -			ctx->nfs_server.hostname,
> -			(const struct sockaddr *)&ctx->nfs_server.address,
> -			ctx->nfs_server.addrlen,
> -			ctx->client_address,
> -			ctx->nfs_server.protocol,
> -			&timeparms,
> -			ctx->minorversion,
> -			ctx->net);
> +				ctx->nfs_server.hostname,
> +				&ctx->nfs_server.address,
> +				ctx->nfs_server.addrlen,
> +				ctx->client_address,
> +				ctx->nfs_server.protocol,
> +				&timeparms,
> +				ctx->minorversion,
> +				ctx->fc.net_ns);
>  	if (error < 0)
>  		return error;
>  
> @@ -1062,10 +1062,7 @@ static int nfs4_init_server(struct nfs_server *server,
>   * Create a version 4 volume record
>   * - keyed on server and FSID
>   */
> -/*struct nfs_server *nfs4_create_server(const struct nfs_fs_context *data,
> -				      struct nfs_fh *mntfh)*/
> -struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
> -				      struct nfs_subversion *nfs_mod)
> +struct nfs_server *nfs4_create_server(struct nfs_fs_context *ctx)
>  {
>  	struct nfs_server *server;
>  	bool auth_probe;
> @@ -1075,14 +1072,14 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
>  	if (!server)
>  		return ERR_PTR(-ENOMEM);
>  
> -	auth_probe = mount_info->ctx->auth_info.flavor_len < 1;
> +	auth_probe = ctx->auth_info.flavor_len < 1;
>  
>  	/* set up the general RPC client */
> -	error = nfs4_init_server(server, mount_info->ctx);
> +	error = nfs4_init_server(server, ctx);
>  	if (error < 0)
>  		goto error;
>  
> -	error = nfs4_server_common_setup(server, mount_info->mntfh, auth_probe);
> +	error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
>  	if (error < 0)
>  		goto error;
>  
> @@ -1096,8 +1093,7 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
>  /*
>   * Create an NFS4 referral server record
>   */
> -struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
> -					       struct nfs_fh *mntfh)
> +struct nfs_server *nfs4_create_referral_server(struct nfs_fs_context *ctx)
>  {
>  	struct nfs_client *parent_client;
>  	struct nfs_server *server, *parent_server;
> @@ -1108,7 +1104,7 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
>  	if (!server)
>  		return ERR_PTR(-ENOMEM);
>  
> -	parent_server = NFS_SB(data->sb);
> +	parent_server = NFS_SB(ctx->clone_data.sb);
>  	parent_client = parent_server->nfs_client;
>  
>  	/* Initialise the client representation from the parent server */
> @@ -1116,9 +1112,10 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
>  
>  	/* Get a client representation.
>  	 * Note: NFSv4 always uses TCP, */
> -	error = nfs4_set_client(server, data->hostname,
> -				data->addr,
> -				data->addrlen,
> +	error = nfs4_set_client(server,
> +				ctx->nfs_server.hostname,
> +				&ctx->nfs_server.address,
> +				ctx->nfs_server.addrlen,
>  				parent_client->cl_ipaddr,
>  				rpc_protocol(parent_server->client),
>  				parent_server->client->cl_timeout,
> @@ -1127,13 +1124,14 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
>  	if (error < 0)
>  		goto error;
>  
> -	error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, data->authflavor);
> +	error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout,
> +					  ctx->selected_flavor);
>  	if (error < 0)
>  		goto error;
>  
>  	auth_probe = parent_server->auth_info.flavor_len < 1;
>  
> -	error = nfs4_server_common_setup(server, mntfh, auth_probe);
> +	error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
>  	if (error < 0)
>  		goto error;
>  
> diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
> index 7d531da1bae3..07466ae971cc 100644
> --- a/fs/nfs/nfs4namespace.c
> +++ b/fs/nfs/nfs4namespace.c
> @@ -7,6 +7,7 @@
>   * NFSv4 namespace
>   */
>  
> +#include <linux/module.h>
>  #include <linux/dcache.h>
>  #include <linux/mount.h>
>  #include <linux/namei.h>
> @@ -20,37 +21,64 @@
>  #include <linux/inet.h>
>  #include "internal.h"
>  #include "nfs4_fs.h"
> +#include "nfs.h"
>  #include "dns_resolve.h"
>  
>  #define NFSDBG_FACILITY		NFSDBG_VFS
>  
>  /*
> + * Work out the length that an NFSv4 path would render to as a standard posix
> + * path, with a leading slash but no terminating slash.
> + */
> +static ssize_t nfs4_pathname_len(const struct nfs4_pathname *pathname)
> +{
> +	ssize_t len;
> +	int i;
> +
> +	for (i = 0; i < pathname->ncomponents; i++) {
> +		const struct nfs4_string *component = &pathname->components[i];
> +
> +		if (component->len > NAME_MAX)
> +			goto too_long;
> +		len += 1 + component->len; /* Adding "/foo" */
> +		if (len > PATH_MAX)
> +			goto too_long;
> +	}
> +	return len;
> +
> +too_long:
> +	return -ENAMETOOLONG;
> +}
> +
> +/*
>   * Convert the NFSv4 pathname components into a standard posix path.
> - *
> - * Note that the resulting string will be placed at the end of the buffer
>   */
> -static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
> -					 char *buffer, ssize_t buflen)
> +static char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
> +				  unsigned short *_len)
>  {
> -	char *end = buffer + buflen;
> -	int n;
> +	ssize_t len;
> +	char *buf, *p;
> +	int i;
>  
> -	*--end = '\0';
> -	buflen--;
> -
> -	n = pathname->ncomponents;
> -	while (--n >= 0) {
> -		const struct nfs4_string *component = &pathname->components[n];
> -		buflen -= component->len + 1;
> -		if (buflen < 0)
> -			goto Elong;
> -		end -= component->len;
> -		memcpy(end, component->data, component->len);
> -		*--end = '/';
> +	len = nfs4_pathname_len(pathname);
> +	if (len < 0)
> +		return ERR_PTR(len);
> +	*_len = len;
> +
> +	p = buf = kmalloc(len + 1, GFP_KERNEL);
> +	if (!buf)
> +		return ERR_PTR(-ENOMEM);
> +
> +	for (i = 0; i < pathname->ncomponents; i++) {
> +		const struct nfs4_string *component = &pathname->components[i];
> +
> +		*p++ = '/';
> +		memcpy(p, component->data, component->len);
> +		p += component->len;
>  	}
> -	return end;
> -Elong:
> -	return ERR_PTR(-ENAMETOOLONG);
> +
> +	*p = 0;
> +	return buf;
>  }
>  
>  /*
> @@ -99,21 +127,25 @@ static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
>   */
>  static int nfs4_validate_fspath(struct dentry *dentry,
>  				const struct nfs4_fs_locations *locations,
> -				char *page, char *page2)
> +				struct nfs_fs_context *ctx)
>  {
> -	const char *path, *fs_path;
> +	const char *path;
> +	char *buf;
> +	int n;
>  
> -	path = nfs4_path(dentry, page, PAGE_SIZE);
> -	if (IS_ERR(path))
> +	buf = kmalloc(4096, GFP_KERNEL);
> +	path = nfs4_path(dentry, buf, 4096);
> +	if (IS_ERR(path)) {
> +		kfree(buf);
>  		return PTR_ERR(path);
> +	}
>  
> -	fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
> -	if (IS_ERR(fs_path))
> -		return PTR_ERR(fs_path);
> -
> -	if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
> +	n = strncmp(path, ctx->nfs_server.export_path,
> +		    ctx->nfs_server.export_path_len);
> +	kfree(buf);
> +	if (n != 0) {
>  		dprintk("%s: path %s does not begin with fsroot %s\n",
> -			__func__, path, fs_path);
> +			__func__, path, ctx->nfs_server.export_path);
>  		return -ENOENT;
>  	}
>  
> @@ -234,56 +266,66 @@ nfs4_negotiate_security(struct rpc_clnt *clnt, struct inode *inode,
>  	return new;
>  }
>  
> -static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
> -				     char *page, char *page2,
> +static struct vfsmount *try_location(struct dentry *dentry,
> +				     struct nfs_fs_context *ctx,
>  				     const struct nfs4_fs_location *location)
>  {
> -	const size_t addr_bufsize = sizeof(struct sockaddr_storage);
> -	struct net *net = rpc_net_ns(NFS_SB(mountdata->sb)->client);
> +	struct net *net = rpc_net_ns(NFS_SB(dentry->d_sb)->client);
>  	struct vfsmount *mnt = ERR_PTR(-ENOENT);
> -	char *mnt_path;
> -	unsigned int maxbuflen;
> -	unsigned int s;
> +	unsigned int len, s;
> +	char *p;
>  
> -	mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
> -	if (IS_ERR(mnt_path))
> -		return ERR_CAST(mnt_path);
> -	mountdata->mnt_path = mnt_path;
> -	maxbuflen = mnt_path - 1 - page2;
> +	/* Allocate a buffer big enough to hold any of the hostnames plus a
> +	 * terminating char and also a buffer big enough to hold the hostname
> +	 * plus a colon plus the path.
> +	 */
> +	len = 0;
> +	for (s = 0; s < location->nservers; s++) {
> +		const struct nfs4_string *buf = &location->servers[s];
> +		if (buf->len > len)
> +			len = buf->len;
> +	}
>  
> -	mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
> -	if (mountdata->addr == NULL)
> +	ctx->nfs_server.hostname = kmalloc(len + 1, GFP_KERNEL);
> +	if (!ctx->nfs_server.hostname)
>  		return ERR_PTR(-ENOMEM);
>  
> +	ctx->fc.device = kmalloc(len + 1 + ctx->nfs_server.export_path_len + 1,
> +				 GFP_KERNEL);
> +	if (!ctx->fc.device)
> +		return ERR_PTR(-ENOMEM);
> +	
>  	for (s = 0; s < location->nservers; s++) {
>  		const struct nfs4_string *buf = &location->servers[s];
>  
> -		if (buf->len <= 0 || buf->len >= maxbuflen)
> -			continue;
> -
>  		if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
>  			continue;
>  
> -		mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
> -				mountdata->addr, addr_bufsize, net);
> -		if (mountdata->addrlen == 0)
> +		ctx->nfs_server.addrlen =
> +			nfs_parse_server_name(buf->data, buf->len,
> +					      &ctx->nfs_server.address,
> +					      sizeof(ctx->nfs_server._address),
> +					      net);
> +		if (ctx->nfs_server.addrlen == 0)
>  			continue;
>  
> -		rpc_set_port(mountdata->addr, NFS_PORT);
> +		rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
>  
> -		memcpy(page2, buf->data, buf->len);
> -		page2[buf->len] = '\0';
> -		mountdata->hostname = page2;
> +		memcpy(ctx->nfs_server.hostname, buf->data, buf->len);
> +		ctx->nfs_server.hostname[buf->len] = '\0';
>  
> -		snprintf(page, PAGE_SIZE, "%s:%s",
> -				mountdata->hostname,
> -				mountdata->mnt_path);
> +		p = ctx->fc.device;
> +		memcpy(p, buf->data, buf->len);
> +		p += buf->len;
> +		*p++ = ':';
> +		memcpy(p, ctx->nfs_server.export_path, ctx->nfs_server.export_path_len);
> +		p += ctx->nfs_server.export_path_len;
> +		*p = 0;
>  
> -		mnt = vfs_submount(mountdata->dentry, &nfs4_referral_fs_type, page, mountdata);
> +		mnt = vfs_kern_mount_fc(&ctx->fc);
>  		if (!IS_ERR(mnt))
>  			break;
>  	}
> -	kfree(mountdata->addr);
>  	return mnt;
>  }
>  
> @@ -296,33 +338,43 @@ static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
>  static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
>  					    const struct nfs4_fs_locations *locations)
>  {
> -	struct vfsmount *mnt = ERR_PTR(-ENOENT);
> -	struct nfs_clone_mount mountdata = {
> -		.sb = dentry->d_sb,
> -		.dentry = dentry,
> -		.authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
> -	};
> -	char *page = NULL, *page2 = NULL;
> +	struct nfs_fs_context *ctx;
> +	struct fs_context *fc;
> +	struct vfsmount *mnt;
> +	char *export_path;
>  	int loc, error;
>  
>  	if (locations == NULL || locations->nlocations <= 0)
>  		goto out;
>  
> +	fc = vfs_new_fs_context(&nfs4_fs_type, dentry->d_sb, 0,
> +			       FS_CONTEXT_FOR_SUBMOUNT);
> +	if (IS_ERR(fc)) {
> +		mnt = ERR_CAST(fc);
> +		goto out;
> +	}
> +	ctx = container_of(fc, struct nfs_fs_context, fc);
> +
>  	dprintk("%s: referral at %pd2\n", __func__, dentry);
>  
> -	page = (char *) __get_free_page(GFP_USER);
> -	if (!page)
> -		goto out;
> +	ctx->mount_type		= NFS4_MOUNT_REFERRAL;
> +	ctx->clone_data.sb	= dentry->d_sb;
> +	ctx->clone_data.dentry	= dentry;
> +	ctx->clone_data.cloned	= true;
>  
> -	page2 = (char *) __get_free_page(GFP_USER);
> -	if (!page2)
> -		goto out;
> +	export_path = nfs4_pathname_string(&locations->fs_path,
> +					   &ctx->nfs_server.export_path_len);
> +	if (IS_ERR(export_path)) {
> +		mnt = ERR_CAST(export_path);
> +		goto out_sc;
> +	}
> +	ctx->nfs_server.export_path = export_path;
>  
>  	/* Ensure fs path is a prefix of current dentry path */
> -	error = nfs4_validate_fspath(dentry, locations, page, page2);
> +	error = nfs4_validate_fspath(dentry, locations, ctx);
>  	if (error < 0) {
>  		mnt = ERR_PTR(error);
> -		goto out;
> +		goto out_sc;
>  	}
>  
>  	for (loc = 0; loc < locations->nlocations; loc++) {
> @@ -332,14 +384,14 @@ static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
>  		    location->rootpath.ncomponents == 0)
>  			continue;
>  
> -		mnt = try_location(&mountdata, page, page2, location);
> +		mnt = try_location(ctx->clone_data.dentry, ctx, location);
>  		if (!IS_ERR(mnt))
>  			break;
>  	}
>  
> +out_sc:
> +	put_fs_context(fc);
>  out:
> -	free_page((unsigned long) page);
> -	free_page((unsigned long) page2);
>  	return mnt;
>  }
>  
> diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
> index c08c46a3b8cd..ca792f799941 100644
> --- a/fs/nfs/nfs4proc.c
> +++ b/fs/nfs/nfs4proc.c
> @@ -9307,8 +9307,9 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
>  	.file_inode_ops	= &nfs4_file_inode_operations,
>  	.file_ops	= &nfs4_file_operations,
>  	.getroot	= nfs4_proc_get_root,
> +	.get_tree	= nfs4_get_tree,
>  	.submount	= nfs4_submount,
> -	.try_mount	= nfs4_try_mount,
> +	.try_get_tree	= nfs4_try_get_tree,
>  	.getattr	= nfs4_proc_getattr,
>  	.setattr	= nfs4_proc_setattr,
>  	.lookup		= nfs4_proc_lookup,
> diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
> index 70111f222a25..9f2eacfee42c 100644
> --- a/fs/nfs/nfs4super.c
> +++ b/fs/nfs/nfs4super.c
> @@ -3,6 +3,7 @@
>   */
>  #include <linux/init.h>
>  #include <linux/module.h>
> +#include <linux/mount.h>
>  #include <linux/nfs4_mount.h>
>  #include <linux/nfs_fs.h>
>  #include "delegation.h"
> @@ -17,36 +18,6 @@
>  
>  static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc);
>  static void nfs4_evict_inode(struct inode *inode);
> -static struct dentry *nfs4_remote_mount(struct file_system_type *fs_type,
> -	int flags, const char *dev_name, void *raw_data);
> -static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
> -	int flags, const char *dev_name, void *raw_data);
> -static struct dentry *nfs4_remote_referral_mount(struct file_system_type *fs_type,
> -	int flags, const char *dev_name, void *raw_data);
> -
> -static struct file_system_type nfs4_remote_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name		= "nfs4",
> -	.mount		= nfs4_remote_mount,
> -	.kill_sb	= nfs_kill_super,
> -	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> -};
> -
> -static struct file_system_type nfs4_remote_referral_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name		= "nfs4",
> -	.mount		= nfs4_remote_referral_mount,
> -	.kill_sb	= nfs_kill_super,
> -	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> -};
> -
> -struct file_system_type nfs4_referral_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name		= "nfs4",
> -	.mount		= nfs4_referral_mount,
> -	.kill_sb	= nfs_kill_super,
> -	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> -};
>  
>  static const struct super_operations nfs4_sops = {
>  	.alloc_inode	= nfs_alloc_inode,
> @@ -60,16 +31,16 @@ static const struct super_operations nfs4_sops = {
>  	.show_devname	= nfs_show_devname,
>  	.show_path	= nfs_show_path,
>  	.show_stats	= nfs_show_stats,
> -	.remount_fs	= nfs_remount,
> +	.remount_fs_fc	= nfs_remount,
>  };
>  
>  struct nfs_subversion nfs_v4 = {
> -	.owner = THIS_MODULE,
> -	.nfs_fs   = &nfs4_fs_type,
> -	.rpc_vers = &nfs_version4,
> -	.rpc_ops  = &nfs_v4_clientops,
> -	.sops     = &nfs4_sops,
> -	.xattr    = nfs4_xattr_handlers,
> +	.owner		= THIS_MODULE,
> +	.nfs_fs		= &nfs4_fs_type,
> +	.rpc_vers	= &nfs_version4,
> +	.rpc_ops	= &nfs_v4_clientops,
> +	.sops		= &nfs4_sops,
> +	.xattr		= nfs4_xattr_handlers,
>  };
>  
>  static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc)
> @@ -103,47 +74,63 @@ static void nfs4_evict_inode(struct inode *inode)
>  /*
>   * Get the superblock for the NFS4 root partition
>   */
> -static struct dentry *
> -nfs4_remote_mount(struct file_system_type *fs_type, int flags,
> -		  const char *dev_name, void *info)
> +static int nfs4_get_remote_tree(struct nfs_fs_context *ctx)
>  {
> -	struct nfs_mount_info *mount_info = info;
>  	struct nfs_server *server;
> -	struct dentry *mntroot = ERR_PTR(-ENOMEM);
>  
> -	mount_info->set_security = nfs_set_sb_security;
> +	ctx->set_security = nfs_set_sb_security;
>  
>  	/* Get a volume representation */
> -	server = nfs4_create_server(mount_info, &nfs_v4);
> -	if (IS_ERR(server)) {
> -		mntroot = ERR_CAST(server);
> -		goto out;
> -	}
> -
> -	mntroot = nfs_fs_mount_common(server, flags, dev_name, mount_info, &nfs_v4);
> +	server = nfs4_create_server(ctx);
> +	if (IS_ERR(server))
> +		return PTR_ERR(server);
>  
> -out:
> -	return mntroot;
> +	return nfs_get_tree_common(server, ctx);
>  }
>  
> -static struct vfsmount *nfs_do_root_mount(struct file_system_type *fs_type,
> -		int flags, void *data, const char *hostname)
> +/*
> + * Create a mount for the root of the server.  We copy the mount context we
> + * have for the parameters and set its hostname, path and type.
> + */
> +static struct vfsmount *nfs_do_root_mount(struct nfs_fs_context *ctx,
> +					  const char *hostname,
> +					  enum nfs_mount_type type)
>  {
> +	struct nfs_fs_context *root_ctx;
> +	struct fs_context *root_fc;
>  	struct vfsmount *root_mnt;
>  	char *root_devname;
>  	size_t len;
> +	int ret;
> +
> +	root_fc = vfs_dup_fs_context(&ctx->fc);
> +	if (IS_ERR(root_fc))
> +		return ERR_CAST(root_fc);
> +	root_ctx = container_of(root_fc, struct nfs_fs_context, fc);
> +
> +	root_ctx->mount_type = type;
> +	root_ctx->nfs_server.export_path = (char *)nfs_slash;
>  
>  	len = strlen(hostname) + 5;
> +	root_mnt = ERR_PTR(-ENOMEM);
>  	root_devname = kmalloc(len, GFP_KERNEL);
>  	if (root_devname == NULL)
> -		return ERR_PTR(-ENOMEM);
> +		goto out_fc;
> +
>  	/* Does hostname needs to be enclosed in brackets? */
>  	if (strchr(hostname, ':'))
>  		snprintf(root_devname, len, "[%s]:/", hostname);
>  	else
>  		snprintf(root_devname, len, "%s:/", hostname);
> -	root_mnt = vfs_kern_mount(fs_type, flags, root_devname, data);
> -	kfree(root_devname);
> +	root_ctx->fc.device = root_devname;
> +
> +	ret = vfs_get_tree(&root_ctx->fc);
> +	if (ret < 0)
> +		return ERR_PTR(ret);
> +
> +	root_mnt = vfs_kern_mount_fc(&root_ctx->fc);
> +out_fc:
> +	put_fs_context(root_fc);
>  	return root_mnt;
>  }
>  
> @@ -234,89 +221,98 @@ static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
>  	return dentry;
>  }
>  
> -struct dentry *nfs4_try_mount(int flags, const char *dev_name,
> -			      struct nfs_mount_info *mount_info,
> -			      struct nfs_subversion *nfs_mod)
> +int nfs4_try_get_tree(struct nfs_fs_context *ctx)
>  {
> -	char *export_path;
>  	struct vfsmount *root_mnt;
> -	struct dentry *res;
> -	struct nfs_fs_context *ctx = mount_info->ctx;
> +	struct dentry *root;
>  
> -	dfprintk(MOUNT, "--> nfs4_try_mount()\n");
> +	dfprintk(MOUNT, "--> nfs4_try_get_tree()\n");
>  
> -	export_path = ctx->nfs_server.export_path;
> -	ctx->nfs_server.export_path = "/";
> -	root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, mount_info,
> -			ctx->nfs_server.hostname);
> -	ctx->nfs_server.export_path = export_path;
> -
> -	res = nfs_follow_remote_path(root_mnt, export_path);
> +	/* We create a mount for the server's root, walk to the requested
> +	 * location and then create another mount for that.
> +	 */
> +	root_mnt = nfs_do_root_mount(ctx, ctx->nfs_server.hostname,
> +				     NFS4_MOUNT_REMOTE);
> +	if (IS_ERR(root_mnt))
> +		return PTR_ERR(root_mnt);
> +
> +	root = nfs_follow_remote_path(root_mnt, ctx->nfs_server.export_path);
> +	if (IS_ERR(root)) {
> +		errorf("NFS4: Couldn't follow remote path");
> +		dfprintk(MOUNT, "<-- nfs4_try_mount() = %ld [error]\n",
> +			 PTR_ERR(root));
> +		return PTR_ERR(root);
> +	}
>  
> -	dfprintk(MOUNT, "<-- nfs4_try_mount() = %d%s\n",
> -		 PTR_ERR_OR_ZERO(res),
> -		 IS_ERR(res) ? " [error]" : "");
> -	return res;
> +	ctx->fc.root = root;
> +	dfprintk(MOUNT, "<-- nfs4_try_get_tree() = 0\n");
> +	return 0;
>  }
>  
> -static struct dentry *
> -nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags,
> -			   const char *dev_name, void *raw_data)
> +static int nfs4_get_remote_referral_tree(struct nfs_fs_context *ctx)
>  {
> -	struct nfs_mount_info mount_info = {
> -		.fill_super = nfs_fill_super,
> -		.set_security = nfs_clone_sb_security,
> -		.cloned = raw_data,
> -	};
>  	struct nfs_server *server;
> -	struct dentry *mntroot = ERR_PTR(-ENOMEM);
>  
> -	dprintk("--> nfs4_referral_get_sb()\n");
> +	dprintk("--> nfs4_get_remote_referral_tree()\n");
>  
> -	mount_info.mntfh = nfs_alloc_fhandle();
> -	if (mount_info.cloned == NULL || mount_info.mntfh == NULL)
> -		goto out;
> +	ctx->set_security = nfs_clone_sb_security;
> +
> +	if (!ctx->clone_data.cloned)
> +		return -EINVAL;
>  
>  	/* create a new volume representation */
> -	server = nfs4_create_referral_server(mount_info.cloned, mount_info.mntfh);
> -	if (IS_ERR(server)) {
> -		mntroot = ERR_CAST(server);
> -		goto out;
> -	}
> +	server = nfs4_create_referral_server(ctx);
> +	if (IS_ERR(server))
> +		return PTR_ERR(server);
>  
> -	mntroot = nfs_fs_mount_common(server, flags, dev_name, &mount_info, &nfs_v4);
> -out:
> -	nfs_free_fhandle(mount_info.mntfh);
> -	return mntroot;
> +	return nfs_get_tree_common(server, ctx);
>  }
>  
>  /*
>   * Create an NFS4 server record on referral traversal
>   */
> -static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
> -		int flags, const char *dev_name, void *raw_data)
> +static int nfs4_get_referral_tree(struct nfs_fs_context *ctx)
>  {
> -	struct nfs_clone_mount *data = raw_data;
> -	char *export_path;
>  	struct vfsmount *root_mnt;
> -	struct dentry *res;
> +	struct dentry *root;
>  
>  	dprintk("--> nfs4_referral_mount()\n");
>  
> -	export_path = data->mnt_path;
> -	data->mnt_path = "/";
> +	root_mnt = nfs_do_root_mount(ctx, ctx->nfs_server.hostname,
> +				     NFS4_MOUNT_REMOTE_REFERRAL);
>  
> -	root_mnt = nfs_do_root_mount(&nfs4_remote_referral_fs_type,
> -			flags, data, data->hostname);
> -	data->mnt_path = export_path;
> +	root = nfs_follow_remote_path(root_mnt, ctx->nfs_server.export_path);
> +	if (IS_ERR(root)) {
> +		errorf("NFS4: Couldn't follow remote path");
> +		dfprintk(MOUNT, "<-- nfs4_referral_mount() = %ld [error]\n",
> +			 PTR_ERR(root));
> +		return PTR_ERR(root);
> +	}
>  
> -	res = nfs_follow_remote_path(root_mnt, export_path);
> -	dprintk("<-- nfs4_referral_mount() = %d%s\n",
> -		PTR_ERR_OR_ZERO(res),
> -		IS_ERR(res) ? " [error]" : "");
> -	return res;
> +	ctx->fc.root = root;
> +	dfprintk(MOUNT, "<-- nfs4_get_referral_tree() = 0\n");
> +	return 0;
>  }
>  
> +/*
> + * Handle special NFS4 mount types.
> + */
> +int nfs4_get_tree(struct nfs_fs_context *ctx)
> +{
> +	switch (ctx->mount_type) {
> +	case NFS4_MOUNT_REMOTE:
> +		return nfs4_get_remote_tree(ctx);
> +
> +	case NFS4_MOUNT_REFERRAL:
> +		return nfs4_get_referral_tree(ctx);
> +
> +	case NFS4_MOUNT_REMOTE_REFERRAL:
> +		return nfs4_get_remote_referral_tree(ctx);
> +
> +	default:
> +		return 1;
> +	}
> +}
>  
>  static int __init init_nfs_v4(void)
>  {
> diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
> index 9872cf676a50..cd22b82e7bb8 100644
> --- a/fs/nfs/proc.c
> +++ b/fs/nfs/proc.c
> @@ -705,7 +705,7 @@ const struct nfs_rpc_ops nfs_v2_clientops = {
>  	.file_ops	= &nfs_file_operations,
>  	.getroot	= nfs_proc_get_root,
>  	.submount	= nfs_submount,
> -	.try_mount	= nfs_try_mount,
> +	.try_get_tree	= nfs_try_get_tree,
>  	.getattr	= nfs_proc_getattr,
>  	.setattr	= nfs_proc_setattr,
>  	.lookup		= nfs_proc_lookup,
> diff --git a/fs/nfs/super.c b/fs/nfs/super.c
> index c13f0ff42df9..3ef689c08f48 100644
> --- a/fs/nfs/super.c
> +++ b/fs/nfs/super.c
> @@ -69,27 +69,6 @@
>  
>  #define NFSDBG_FACILITY		NFSDBG_VFS
>  
> -static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
> -		int flags, const char *dev_name, void *raw_data);
> -
> -struct file_system_type nfs_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name		= "nfs",
> -	.mount		= nfs_fs_mount,
> -	.kill_sb	= nfs_kill_super,
> -	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> -};
> -MODULE_ALIAS_FS("nfs");
> -EXPORT_SYMBOL_GPL(nfs_fs_type);
> -
> -struct file_system_type nfs_xdev_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name		= "nfs",
> -	.mount		= nfs_xdev_mount,
> -	.kill_sb	= nfs_kill_super,
> -	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> -};
> -
>  const struct super_operations nfs_sops = {
>  	.alloc_inode	= nfs_alloc_inode,
>  	.destroy_inode	= nfs_destroy_inode,
> @@ -102,22 +81,11 @@ const struct super_operations nfs_sops = {
>  	.show_devname	= nfs_show_devname,
>  	.show_path	= nfs_show_path,
>  	.show_stats	= nfs_show_stats,
> -	.remount_fs	= nfs_remount,
> +	.remount_fs_fc	= nfs_remount,
>  };
>  EXPORT_SYMBOL_GPL(nfs_sops);
>  
>  #if IS_ENABLED(CONFIG_NFS_V4)
> -struct file_system_type nfs4_fs_type = {
> -	.owner		= THIS_MODULE,
> -	.name		= "nfs4",
> -	.mount		= nfs_fs_mount,
> -	.kill_sb	= nfs_kill_super,
> -	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
> -};
> -MODULE_ALIAS_FS("nfs4");
> -MODULE_ALIAS("nfs4");
> -EXPORT_SYMBOL_GPL(nfs4_fs_type);
> -
>  static int __init register_nfs4_fs(void)
>  {
>  	return register_filesystem(&nfs4_fs_type);
> @@ -710,11 +678,11 @@ bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
>  EXPORT_SYMBOL_GPL(nfs_auth_info_match);
>  
>  /*
> - * Ensure that a specified authtype in cfg->auth_info is supported by
> - * the server. Returns 0 and sets cfg->selected_flavor if it's ok, and
> + * Ensure that a specified authtype in ctx->auth_info is supported by
> + * the server. Returns 0 and sets ctx->selected_flavor if it's ok, and
>   * -EACCES if not.
>   */
> -static int nfs_verify_authflavors(struct nfs_fs_context *cfg,
> +static int nfs_verify_authflavors(struct nfs_fs_context *ctx,
>  			rpc_authflavor_t *server_authlist, unsigned int count)
>  {
>  	rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
> @@ -732,7 +700,7 @@ static int nfs_verify_authflavors(struct nfs_fs_context *cfg,
>  	for (i = 0; i < count; i++) {
>  		flavor = server_authlist[i];
>  
> -		if (nfs_auth_info_match(&cfg->auth_info, flavor))
> +		if (nfs_auth_info_match(&ctx->auth_info, flavor))
>  			goto out;
>  
>  		if (flavor == RPC_AUTH_NULL)
> @@ -749,8 +717,8 @@ static int nfs_verify_authflavors(struct nfs_fs_context *cfg,
>  	return -EACCES;
>  
>  out:
> -	cfg->selected_flavor = flavor;
> -	dfprintk(MOUNT, "NFS: using auth flavor %u\n", cfg->selected_flavor);
> +	ctx->selected_flavor = flavor;
> +	dfprintk(MOUNT, "NFS: using auth flavor %u\n", ctx->selected_flavor);
>  	return 0;
>  }
>  
> @@ -758,50 +726,50 @@ static int nfs_verify_authflavors(struct nfs_fs_context *cfg,
>   * Use the remote server's MOUNT service to request the NFS file handle
>   * corresponding to the provided path.
>   */
> -static int nfs_request_mount(struct nfs_fs_context *cfg,
> +static int nfs_request_mount(struct nfs_fs_context *ctx,
>  			     struct nfs_fh *root_fh,
>  			     rpc_authflavor_t *server_authlist,
>  			     unsigned int *server_authlist_len)
>  {
>  	struct nfs_mount_request request = {
>  		.sap		= (struct sockaddr *)
> -						&cfg->mount_server.address,
> -		.dirpath	= cfg->nfs_server.export_path,
> -		.protocol	= cfg->mount_server.protocol,
> +						&ctx->mount_server.address,
> +		.dirpath	= ctx->nfs_server.export_path,
> +		.protocol	= ctx->mount_server.protocol,
>  		.fh		= root_fh,
> -		.noresvport	= cfg->flags & NFS_MOUNT_NORESVPORT,
> +		.noresvport	= ctx->flags & NFS_MOUNT_NORESVPORT,
>  		.auth_flav_len	= server_authlist_len,
>  		.auth_flavs	= server_authlist,
> -		.net		= cfg->net,
> +		.net		= ctx->fc.net_ns,
>  	};
>  	int status;
>  
> -	if (cfg->mount_server.version == 0) {
> -		switch (cfg->version) {
> +	if (ctx->mount_server.version == 0) {
> +		switch (ctx->version) {
>  			default:
> -				cfg->mount_server.version = NFS_MNT3_VERSION;
> +				ctx->mount_server.version = NFS_MNT3_VERSION;
>  				break;
>  			case 2:
> -				cfg->mount_server.version = NFS_MNT_VERSION;
> +				ctx->mount_server.version = NFS_MNT_VERSION;
>  		}
>  	}
> -	request.version = cfg->mount_server.version;
> +	request.version = ctx->mount_server.version;
>  
> -	if (cfg->mount_server.hostname)
> -		request.hostname = cfg->mount_server.hostname;
> +	if (ctx->mount_server.hostname)
> +		request.hostname = ctx->mount_server.hostname;
>  	else
> -		request.hostname = cfg->nfs_server.hostname;
> +		request.hostname = ctx->nfs_server.hostname;
>  
>  	/*
>  	 * Construct the mount server's address.
>  	 */
> -	if (cfg->mount_server.address.sa_family == AF_UNSPEC) {
> -		memcpy(request.sap, &cfg->nfs_server.address,
> -		       cfg->nfs_server.addrlen);
> -		cfg->mount_server.addrlen = cfg->nfs_server.addrlen;
> +	if (ctx->mount_server.address.sa_family == AF_UNSPEC) {
> +		memcpy(request.sap, &ctx->nfs_server.address,
> +		       ctx->nfs_server.addrlen);
> +		ctx->mount_server.addrlen = ctx->nfs_server.addrlen;
>  	}
> -	request.salen = cfg->mount_server.addrlen;
> -	nfs_set_port(request.sap, &cfg->mount_server.port, 0);
> +	request.salen = ctx->mount_server.addrlen;
> +	nfs_set_port(request.sap, &ctx->mount_server.port, 0);
>  
>  	/*
>  	 * Now ask the mount server to map our export path
> @@ -817,20 +785,17 @@ static int nfs_request_mount(struct nfs_fs_context *cfg,
>  	return 0;
>  }
>  
> -static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info,
> -					struct nfs_subversion *nfs_mod)
> +static struct nfs_server *nfs_try_mount_request(struct nfs_fs_context *ctx)
>  {
>  	int status;
>  	unsigned int i;
>  	bool tried_auth_unix = false;
>  	bool auth_null_in_list = false;
>  	struct nfs_server *server = ERR_PTR(-EACCES);
> -	struct nfs_fs_context *ctx = mount_info->ctx;
>  	rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
>  	unsigned int authlist_len = ARRAY_SIZE(authlist);
>  
> -	status = nfs_request_mount(ctx, mount_info->mntfh, authlist,
> -					&authlist_len);
> +	status = nfs_request_mount(ctx, ctx->mntfh, authlist, &authlist_len);
>  	if (status)
>  		return ERR_PTR(status);
>  
> @@ -844,7 +809,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
>  			 ctx->selected_flavor);
>  		if (status)
>  			return ERR_PTR(status);
> -		return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
> +		return ctx->nfs_mod->rpc_ops->create_server(ctx);
>  	}
>  
>  	/*
> @@ -871,7 +836,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
>  		}
>  		dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
>  		ctx->selected_flavor = flavor;
> -		server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
> +		server = ctx->nfs_mod->rpc_ops->create_server(ctx);
>  		if (!IS_ERR(server))
>  			return server;
>  	}
> @@ -887,26 +852,27 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
>  	/* Last chance! Try AUTH_UNIX */
>  	dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
>  	ctx->selected_flavor = RPC_AUTH_UNIX;
> -	return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
> +	return ctx->nfs_mod->rpc_ops->create_server(ctx);
>  }
>  
> -struct dentry *nfs_try_mount(int flags, const char *dev_name,
> -			     struct nfs_mount_info *mount_info,
> -			     struct nfs_subversion *nfs_mod)
> +int nfs_try_get_tree(struct nfs_fs_context *ctx)
>  {
>  	struct nfs_server *server;
>  
> -	if (mount_info->ctx->need_mount)
> -		server = nfs_try_mount_request(mount_info, nfs_mod);
> +	if (ctx->need_mount)
> +		server = nfs_try_mount_request(ctx);
>  	else
> -		server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
> +		server = ctx->nfs_mod->rpc_ops->create_server(ctx);
>  
> -	if (IS_ERR(server))
> -		return ERR_CAST(server);
> +	if (IS_ERR(server)) {
> +		errorf("NFS: Couldn't create server");
> +		return PTR_ERR(server);
> +	}
>  
> -	return nfs_fs_mount_common(server, flags, dev_name, mount_info, nfs_mod);
> +	return nfs_get_tree_common(server, ctx);
>  }
> -EXPORT_SYMBOL_GPL(nfs_try_mount);
> +EXPORT_SYMBOL_GPL(nfs_try_get_tree);
> +
>  
>  #define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
>  		| NFS_MOUNT_SECURE \
> @@ -946,15 +912,11 @@ nfs_compare_remount_data(struct nfs_server *nfss,
>  	return 0;
>  }
>  
> -int
> -nfs_remount(struct super_block *sb, int *flags, char *raw_data)
> +int nfs_remount(struct super_block *sb, struct fs_context *fc)
>  {
> -	int error;
> +	struct nfs_fs_context *ctx =
> +		container_of(fc, struct nfs_fs_context, fc);
>  	struct nfs_server *nfss = sb->s_fs_info;
> -	struct nfs_fs_context *ctx;
> -	struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
> -	struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
> -	u32 nfsvers = nfss->nfs_client->rpc_ops->version;
>  
>  	sync_filesystem(sb);
>  
> @@ -964,39 +926,9 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
>  	 * ones were explicitly specified. Fall back to legacy behavior and
>  	 * just return success.
>  	 */
> -	if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
> -	    (nfsvers <= 3 && (!options || (options->version >= 1 &&
> -					   options->version <= 6))))
> +	if (ctx->skip_remount_option_check)
>  		return 0;
>  
> -	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
> -	if (ctx == NULL)
> -		return -ENOMEM;
> -
> -	/* fill out struct with values from existing mount */
> -	ctx->flags = nfss->flags;
> -	ctx->rsize = nfss->rsize;
> -	ctx->wsize = nfss->wsize;
> -	ctx->retrans = nfss->client->cl_timeout->to_retries;
> -	ctx->selected_flavor = nfss->client->cl_auth->au_flavor;
> -	ctx->acregmin = nfss->acregmin / HZ;
> -	ctx->acregmax = nfss->acregmax / HZ;
> -	ctx->acdirmin = nfss->acdirmin / HZ;
> -	ctx->acdirmax = nfss->acdirmax / HZ;
> -	ctx->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
> -	ctx->nfs_server.port = nfss->port;
> -	ctx->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
> -	ctx->version = nfsvers;
> -	ctx->minorversion = nfss->nfs_client->cl_minorversion;
> -	ctx->net = current->nsproxy->net_ns;
> -	memcpy(&ctx->nfs_server.address, &nfss->nfs_client->cl_addr,
> -		ctx->nfs_server.addrlen);
> -
> -	/* overwrite those values with any that were specified */
> -	error = -EINVAL;
> -	if (!nfs_parse_mount_options((char *)options, ctx))
> -		goto out;
> -
>  	/*
>  	 * noac is a special case. It implies -o sync, but that's not
>  	 * necessarily reflected in the mtab options. do_remount_sb
> @@ -1004,13 +936,10 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
>  	 * remount options, so we have to explicitly reset it.
>  	 */
>  	if (ctx->flags & NFS_MOUNT_NOAC)
> -		*flags |= SB_SYNCHRONOUS;
> +		ctx->fc.sb_flags |= SB_SYNCHRONOUS;
>  
>  	/* compare new mount options with old ones */
> -	error = nfs_compare_remount_data(nfss, ctx);
> -out:
> -	kfree(ctx);
> -	return error;
> +	return nfs_compare_remount_data(nfss, ctx);
>  }
>  EXPORT_SYMBOL_GPL(nfs_remount);
>  
> @@ -1037,9 +966,8 @@ static void nfs_initialise_sb(struct super_block *sb)
>  /*
>   * Finish setting up an NFS2/3 superblock
>   */
> -void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
> +static void nfs_fill_super(struct super_block *sb, struct nfs_fs_context *ctx)
>  {
> -	struct nfs_fs_context *ctx = mount_info->ctx;
>  	struct nfs_server *server = NFS_SB(sb);
>  
>  	sb->s_blocksize_bits = 0;
> @@ -1059,15 +987,13 @@ void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
>  
>   	nfs_initialise_sb(sb);
>  }
> -EXPORT_SYMBOL_GPL(nfs_fill_super);
>  
>  /*
>   * Finish setting up a cloned NFS2/3/4 superblock
>   */
> -static void nfs_clone_super(struct super_block *sb,
> -			    struct nfs_mount_info *mount_info)
> +static void nfs_clone_super(struct super_block *sb, struct nfs_fs_context *ctx)
>  {
> -	const struct super_block *old_sb = mount_info->cloned->sb;
> +	const struct super_block *old_sb = ctx->clone_data.sb;
>  	struct nfs_server *server = NFS_SB(sb);
>  
>  	sb->s_blocksize_bits = old_sb->s_blocksize_bits;
> @@ -1087,13 +1013,14 @@ static void nfs_clone_super(struct super_block *sb,
>   	nfs_initialise_sb(sb);
>  }
>  
> -static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
> +static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b,
> +				     const struct nfs_fs_context *ctx)
>  {
>  	const struct nfs_server *a = s->s_fs_info;
>  	const struct rpc_clnt *clnt_a = a->client;
>  	const struct rpc_clnt *clnt_b = b->client;
>  
> -	if ((s->s_flags & NFS_SB_MASK) != (flags & NFS_SB_MASK))
> +	if ((s->s_flags & NFS_SB_MASK) != (ctx->fc.sb_flags & NFS_SB_MASK))
>  		goto Ebusy;
>  	if (a->nfs_client != b->nfs_client)
>  		goto Ebusy;
> @@ -1119,18 +1046,13 @@ static int nfs_compare_mount_options(const struct super_block *s, const struct n
>  	return 0;
>  }
>  
> -struct nfs_sb_mountdata {
> -	struct nfs_server *server;
> -	int mntflags;
> -};
> -
> -static int nfs_set_super(struct super_block *s, void *data)
> +static int nfs_set_super(struct super_block *s, struct fs_context *fc)
>  {
> -	struct nfs_sb_mountdata *sb_mntdata = data;
> -	struct nfs_server *server = sb_mntdata->server;
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +	struct nfs_server *server = ctx->server;
>  	int ret;
>  
> -	s->s_flags = sb_mntdata->mntflags;
> +	s->s_flags = ctx->fc.sb_flags;
>  	s->s_fs_info = server;
>  	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
>  	ret = set_anon_super(s, server);
> @@ -1181,11 +1103,10 @@ static int nfs_compare_super_address(struct nfs_server *server1,
>  	return 1;
>  }
>  
> -static int nfs_compare_super(struct super_block *sb, void *data)
> +static int nfs_compare_super(struct super_block *sb, struct fs_context *fc)
>  {
> -	struct nfs_sb_mountdata *sb_mntdata = data;
> -	struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
> -	int mntflags = sb_mntdata->mntflags;
> +	struct nfs_fs_context *ctx = container_of(fc, struct nfs_fs_context, fc);
> +	struct nfs_server *server = ctx->server, *old = NFS_SB(sb);
>  
>  	if (!nfs_compare_super_address(old, server))
>  		return 0;
> @@ -1194,13 +1115,12 @@ static int nfs_compare_super(struct super_block *sb, void *data)
>  		return 0;
>  	if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
>  		return 0;
> -	return nfs_compare_mount_options(sb, server, mntflags);
> +	return nfs_compare_mount_options(sb, server, ctx);
>  }
>  
>  #ifdef CONFIG_NFS_FSCACHE
>  static void nfs_get_cache_cookie(struct super_block *sb,
> -				 struct nfs_fs_context *ctx,
> -				 struct nfs_clone_mount *cloned)
> +				 struct nfs_fs_context *ctx)
>  {
>  	struct nfs_server *nfss = NFS_SB(sb);
>  	char *uniq = NULL;
> @@ -1209,77 +1129,72 @@ static void nfs_get_cache_cookie(struct super_block *sb,
>  	nfss->fscache_key = NULL;
>  	nfss->fscache = NULL;
>  
> -	if (ctx) {
> +	if (!ctx)
> +		return;
> +
> +	if (ctx->clone_data.cloned) {
> +		struct nfs_server *mnt_s = NFS_SB(ctx->clone_data.sb);
> +		if (!(mnt_s->options & NFS_OPTION_FSCACHE))
> +			return;
> +		if (mnt_s->fscache_key) {
> +			uniq = mnt_s->fscache_key->key.uniquifier;
> +			ulen = mnt_s->fscache_key->key.uniq_len;
> +		}
> +	} else {
>  		if (!(ctx->options & NFS_OPTION_FSCACHE))
>  			return;
>  		if (ctx->fscache_uniq) {
>  			uniq = ctx->fscache_uniq;
>  			ulen = strlen(ctx->fscache_uniq);
>  		}
> -	} else if (cloned) {
> -		struct nfs_server *mnt_s = NFS_SB(cloned->sb);
> -		if (!(mnt_s->options & NFS_OPTION_FSCACHE))
> -			return;
> -		if (mnt_s->fscache_key) {
> -			uniq = mnt_s->fscache_key->key.uniquifier;
> -			ulen = mnt_s->fscache_key->key.uniq_len;
> -		};
> -	} else
>  		return;
> +	}
>  
>  	nfs_fscache_get_super_cookie(sb, uniq, ulen);
>  }
>  #else
>  static void nfs_get_cache_cookie(struct super_block *sb,
> -				 struct nfs_fs_context *parsed,
> -				 struct nfs_clone_mount *cloned)
> +				 struct nfs_fs_context *ctx)
>  {
>  }
>  #endif
>  
> -int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
> -			struct nfs_mount_info *mount_info)
> +int nfs_set_sb_security(struct super_block *sb, struct nfs_fs_context *ctx)
>  {
>  	int error;
>  	unsigned long kflags = 0, kflags_out = 0;
> -	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
> +
> +	if (NFS_SB(sb)->caps & NFS_CAP_SECURITY_LABEL)
>  		kflags |= SECURITY_LSM_NATIVE_LABELS;
>  
> -	error = security_sb_set_mnt_opts(s, &mount_info->ctx->lsm_opts,
> -						kflags, &kflags_out);
> +	error = security_sb_set_mnt_opts(sb, ctx->fc.security,
> +					 kflags, &kflags_out);
>  	if (error)
>  		goto err;
>  
> -	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
> -		!(kflags_out & SECURITY_LSM_NATIVE_LABELS))
> -		NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
> +	if (NFS_SB(sb)->caps & NFS_CAP_SECURITY_LABEL &&
> +	    !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
> +		NFS_SB(sb)->caps &= ~NFS_CAP_SECURITY_LABEL;
>  err:
>  	return error;
>  }
>  EXPORT_SYMBOL_GPL(nfs_set_sb_security);
>  
> -int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
> -			  struct nfs_mount_info *mount_info)
> +int nfs_clone_sb_security(struct super_block *sb, struct nfs_fs_context *ctx)
>  {
>  	/* clone any lsm security options from the parent to the new sb */
> -	if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
> +	if (d_inode(ctx->fc.root)->i_op !=
> +	    NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops)
>  		return -ESTALE;
> -	return security_sb_clone_mnt_opts(mount_info->cloned->sb, s);
> +	return security_sb_clone_mnt_opts(ctx->clone_data.sb, sb);
>  }
>  EXPORT_SYMBOL_GPL(nfs_clone_sb_security);
>  
> -struct dentry *nfs_fs_mount_common(struct nfs_server *server,
> -				   int flags, const char *dev_name,
> -				   struct nfs_mount_info *mount_info,
> -				   struct nfs_subversion *nfs_mod)
> +int nfs_get_tree_common(struct nfs_server *server, struct nfs_fs_context *ctx)
>  {
>  	struct super_block *s;
>  	struct dentry *mntroot = ERR_PTR(-ENOMEM);
> -	int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
> -	struct nfs_sb_mountdata sb_mntdata = {
> -		.mntflags = flags,
> -		.server = server,
> -	};
> +	int (*compare_super)(struct super_block *, struct fs_context *) = nfs_compare_super;
>  	int error;
>  
>  	if (server->flags & NFS_MOUNT_UNSHARED)
> @@ -1287,16 +1202,19 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
>  
>  	/* -o noac implies -o sync */
>  	if (server->flags & NFS_MOUNT_NOAC)
> -		sb_mntdata.mntflags |= SB_SYNCHRONOUS;
> +		ctx->fc.sb_flags |= SB_SYNCHRONOUS;
>  
> -	if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
> -		if (mount_info->cloned->sb->s_flags & SB_SYNCHRONOUS)
> -			sb_mntdata.mntflags |= SB_SYNCHRONOUS;
> +	if (ctx->clone_data.cloned && ctx->clone_data.sb != NULL)
> +		if (ctx->clone_data.sb->s_flags & SB_SYNCHRONOUS)
> +			ctx->fc.sb_flags |= SB_SYNCHRONOUS;
>  
>  	/* Get a superblock - note that we may end up sharing one that already exists */
> -	s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);
> +	ctx->server = server;
> +	s = sget_fc(&ctx->fc, compare_super, nfs_set_super);
> +	ctx->server = NULL;
>  	if (IS_ERR(s)) {
> -		mntroot = ERR_CAST(s);
> +		error = PTR_ERR(s);
> +		errorf("NFS: Couldn't get superblock");
>  		goto out_err_nosb;
>  	}
>  
> @@ -1316,22 +1234,28 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
>  
>  	if (!s->s_root) {
>  		/* initial superblock/root creation */
> -		mount_info->fill_super(s, mount_info);
> -		nfs_get_cache_cookie(s, mount_info->ctx, mount_info->cloned);
> +		if (ctx->clone_data.sb)
> +			nfs_clone_super(s, ctx);
> +		else
> +			nfs_fill_super(s, ctx);
> +		nfs_get_cache_cookie(s, ctx);
>  	}
>  
> -	mntroot = nfs_get_root(s, mount_info->mntfh, dev_name);
> -	if (IS_ERR(mntroot))
> +	error = nfs_get_root(s, ctx);
> +	if (error < 0) {
> +		errorf("NFS: Couldn't get root dentry");
>  		goto error_splat_super;
> +	}
>  
> -	error = mount_info->set_security(s, mntroot, mount_info);
> +	error = ctx->set_security(s, ctx);
>  	if (error)
>  		goto error_splat_root;
>  
>  	s->s_flags |= SB_ACTIVE;
> +	error = 0;
>  
>  out:
> -	return mntroot;
> +	return error;
>  
>  out_err_nosb:
>  	nfs_free_server(server);
> @@ -1339,53 +1263,11 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
>  
>  error_splat_root:
>  	dput(mntroot);
> -	mntroot = ERR_PTR(error);
>  error_splat_super:
>  	deactivate_locked_super(s);
>  	goto out;
>  }
> -EXPORT_SYMBOL_GPL(nfs_fs_mount_common);
> -
> -struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
> -	int flags, const char *dev_name, void *raw_data)
> -{
> -	struct nfs_mount_info mount_info = {
> -		.fill_super = nfs_fill_super,
> -		.set_security = nfs_set_sb_security,
> -	};
> -	struct dentry *mntroot = ERR_PTR(-ENOMEM);
> -	struct nfs_subversion *nfs_mod;
> -	int error;
> -
> -	mount_info.ctx = nfs_alloc_parsed_mount_data();
> -	mount_info.mntfh = nfs_alloc_fhandle();
> -	if (mount_info.ctx == NULL || mount_info.mntfh == NULL)
> -		goto out;
> -
> -	/* Validate the mount data */
> -	error = nfs_validate_mount_data(fs_type, raw_data, mount_info.ctx, mount_info.mntfh, dev_name);
> -	if (error == NFS_TEXT_DATA)
> -		error = nfs_validate_text_mount_data(raw_data, mount_info.ctx, dev_name);
> -	if (error < 0) {
> -		mntroot = ERR_PTR(error);
> -		goto out;
> -	}
> -
> -	nfs_mod = get_nfs_version(mount_info.ctx->version);
> -	if (IS_ERR(nfs_mod)) {
> -		mntroot = ERR_CAST(nfs_mod);
> -		goto out;
> -	}
> -
> -	mntroot = nfs_mod->rpc_ops->try_mount(flags, dev_name, &mount_info, nfs_mod);
> -
> -	put_nfs_version(nfs_mod);
> -out:
> -	nfs_free_parsed_mount_data(mount_info.ctx);
> -	nfs_free_fhandle(mount_info.mntfh);
> -	return mntroot;
> -}
> -EXPORT_SYMBOL_GPL(nfs_fs_mount);
> +EXPORT_SYMBOL_GPL(nfs_get_tree_common);
>  
>  /*
>   * Destroy an NFS2/3 superblock
> @@ -1404,41 +1286,6 @@ void nfs_kill_super(struct super_block *s)
>  }
>  EXPORT_SYMBOL_GPL(nfs_kill_super);
>  
> -/*
> - * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
> - */
> -static struct dentry *
> -nfs_xdev_mount(struct file_system_type *fs_type, int flags,
> -		const char *dev_name, void *raw_data)
> -{
> -	struct nfs_clone_mount *data = raw_data;
> -	struct nfs_mount_info mount_info = {
> -		.fill_super = nfs_clone_super,
> -		.set_security = nfs_clone_sb_security,
> -		.cloned = data,
> -	};
> -	struct nfs_server *server;
> -	struct dentry *mntroot = ERR_PTR(-ENOMEM);
> -	struct nfs_subversion *nfs_mod = NFS_SB(data->sb)->nfs_client->cl_nfs_mod;
> -
> -	dprintk("--> nfs_xdev_mount()\n");
> -
> -	mount_info.mntfh = mount_info.cloned->fh;
> -
> -	/* create a new volume representation */
> -	server = nfs_mod->rpc_ops->clone_server(NFS_SB(data->sb), data->fh, data->fattr, data->authflavor);
> -
> -	if (IS_ERR(server))
> -		mntroot = ERR_CAST(server);
> -	else
> -		mntroot = nfs_fs_mount_common(server, flags,
> -				dev_name, &mount_info, nfs_mod);
> -
> -	dprintk("<-- nfs_xdev_mount() = %ld\n",
> -			IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
> -	return mntroot;
> -}
> -
>  #if IS_ENABLED(CONFIG_NFS_V4)
>  
>  /*
> diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
> index b28c83475ee8..71697103a887 100644
> --- a/include/linux/nfs_xdr.h
> +++ b/include/linux/nfs_xdr.h
> @@ -1542,6 +1542,7 @@ struct nfs_subversion;
>  struct nfs_mount_info;
>  struct nfs_client_initdata;
>  struct nfs_pageio_descriptor;
> +struct nfs_fs_context;
>  
>  /*
>   * RPC procedure vector for NFSv2/NFSv3 demuxing
> @@ -1556,10 +1557,10 @@ struct nfs_rpc_ops {
>  
>  	int	(*getroot) (struct nfs_server *, struct nfs_fh *,
>  			    struct nfs_fsinfo *);
> +	int	(*get_tree)(struct nfs_fs_context *);
>  	struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
>  				      struct nfs_fh *, struct nfs_fattr *);
> -	struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
> -				     struct nfs_subversion *);
> +	int	(*try_get_tree) (struct nfs_fs_context *);
>  	int	(*getattr) (struct nfs_server *, struct nfs_fh *,
>  			    struct nfs_fattr *, struct nfs4_label *);
>  	int	(*setattr) (struct dentry *, struct nfs_fattr *,
> @@ -1620,7 +1621,7 @@ struct nfs_rpc_ops {
>  	struct nfs_client *(*init_client) (struct nfs_client *,
>  				const struct nfs_client_initdata *);
>  	void	(*free_client) (struct nfs_client *);
> -	struct nfs_server *(*create_server)(struct nfs_mount_info *, struct nfs_subversion *);
> +	struct nfs_server *(*create_server)(struct nfs_fs_context *);
>  	struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
>  					   struct nfs_fattr *, rpc_authflavor_t);
>  };
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>