lkml.org 
[lkml]   [2019]   [Nov]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH v5 26/27] NFS: Additional refactoring for fs_context conversion
Date
Split out from commit "NFS: Add fs_context support."

This patch adds additional refactoring for the conversion of NFS to use
fs_context, namely:

(*) Merge nfs_mount_info and nfs_clone_mount into nfs_fs_context.
nfs_clone_mount has had several fields removed, and nfs_mount_info
has been removed altogether.
(*) Various functions now take an fs_context as an argument instead
of nfs_mount_info, nfs_fs_context, etc.

Signed-off-by: Scott Mayhew <smayhew@redhat.com>
---
fs/nfs/client.c | 22 +++---
fs/nfs/fs_context.c | 155 +++++++++++++++-------------------------
fs/nfs/fscache.c | 2 +-
fs/nfs/getroot.c | 70 +++++++++---------
fs/nfs/internal.h | 53 +++++---------
fs/nfs/namespace.c | 14 ++--
fs/nfs/nfs3_fs.h | 2 +-
fs/nfs/nfs3client.c | 5 +-
fs/nfs/nfs4client.c | 62 ++++++++--------
fs/nfs/nfs4namespace.c | 24 +++----
fs/nfs/nfs4super.c | 19 +++--
fs/nfs/super.c | 48 ++++++-------
include/linux/nfs_xdr.h | 2 +-
13 files changed, 204 insertions(+), 274 deletions(-)

diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 511d1d629786..a26e7d1d74bc 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -648,17 +648,17 @@ 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 *ctx,
- struct nfs_subversion *nfs_mod)
+ const struct fs_context *fc)
{
+ const struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct rpc_timeout timeparms;
struct nfs_client_initdata cl_init = {
.hostname = ctx->nfs_server.hostname,
.addr = (const struct sockaddr *)&ctx->nfs_server.address,
.addrlen = ctx->nfs_server.addrlen,
- .nfs_mod = nfs_mod,
+ .nfs_mod = ctx->nfs_mod,
.proto = ctx->nfs_server.protocol,
- .net = ctx->net,
+ .net = fc->net_ns,
.timeparms = &timeparms,
.cred = server->cred,
.nconnect = ctx->nfs_server.nconnect,
@@ -940,10 +940,10 @@ 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_server *nfs_create_server(struct fs_context *fc)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct nfs_server *server;
- struct nfs_subversion *nfs_mod = mount_info->nfs_mod;
struct nfs_fattr *fattr;
int error;

@@ -959,18 +959,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, fc);
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)
@@ -978,8 +978,8 @@ 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, NULL);
+ error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,
+ fattr, NULL, 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 ac1a8d7d7393..e472334b978d 100644
--- a/fs/nfs/fs_context.c
+++ b/fs/nfs/fs_context.c
@@ -241,43 +241,6 @@ static const struct constant_table nfs_secflavor_tokens[] = {
{ "sys", Opt_sec_sys },
};

-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;
- ctx->lsm_opts = NULL;
- }
- 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);
- }
-}
-
/*
* Sanity-check a server address provided by the mount command.
*
@@ -342,7 +305,7 @@ static void nfs_set_mount_transport_protocol(struct nfs_fs_context *ctx)
* Add 'flavor' to 'auth_info' if not already present.
* Returns true if 'flavor' ends up in the list, false otherwise
*/
-static int nfs_auth_info_add(struct nfs_fs_context *ctx,
+static int nfs_auth_info_add(struct fs_context *fc,
struct nfs_auth_info *auth_info,
rpc_authflavor_t flavor)
{
@@ -367,9 +330,10 @@ static int nfs_auth_info_add(struct nfs_fs_context *ctx,
/*
* Parse the value of the 'sec=' option.
*/
-static int nfs_parse_security_flavors(struct nfs_fs_context *ctx,
+static int nfs_parse_security_flavors(struct fs_context *fc,
struct fs_parameter *param)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
rpc_authflavor_t pseudoflavor;
char *string = param->string, *p;
int ret;
@@ -419,7 +383,7 @@ static int nfs_parse_security_flavors(struct nfs_fs_context *ctx,
return -EINVAL;
}

- ret = nfs_auth_info_add(ctx, &ctx->auth_info, pseudoflavor);
+ ret = nfs_auth_info_add(fc, &ctx->auth_info, pseudoflavor);
if (ret < 0)
return ret;
}
@@ -427,9 +391,11 @@ static int nfs_parse_security_flavors(struct nfs_fs_context *ctx,
return 0;
}

-static int nfs_parse_version_string(struct nfs_fs_context *ctx,
+static int nfs_parse_version_string(struct fs_context *fc,
const char *string)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
+
ctx->flags &= ~NFS_MOUNT_VER3;
switch (lookup_constant(nfs_vers_tokens, string, -1)) {
case Opt_vers_2:
@@ -656,17 +622,17 @@ static int nfs_fs_context_parse_param(struct fs_context *fc,
* options that take text values
*/
case Opt_v:
- ret = nfs_parse_version_string(ctx, param->key + 1);
+ ret = nfs_parse_version_string(fc, param->key + 1);
if (ret < 0)
return ret;
break;
case Opt_vers:
- ret = nfs_parse_version_string(ctx, param->string);
+ ret = nfs_parse_version_string(fc, param->string);
if (ret < 0)
return ret;
break;
case Opt_sec:
- ret = nfs_parse_security_flavors(ctx, param);
+ ret = nfs_parse_security_flavors(fc, param);
if (ret < 0)
return ret;
break;
@@ -729,7 +695,7 @@ static int nfs_fs_context_parse_param(struct fs_context *fc,
break;

case Opt_addr:
- len = rpc_pton(ctx->net, param->string, param->size,
+ len = rpc_pton(fc->net_ns, param->string, param->size,
&ctx->nfs_server.address,
sizeof(ctx->nfs_server._address));
if (len == 0)
@@ -747,7 +713,7 @@ static int nfs_fs_context_parse_param(struct fs_context *fc,
param->string = NULL;
break;
case Opt_mountaddr:
- len = rpc_pton(ctx->net, param->string, param->size,
+ len = rpc_pton(fc->net_ns, param->string, param->size,
&ctx->mount_server.address,
sizeof(ctx->mount_server._address));
if (len == 0)
@@ -819,7 +785,7 @@ static int nfs_fs_context_parse_param(struct fs_context *fc,
}

/*
- * Split "dev_name" into "hostname:export_path".
+ * Split fc->source 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
@@ -827,12 +793,13 @@ static int nfs_fs_context_parse_param(struct fs_context *fc,
*
* 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)
+static int nfs_parse_source(struct fs_context *fc,
+ size_t maxnamlen, size_t maxpathlen)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
+ const char *dev_name = fc->source;
size_t len;
- char *end;
+ const char *end;

if (unlikely(!dev_name || !*dev_name)) {
dfprintk(MOUNT, "NFS: device name not specified\n");
@@ -848,7 +815,7 @@ static int nfs_parse_devname(struct nfs_fs_context *ctx,
len = end - dev_name;
end++;
} else {
- char *comma;
+ const char *comma;

end = strchr(dev_name, ':');
if (end == NULL)
@@ -856,8 +823,8 @@ static int nfs_parse_devname(struct nfs_fs_context *ctx,
len = end - dev_name;

/* kill possible hostname list: not supported */
- comma = strchr(dev_name, ',');
- if (comma != NULL && comma < end)
+ comma = memchr(dev_name, ',', len);
+ if (comma)
len = comma - dev_name;
}

@@ -920,7 +887,7 @@ static int nfs23_parse_monolithic(struct fs_context *fc,
struct nfs_mount_data *data)
{
struct nfs_fs_context *ctx = nfs_fc2context(fc);
- struct nfs_fh *mntfh = ctx->mount_info.mntfh;
+ struct nfs_fh *mntfh = ctx->mntfh;
struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;

@@ -1009,6 +976,7 @@ static int nfs23_parse_monolithic(struct fs_context *fc,
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
@@ -1073,12 +1041,6 @@ static int nfs23_parse_monolithic(struct fs_context *fc,
}

#if IS_ENABLED(CONFIG_NFS_V4)
-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);
-}
-
/*
* Validate NFSv4 mount options
*/
@@ -1251,20 +1213,22 @@ static int nfs_fs_context_validate(struct fs_context *fc)
goto out_no_address;

if (ctx->version == 4) {
-#if IS_ENABLED(CONFIG_NFS_V4)
- if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
- port = NFS_RDMA_PORT;
- else
- port = NFS_PORT;
- max_namelen = NFS4_MAXNAMLEN;
- max_pathlen = NFS4_MAXPATHLEN;
- nfs_validate_transport_protocol(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 */
+ if (IS_ENABLED(CONFIG_NFS_V4)) {
+ if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
+ port = NFS_RDMA_PORT;
+ else
+ port = NFS_PORT;
+ max_namelen = NFS4_MAXNAMLEN;
+ max_pathlen = NFS4_MAXPATHLEN;
+ nfs_validate_transport_protocol(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);
if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
@@ -1273,33 +1237,30 @@ static int nfs_fs_context_validate(struct fs_context *fc)

nfs_set_port(sap, &ctx->nfs_server.port, port);

- ret = nfs_parse_devname(ctx, fc->source, max_namelen, max_pathlen);
+ ret = nfs_parse_source(fc, max_namelen, max_pathlen);
if (ret < 0)
return ret;

/* Load the NFS protocol module if we haven't done so yet */
- if (!ctx->mount_info.nfs_mod) {
+ 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->mount_info.nfs_mod = nfs_mod;
+ ctx->nfs_mod = nfs_mod;
}
return 0;

out_no_device_name:
dfprintk(MOUNT, "NFS: Device name not specified\n");
return -EINVAL;
-#if !IS_ENABLED(CONFIG_NFS_V4)
out_v4_not_compiled:
dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
return -EPROTONOSUPPORT;
-#else
out_invalid_transport_udp:
dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
return -EINVAL;
-#endif /* !CONFIG_NFS_V4 */
out_no_address:
dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
return -EINVAL;
@@ -1332,7 +1293,7 @@ static int nfs_get_tree(struct fs_context *fc)
if (err)
return err;
if (!ctx->internal)
- return ctx->mount_info.nfs_mod->rpc_ops->try_get_tree(fc);
+ return ctx->nfs_mod->rpc_ops->try_get_tree(fc);
else
return nfs_get_tree_common(fc);
}
@@ -1351,20 +1312,19 @@ static int nfs_fs_context_dup(struct fs_context *fc, struct fs_context *src_fc)
if (!ctx)
return -ENOMEM;

- ctx->mount_info.mntfh = nfs_alloc_fhandle();
- if (!ctx->mount_info.mntfh) {
+ ctx->mntfh = nfs_alloc_fhandle();
+ if (!ctx->mntfh) {
kfree(ctx);
return -ENOMEM;
}
- nfs_copy_fh(ctx->mount_info.mntfh, src->mount_info.mntfh);
+ nfs_copy_fh(ctx->mntfh, src->mntfh);

- __module_get(ctx->mount_info.nfs_mod->owner);
+ __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->clone_data.addr = NULL;
ctx->clone_data.fattr = NULL;
fc->fs_private = ctx;
return 0;
@@ -1375,17 +1335,16 @@ static void nfs_fs_context_free(struct fs_context *fc)
struct nfs_fs_context *ctx = nfs_fc2context(fc);

if (ctx) {
- if (ctx->mount_info.server)
- nfs_free_server(ctx->mount_info.server);
- if (ctx->mount_info.nfs_mod)
- put_nfs_version(ctx->mount_info.nfs_mod);
+ if (ctx->server)
+ nfs_free_server(ctx->server);
+ if (ctx->nfs_mod)
+ put_nfs_version(ctx->nfs_mod);
kfree(ctx->client_address);
kfree(ctx->mount_server.hostname);
kfree(ctx->nfs_server.export_path);
kfree(ctx->nfs_server.hostname);
kfree(ctx->fscache_uniq);
- nfs_free_fhandle(ctx->mount_info.mntfh);
- kfree(ctx->clone_data.addr);
+ nfs_free_fhandle(ctx->mntfh);
nfs_free_fattr(ctx->clone_data.fattr);
kfree(ctx);
}
@@ -1413,9 +1372,8 @@ static int nfs_init_fs_context(struct fs_context *fc)
if (unlikely(!ctx))
return -ENOMEM;

- ctx->mount_info.ctx = ctx;
- ctx->mount_info.mntfh = nfs_alloc_fhandle();
- if (unlikely(!ctx->mount_info.mntfh)) {
+ ctx->mntfh = nfs_alloc_fhandle();
+ if (unlikely(!ctx->mntfh)) {
kfree(ctx);
return -ENOMEM;
}
@@ -1452,8 +1410,8 @@ static int nfs_init_fs_context(struct fs_context *fc)
fc->net_ns = get_net(net);
}

- ctx->mount_info.nfs_mod = nfss->nfs_client->cl_nfs_mod;
- __module_get(ctx->mount_info.nfs_mod->owner);
+ ctx->nfs_mod = nfss->nfs_client->cl_nfs_mod;
+ __module_get(ctx->nfs_mod->owner);
} else {
/* defaults */
ctx->timeo = NFS_UNSPEC_TIMEO;
@@ -1468,7 +1426,6 @@ static int nfs_init_fs_context(struct fs_context *fc)
ctx->minorversion = 0;
ctx->need_mount = true;
}
- ctx->net = fc->net_ns;
fc->fs_private = ctx;
fc->ops = &nfs_fs_context_ops;
return 0;
diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index 3800ab6f08fa..4a8df8c30a03 100644
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -128,7 +128,7 @@ void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int
return;

key->nfs_client = nfss->nfs_client;
- key->key.super.s_flags = sb->s_flags & NFS_MS_MASK;
+ key->key.super.s_flags = sb->s_flags & NFS_SB_MASK;
key->key.nfs_server.flags = nfss->flags;
key->key.nfs_server.rsize = nfss->rsize;
key->key.nfs_server.wsize = nfss->wsize;
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 878c4c5982d9..ab45496d23a6 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -64,66 +64,68 @@ 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 fs_context *fc)
{
- struct nfs_server *server = NFS_SB(sb);
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
+ 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(fc->source, 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;
+ 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);
+ 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);
+ 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);
+ 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 ccbff3a9ccf6..007d058baad1 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -11,7 +11,7 @@
#include <linux/nfs_page.h>
#include <linux/wait_bit.h>

-#define NFS_MS_MASK (SB_RDONLY|SB_NOSUID|SB_NODEV|SB_NOEXEC|SB_SYNCHRONOUS)
+#define NFS_SB_MASK (SB_RDONLY|SB_NOSUID|SB_NODEV|SB_NOEXEC|SB_SYNCHRONOUS)

extern const struct export_operations nfs_export_ops;

@@ -33,17 +33,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;
- struct dentry *dentry;
- char *hostname;
- char *mnt_path;
- struct sockaddr *addr;
- size_t addrlen;
- rpc_authflavor_t authflavor;
- struct nfs_fattr *fattr;
-};
-
/*
* Note: RFC 1813 doesn't limit the number of auth flavors that
* a server can return, so make something up.
@@ -80,15 +69,6 @@ struct nfs_client_initdata {
const struct cred *cred;
};

-struct nfs_mount_info {
- unsigned int inherited_bsize;
- struct nfs_fs_context *ctx;
- struct nfs_clone_mount *cloned;
- struct nfs_server *server;
- struct nfs_fh *mntfh;
- struct nfs_subversion *nfs_mod;
-};
-
/*
* In-kernel mount arguments
*/
@@ -140,13 +120,17 @@ struct nfs_fs_context {
unsigned short export_path_len;
} nfs_server;

- void *lsm_opts;
- struct net *net;
-
- char buf[32]; /* Parse buffer */
-
- struct nfs_mount_info mount_info;
- struct nfs_clone_mount clone_data;
+ struct nfs_fh *mntfh;
+ struct nfs_server *server;
+ struct nfs_subversion *nfs_mod;
+
+ /* Information for a cloned mount. */
+ struct nfs_clone_mount {
+ struct super_block *sb;
+ struct dentry *dentry;
+ struct nfs_fattr *fattr;
+ unsigned int inherited_bsize;
+ } clone_data;
};

static inline struct nfs_fs_context *nfs_fc2context(const struct fs_context *fc)
@@ -194,10 +178,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 *);
-extern struct nfs_server *nfs4_create_server(struct nfs_mount_info *);
-extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
- struct nfs_fh *);
+extern struct nfs_server *nfs_create_server(struct fs_context *);
+extern struct nfs_server *nfs4_create_server(struct fs_context *);
+extern struct nfs_server *nfs4_create_referral_server(struct fs_context *);
extern int nfs4_update_server(struct nfs_server *server, const char *hostname,
struct sockaddr *sap, size_t salen,
struct net *net);
@@ -444,12 +427,8 @@ int nfs_submount(struct fs_context *, struct nfs_server *);
int nfs_do_submount(struct fs_context *);

/* 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 fs_context *fc);
#if IS_ENABLED(CONFIG_NFS_V4)
-extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *,
- const char *);
-
extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);
#endif

diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index 927b0f732148..3e566a632215 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -176,8 +176,8 @@ struct vfsmount *nfs_d_automount(struct path *path)

ctx->version = client->rpc_ops->version;
ctx->minorversion = client->cl_minorversion;
- ctx->mount_info.nfs_mod = client->cl_nfs_mod;
- __module_get(ctx->mount_info.nfs_mod->owner);
+ ctx->nfs_mod = client->cl_nfs_mod;
+ __module_get(ctx->nfs_mod->owner);

ret = client->rpc_ops->submount(fc, server);
if (ret < 0) {
@@ -259,22 +259,22 @@ int nfs_do_submount(struct fs_context *fc)
int ret;

/* create a new volume representation */
- server = ctx->mount_info.nfs_mod->rpc_ops->clone_server(NFS_SB(ctx->clone_data.sb),
- ctx->mount_info.mntfh,
+ 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))
return PTR_ERR(server);

- ctx->mount_info.server = server;
+ ctx->server = server;

buffer = kmalloc(4096, GFP_USER);
if (!buffer)
return -ENOMEM;

ctx->internal = true;
- ctx->mount_info.inherited_bsize = ctx->clone_data.sb->s_blocksize_bits;
+ ctx->clone_data.inherited_bsize = ctx->clone_data.sb->s_blocksize_bits;

p = nfs_devname(dentry, buffer, 4096);
if (IS_ERR(p)) {
@@ -299,7 +299,7 @@ int nfs_submount(struct fs_context *fc, struct nfs_server *server)

/* Look it up again to get its attributes */
err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name,
- ctx->mount_info.mntfh, ctx->clone_data.fattr,
+ ctx->mntfh, ctx->clone_data.fattr,
NULL);
dput(parent);
if (err != 0)
diff --git a/fs/nfs/nfs3_fs.h b/fs/nfs/nfs3_fs.h
index 09602dc1889f..1b950b66b3bb 100644
--- a/fs/nfs/nfs3_fs.h
+++ b/fs/nfs/nfs3_fs.h
@@ -27,7 +27,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_server *nfs3_create_server(struct 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 a340b5d0e1a3..bfd9b5f03455 100644
--- a/fs/nfs/nfs3client.c
+++ b/fs/nfs/nfs3client.c
@@ -46,9 +46,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_server *nfs3_create_server(struct fs_context *fc)
{
- struct nfs_server *server = nfs_create_server(mount_info);
+ struct nfs_server *server = nfs_create_server(fc);
+
/* 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/nfs4client.c b/fs/nfs/nfs4client.c
index 2ee2281ce404..be26fbe06863 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -1052,9 +1052,9 @@ static int nfs4_server_common_setup(struct nfs_server *server,
/*
* Create a version 4 volume record
*/
-static int nfs4_init_server(struct nfs_server *server,
- struct nfs_fs_context *ctx)
+static int nfs4_init_server(struct nfs_server *server, struct fs_context *fc)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct rpc_timeout timeparms;
int error;

@@ -1076,15 +1076,15 @@ 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->nfs_server.nconnect,
- 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->nfs_server.nconnect,
+ fc->net_ns);
if (error < 0)
return error;

@@ -1107,10 +1107,9 @@ 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_server *nfs4_create_server(struct fs_context *fc)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct nfs_server *server;
bool auth_probe;
int error;
@@ -1121,14 +1120,14 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info)

server->cred = get_cred(current_cred());

- 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, fc);
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;

@@ -1142,9 +1141,9 @@ 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 fs_context *fc)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct nfs_client *parent_client;
struct nfs_server *server, *parent_server;
bool auth_probe;
@@ -1154,7 +1153,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;

server->cred = get_cred(parent_server->cred);
@@ -1164,10 +1163,11 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,

/* Get a client representation */
#if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
- rpc_set_port(data->addr, NFS_RDMA_PORT);
- error = nfs4_set_client(server, data->hostname,
- data->addr,
- data->addrlen,
+ rpc_set_port(&ctx->nfs_server.address, NFS_RDMA_PORT);
+ error = nfs4_set_client(server,
+ ctx->nfs_server.hostname,
+ &ctx->nfs_server.address,
+ ctx->nfs_server.addrlen,
parent_client->cl_ipaddr,
XPRT_TRANSPORT_RDMA,
parent_server->client->cl_timeout,
@@ -1178,10 +1178,11 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
goto init_server;
#endif /* IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) */

- rpc_set_port(data->addr, NFS_PORT);
- error = nfs4_set_client(server, data->hostname,
- data->addr,
- data->addrlen,
+ rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
+ error = nfs4_set_client(server,
+ ctx->nfs_server.hostname,
+ &ctx->nfs_server.address,
+ ctx->nfs_server.addrlen,
parent_client->cl_ipaddr,
XPRT_TRANSPORT_TCP,
parent_server->client->cl_timeout,
@@ -1194,13 +1195,14 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
#if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
init_server:
#endif
- 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 04985aebe184..db94e9422501 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -130,9 +130,10 @@ static int nfs4_validate_fspath(struct dentry *dentry,
const struct nfs4_fs_locations *locations,
struct nfs_fs_context *ctx)
{
- const char *path, *fs_path;
- char *buf;
+ const char *path;
+ char *fs_path;
unsigned short len;
+ char *buf;
int n;

buf = kmalloc(4096, GFP_KERNEL);
@@ -143,7 +144,6 @@ static int nfs4_validate_fspath(struct dentry *dentry,
}

fs_path = nfs4_pathname_string(&locations->fs_path, &len);
-
n = strncmp(path, fs_path, len);
kfree(buf);
kfree(fs_path);
@@ -274,7 +274,6 @@ nfs4_negotiate_security(struct rpc_clnt *clnt, struct inode *inode,
static int try_location(struct fs_context *fc,
const struct nfs4_fs_location *location)
{
- const size_t addr_bufsize = sizeof(struct sockaddr_storage);
struct nfs_fs_context *ctx = nfs_fc2context(fc);
unsigned int len, s;
char *export_path, *source, *p;
@@ -310,29 +309,24 @@ static int try_location(struct fs_context *fc,

kfree(fc->source);
fc->source = source;
-
- ctx->clone_data.addr = kmalloc(addr_bufsize, GFP_KERNEL);
- if (ctx->clone_data.addr == NULL)
- return -ENOMEM;
for (s = 0; s < location->nservers; s++) {
const struct nfs4_string *buf = &location->servers[s];

if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
continue;

- ctx->clone_data.addrlen =
+ ctx->nfs_server.addrlen =
nfs_parse_server_name(buf->data, buf->len,
- ctx->clone_data.addr,
- addr_bufsize,
+ &ctx->nfs_server.address,
+ sizeof(ctx->nfs_server._address),
fc->net_ns);
- if (ctx->clone_data.addrlen == 0)
+ if (ctx->nfs_server.addrlen == 0)
continue;

- rpc_set_port(ctx->clone_data.addr, NFS_PORT);
+ rpc_set_port(&ctx->nfs_server.address, NFS_PORT);

memcpy(ctx->nfs_server.hostname, buf->data, buf->len);
ctx->nfs_server.hostname[buf->len] = '\0';
- ctx->clone_data.hostname = ctx->nfs_server.hostname;

p = source;
memcpy(p, buf->data, buf->len);
@@ -445,7 +439,7 @@ int nfs4_submount(struct fs_context *fc, struct nfs_server *server)
int ret;

/* Look it up again to get its attributes and sec flavor */
- client = nfs4_proc_lookup_mountpoint(dir, name, ctx->mount_info.mntfh,
+ client = nfs4_proc_lookup_mountpoint(dir, name, ctx->mntfh,
ctx->clone_data.fattr);
dput(parent);
if (IS_ERR(client))
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 96edee546b8a..3b27c5e3d781 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -35,12 +35,12 @@ static const struct super_operations nfs4_sops = {
};

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)
@@ -168,7 +168,7 @@ static int do_nfs4_mount(struct nfs_server *server,

root_ctx = nfs_fc2context(root_fc);
root_ctx->internal = true;
- root_ctx->mount_info.server = server;
+ root_ctx->server = server;
/* We leave export_path unset as it's not used to find the root. */

len = strlen(hostname) + 5;
@@ -221,7 +221,7 @@ int nfs4_try_get_tree(struct fs_context *fc)
/* We create a mount for the server's root, walk to the requested
* location and then create another mount for that.
*/
- err= do_nfs4_mount(nfs4_create_server(&ctx->mount_info),
+ err= do_nfs4_mount(nfs4_create_server(fc),
fc, ctx->nfs_server.hostname,
ctx->nfs_server.export_path);
if (err) {
@@ -243,7 +243,7 @@ int nfs4_get_referral_tree(struct fs_context *fc)
dprintk("--> nfs4_referral_mount()\n");

/* create a new volume representation */
- err = do_nfs4_mount(nfs4_create_referral_server(&ctx->clone_data, ctx->mount_info.mntfh),
+ err = do_nfs4_mount(nfs4_create_referral_server(fc),
fc, ctx->nfs_server.hostname,
ctx->nfs_server.export_path);
if (err) {
@@ -254,7 +254,6 @@ int nfs4_get_referral_tree(struct fs_context *fc)
return err;
}

-
static int __init init_nfs_v4(void)
{
int err;
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 6ff99da978a8..ed0290d5ebf3 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -745,11 +745,12 @@ static int nfs_verify_authflavors(struct nfs_fs_context *ctx,
* 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 *ctx,
+static int nfs_request_mount(struct fs_context *fc,
struct nfs_fh *root_fh,
rpc_authflavor_t *server_authlist,
unsigned int *server_authlist_len)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct nfs_mount_request request = {
.sap = (struct sockaddr *)
&ctx->mount_server.address,
@@ -759,7 +760,7 @@ static int nfs_request_mount(struct nfs_fs_context *ctx,
.noresvport = ctx->flags & NFS_MOUNT_NORESVPORT,
.auth_flav_len = server_authlist_len,
.auth_flavs = server_authlist,
- .net = ctx->net,
+ .net = fc->net_ns,
};
int status;

@@ -804,20 +805,18 @@ static int nfs_request_mount(struct nfs_fs_context *ctx,
return 0;
}

-static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info)
+static struct nfs_server *nfs_try_mount_request(struct fs_context *fc)
{
+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
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);
- struct nfs_subversion *nfs_mod = mount_info->nfs_mod;

- status = nfs_request_mount(ctx, mount_info->mntfh, authlist,
- &authlist_len);
+ status = nfs_request_mount(fc, ctx->mntfh, authlist, &authlist_len);
if (status)
return ERR_PTR(status);

@@ -831,7 +830,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);
+ return ctx->nfs_mod->rpc_ops->create_server(fc);
}

/*
@@ -858,7 +857,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);
+ server = ctx->nfs_mod->rpc_ops->create_server(fc);
if (!IS_ERR(server))
return server;
}
@@ -874,7 +873,7 @@ 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);
+ return ctx->nfs_mod->rpc_ops->create_server(fc);
}

int nfs_try_get_tree(struct fs_context *fc)
@@ -882,9 +881,9 @@ int nfs_try_get_tree(struct fs_context *fc)
struct nfs_fs_context *ctx = nfs_fc2context(fc);

if (ctx->need_mount)
- ctx->mount_info.server = nfs_try_mount_request(&ctx->mount_info);
+ ctx->server = nfs_try_mount_request(fc);
else
- ctx->mount_info.server = ctx->mount_info.nfs_mod->rpc_ops->create_server(&ctx->mount_info);
+ ctx->server = ctx->nfs_mod->rpc_ops->create_server(fc);

return nfs_get_tree_common(fc);
}
@@ -966,9 +965,8 @@ EXPORT_SYMBOL_GPL(nfs_reconfigure);
/*
* Finish setting up an NFS superblock
*/
-static 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;
@@ -1009,13 +1007,14 @@ static void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_
nfs_super_set_maxbytes(sb, server->maxfilesize);
}

-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 fs_context *fc)
{
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_MS_MASK) != (flags & NFS_MS_MASK))
+ if ((s->s_flags & NFS_SB_MASK) != (fc->sb_flags & NFS_SB_MASK))
goto Ebusy;
if (a->nfs_client != b->nfs_client)
goto Ebusy;
@@ -1122,7 +1121,7 @@ static int nfs_compare_super(struct super_block *sb, struct fs_context *fc)
return 0;
if (!nfs_compare_userns(old, server))
return 0;
- return nfs_compare_mount_options(sb, server, fc->sb_flags);
+ return nfs_compare_mount_options(sb, server, fc);
}

#ifdef CONFIG_NFS_FSCACHE
@@ -1177,13 +1176,12 @@ int nfs_get_tree_common(struct fs_context *fc)
{
struct nfs_fs_context *ctx = nfs_fc2context(fc);
struct super_block *s;
- struct dentry *mntroot = ERR_PTR(-ENOMEM);
int (*compare_super)(struct super_block *, struct fs_context *) = nfs_compare_super;
- struct nfs_server *server = ctx->mount_info.server;
+ struct nfs_server *server = ctx->server;
unsigned long kflags = 0, kflags_out = 0;
int error;

- ctx->mount_info.server = NULL;
+ ctx->server = NULL;
if (IS_ERR(server))
return PTR_ERR(server);

@@ -1224,9 +1222,9 @@ int nfs_get_tree_common(struct fs_context *fc)
}

if (!s->s_root) {
- unsigned bsize = ctx->mount_info.inherited_bsize;
+ unsigned bsize = ctx->clone_data.inherited_bsize;
/* initial superblock/root creation */
- nfs_fill_super(s, &ctx->mount_info);
+ nfs_fill_super(s, ctx);
if (bsize) {
s->s_blocksize_bits = bsize;
s->s_blocksize = 1U << bsize;
@@ -1234,13 +1232,11 @@ int nfs_get_tree_common(struct fs_context *fc)
nfs_get_cache_cookie(s, ctx);
}

- mntroot = nfs_get_root(s, ctx->mount_info.mntfh, fc->source);
- if (IS_ERR(mntroot)) {
- error = PTR_ERR(mntroot);
+ error = nfs_get_root(s, fc);
+ if (error < 0) {
dfprintk(MOUNT, "NFS: Couldn't get root dentry\n");
goto error_splat_super;
}
- fc->root = mntroot;

if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
kflags |= SECURITY_LSM_NATIVE_LABELS;
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 3de843888bc0..ed9f215d03ea 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -1705,7 +1705,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_server *(*create_server)(struct fs_context *);
struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
struct nfs_fattr *, rpc_authflavor_t);
};
--
2.17.2
\
 
 \ /
  Last update: 2019-11-20 16:29    [W:0.125 / U:14.184 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site