redonkable/alistair23-linux
redonkable/alistair23-linux
1
0
Fork 0
Code Releases Activity

NFS: Rename struct nfs_parsed_mount_data to struct nfs_fs_context

Browse source 
Rename struct nfs_parsed_mount_data to struct nfs_fs_context and rename
pointers to it to "ctx".  At some point this will be pointed to by an
fs_context struct's fs_private pointer.

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>
This commit is contained in:
David Howells 2019-12-10 07:31:06 -05:00 committed by Anna Schumaker
parent e0a626b124
commit 5eb005caf5
6 changed files with 392 additions and 392 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
fs/nfs/client.c
View file

@ -658,28 +658,28 @@ EXPORT_SYMBOL_GPL(nfs_init_client);
* Create a version 2 or 3 client * Create a version 2 or 3 client
*/ */
static int nfs_init_server(struct nfs_server *server, static int nfs_init_server(struct nfs_server *server,
const struct nfs_parsed_mount_data *data, const struct nfs_fs_context *cfg,
struct nfs_subversion *nfs_mod) struct nfs_subversion *nfs_mod)
{ {
struct rpc_timeout timeparms; struct rpc_timeout timeparms;
struct nfs_client_initdata cl_init = { struct nfs_client_initdata cl_init = {
.hostname = data->nfs_server.hostname, .hostname = cfg->nfs_server.hostname,
.addr = (const struct sockaddr *)&data->nfs_server.address, .addr = (const struct sockaddr *)&cfg->nfs_server.address,
.addrlen = data->nfs_server.addrlen, .addrlen = cfg->nfs_server.addrlen,
.nfs_mod = nfs_mod, .nfs_mod = nfs_mod,
.proto = data->nfs_server.protocol, .proto = cfg->nfs_server.protocol,
.net = data->net, .net = cfg->net,
.timeparms = &timeparms, .timeparms = &timeparms,
.cred = server->cred, .cred = server->cred,
.nconnect = data->nfs_server.nconnect, .nconnect = cfg->nfs_server.nconnect,
.init_flags = (1UL << NFS_CS_REUSEPORT), .init_flags = (1UL << NFS_CS_REUSEPORT),
}; };
struct nfs_client *clp; struct nfs_client *clp;
int error; int error;
nfs_init_timeout_values(&timeparms, data->nfs_server.protocol, nfs_init_timeout_values(&timeparms, cfg->nfs_server.protocol,
data->timeo, data->retrans); cfg->timeo, cfg->retrans);
if (data->flags & NFS_MOUNT_NORESVPORT) if (cfg->flags & NFS_MOUNT_NORESVPORT)
set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags); set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
/* Allocate or find a client reference we can use */ /* Allocate or find a client reference we can use */
@ -690,46 +690,46 @@ static int nfs_init_server(struct nfs_server *server,
server->nfs_client = clp; server->nfs_client = clp;
/* Initialise the client representation from the mount data */ /* Initialise the client representation from the mount data */
server->flags = data->flags; server->flags = cfg->flags;
server->options = data->options; server->options = cfg->options;
server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID| 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_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME; NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
if (data->rsize) if (cfg->rsize)
server->rsize = nfs_block_size(data->rsize, NULL); server->rsize = nfs_block_size(cfg->rsize, NULL);
if (data->wsize) if (cfg->wsize)
server->wsize = nfs_block_size(data->wsize, NULL); server->wsize = nfs_block_size(cfg->wsize, NULL);
server->acregmin = data->acregmin * HZ; server->acregmin = cfg->acregmin * HZ;
server->acregmax = data->acregmax * HZ; server->acregmax = cfg->acregmax * HZ;
server->acdirmin = data->acdirmin * HZ; server->acdirmin = cfg->acdirmin * HZ;
server->acdirmax = data->acdirmax * HZ; server->acdirmax = cfg->acdirmax * HZ;
/* Start lockd here, before we might error out */ /* Start lockd here, before we might error out */
error = nfs_start_lockd(server); error = nfs_start_lockd(server);
if (error < 0) if (error < 0)
goto error; goto error;
server->port = data->nfs_server.port; server->port = cfg->nfs_server.port;
server->auth_info = data->auth_info; server->auth_info = cfg->auth_info;
error = nfs_init_server_rpcclient(server, &timeparms, error = nfs_init_server_rpcclient(server, &timeparms,
data->selected_flavor); cfg->selected_flavor);
if (error < 0) if (error < 0)
goto error; goto error;
/* Preserve the values of mount_server-related mount options */ /* Preserve the values of mount_server-related mount options */
if (data->mount_server.addrlen) { if (cfg->mount_server.addrlen) {
memcpy(&server->mountd_address, &data->mount_server.address, memcpy(&server->mountd_address, &cfg->mount_server.address,
data->mount_server.addrlen); cfg->mount_server.addrlen);
server->mountd_addrlen = data->mount_server.addrlen; server->mountd_addrlen = cfg->mount_server.addrlen;
} }
server->mountd_version = data->mount_server.version; server->mountd_version = cfg->mount_server.version;
server->mountd_port = data->mount_server.port; server->mountd_port = cfg->mount_server.port;
server->mountd_protocol = data->mount_server.protocol; server->mountd_protocol = cfg->mount_server.protocol;
server->namelen = data->namlen; server->namelen = cfg->namlen;
return 0; return 0;
error: error:
@ -970,7 +970,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info)
goto error; goto error;
/* Get a client representation */ /* Get a client representation */
error = nfs_init_server(server, mount_info->parsed, nfs_mod); error = nfs_init_server(server, mount_info->ctx, nfs_mod);
if (error < 0) if (error < 0)
goto error; goto error;
@ -981,7 +981,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info)
if (server->nfs_client->rpc_ops->version == 3) { if (server->nfs_client->rpc_ops->version == 3) {
if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN) if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
server->namelen = NFS3_MAXNAMLEN; server->namelen = NFS3_MAXNAMLEN;
if (!(mount_info->parsed->flags & NFS_MOUNT_NORDIRPLUS)) if (!(mount_info->ctx->flags & NFS_MOUNT_NORDIRPLUS))
server->caps |= NFS_CAP_READDIRPLUS; server->caps |= NFS_CAP_READDIRPLUS;
} else { } else {
if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN) if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)

444
fs/nfs/fs_context.c
View file

@ -242,40 +242,40 @@ static const match_table_t nfs_vers_tokens = {
{ Opt_vers_err, NULL } { Opt_vers_err, NULL }
}; };
struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void) struct nfs_fs_context *nfs_alloc_parsed_mount_data(void)
{ {
struct nfs_parsed_mount_data *data; struct nfs_fs_context *ctx;
data = kzalloc(sizeof(*data), GFP_KERNEL); ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (data) { if (ctx) {
data->timeo = NFS_UNSPEC_TIMEO; ctx->timeo = NFS_UNSPEC_TIMEO;
data->retrans = NFS_UNSPEC_RETRANS; ctx->retrans = NFS_UNSPEC_RETRANS;
data->acregmin = NFS_DEF_ACREGMIN; ctx->acregmin = NFS_DEF_ACREGMIN;
data->acregmax = NFS_DEF_ACREGMAX; ctx->acregmax = NFS_DEF_ACREGMAX;
data->acdirmin = NFS_DEF_ACDIRMIN; ctx->acdirmin = NFS_DEF_ACDIRMIN;
data->acdirmax = NFS_DEF_ACDIRMAX; ctx->acdirmax = NFS_DEF_ACDIRMAX;
data->mount_server.port = NFS_UNSPEC_PORT; ctx->mount_server.port = NFS_UNSPEC_PORT;
data->nfs_server.port = NFS_UNSPEC_PORT; ctx->nfs_server.port = NFS_UNSPEC_PORT;
data->nfs_server.protocol = XPRT_TRANSPORT_TCP; ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
data->selected_flavor = RPC_AUTH_MAXFLAVOR; ctx->selected_flavor = RPC_AUTH_MAXFLAVOR;
data->minorversion = 0; ctx->minorversion = 0;
data->need_mount = true; ctx->need_mount = true;
data->net = current->nsproxy->net_ns; ctx->net = current->nsproxy->net_ns;
data->lsm_opts = NULL; ctx->lsm_opts = NULL;
} }
return data; return ctx;
} }
void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data) void nfs_free_parsed_mount_data(struct nfs_fs_context *ctx)
{ {
if (data) { if (ctx) {
kfree(data->client_address); kfree(ctx->client_address);
kfree(data->mount_server.hostname); kfree(ctx->mount_server.hostname);
kfree(data->nfs_server.export_path); kfree(ctx->nfs_server.export_path);
kfree(data->nfs_server.hostname); kfree(ctx->nfs_server.hostname);
kfree(data->fscache_uniq); kfree(ctx->fscache_uniq);
security_free_mnt_opts(&data->lsm_opts); security_free_mnt_opts(&ctx->lsm_opts);
kfree(data); kfree(ctx);
} }
} }
@ -306,15 +306,15 @@ static int nfs_verify_server_address(struct sockaddr *addr)
* Sanity check the NFS transport protocol. * Sanity check the NFS transport protocol.
* *
*/ */
static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt) static void nfs_validate_transport_protocol(struct nfs_fs_context *ctx)
{ {
switch (mnt->nfs_server.protocol) { switch (ctx->nfs_server.protocol) {
case XPRT_TRANSPORT_UDP: case XPRT_TRANSPORT_UDP:
case XPRT_TRANSPORT_TCP: case XPRT_TRANSPORT_TCP:
case XPRT_TRANSPORT_RDMA: case XPRT_TRANSPORT_RDMA:
break; break;
default: default:
mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
} }
} }
@ -322,20 +322,20 @@ static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
* For text based NFSv2/v3 mounts, the mount protocol transport default * For text based NFSv2/v3 mounts, the mount protocol transport default
* settings should depend upon the specified NFS transport. * settings should depend upon the specified NFS transport.
*/ */
static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt) static void nfs_set_mount_transport_protocol(struct nfs_fs_context *ctx)
{ {
nfs_validate_transport_protocol(mnt); nfs_validate_transport_protocol(ctx);
if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP || if (ctx->mount_server.protocol == XPRT_TRANSPORT_UDP ||
mnt->mount_server.protocol == XPRT_TRANSPORT_TCP) ctx->mount_server.protocol == XPRT_TRANSPORT_TCP)
return; return;
switch (mnt->nfs_server.protocol) { switch (ctx->nfs_server.protocol) {
case XPRT_TRANSPORT_UDP: case XPRT_TRANSPORT_UDP:
mnt->mount_server.protocol = XPRT_TRANSPORT_UDP; ctx->mount_server.protocol = XPRT_TRANSPORT_UDP;
break; break;
case XPRT_TRANSPORT_TCP: case XPRT_TRANSPORT_TCP:
case XPRT_TRANSPORT_RDMA: case XPRT_TRANSPORT_RDMA:
mnt->mount_server.protocol = XPRT_TRANSPORT_TCP; ctx->mount_server.protocol = XPRT_TRANSPORT_TCP;
} }
} }
@ -367,8 +367,7 @@ static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
/* /*
* Parse the value of the 'sec=' option. * Parse the value of the 'sec=' option.
*/ */
static int nfs_parse_security_flavors(char *value, static int nfs_parse_security_flavors(char *value, struct nfs_fs_context *ctx)
struct nfs_parsed_mount_data *mnt)
{ {
substring_t args[MAX_OPT_ARGS]; substring_t args[MAX_OPT_ARGS];
rpc_authflavor_t pseudoflavor; rpc_authflavor_t pseudoflavor;
@ -417,7 +416,7 @@ static int nfs_parse_security_flavors(char *value,
return 0; return 0;
} }
if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor)) if (!nfs_auth_info_add(&ctx->auth_info, pseudoflavor))
return 0; return 0;
} }
@ -425,36 +424,36 @@ static int nfs_parse_security_flavors(char *value,
} }
static int nfs_parse_version_string(char *string, static int nfs_parse_version_string(char *string,
struct nfs_parsed_mount_data *mnt, struct nfs_fs_context *ctx,
substring_t *args) substring_t *args)
{ {
mnt->flags &= ~NFS_MOUNT_VER3; ctx->flags &= ~NFS_MOUNT_VER3;
switch (match_token(string, nfs_vers_tokens, args)) { switch (match_token(string, nfs_vers_tokens, args)) {
case Opt_vers_2: case Opt_vers_2:
mnt->version = 2; ctx->version = 2;
break; break;
case Opt_vers_3: case Opt_vers_3:
mnt->flags |= NFS_MOUNT_VER3; ctx->flags |= NFS_MOUNT_VER3;
mnt->version = 3; ctx->version = 3;
break; break;
case Opt_vers_4: case Opt_vers_4:
/* Backward compatibility option. In future, /* Backward compatibility option. In future,
* the mount program should always supply * the mount program should always supply
* a NFSv4 minor version number. * a NFSv4 minor version number.
*/ */
mnt->version = 4; ctx->version = 4;
break; break;
case Opt_vers_4_0: case Opt_vers_4_0:
mnt->version = 4; ctx->version = 4;
mnt->minorversion = 0; ctx->minorversion = 0;
break; break;
case Opt_vers_4_1: case Opt_vers_4_1:
mnt->version = 4; ctx->version = 4;
mnt->minorversion = 1; ctx->minorversion = 1;
break; break;
case Opt_vers_4_2: case Opt_vers_4_2:
mnt->version = 4; ctx->version = 4;
mnt->minorversion = 2; ctx->minorversion = 2;
break; break;
default: default:
return 0; return 0;
@ -502,7 +501,7 @@ static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
* skipped as they are encountered. If there were no errors, return 1; * skipped as they are encountered. If there were no errors, return 1;
* otherwise return 0 (zero). * otherwise return 0 (zero).
*/ */
int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt) int nfs_parse_mount_options(char *raw, struct nfs_fs_context *ctx)
{ {
char *p, *string; char *p, *string;
int rc, sloppy = 0, invalid_option = 0; int rc, sloppy = 0, invalid_option = 0;
@ -515,7 +514,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
} }
dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw); dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
rc = security_sb_eat_lsm_opts(raw, &mnt->lsm_opts); rc = security_sb_eat_lsm_opts(raw, &ctx->lsm_opts);
if (rc) if (rc)
goto out_security_failure; goto out_security_failure;
@ -536,96 +535,96 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
* boolean options: foo/nofoo * boolean options: foo/nofoo
*/ */
case Opt_soft: case Opt_soft:
mnt->flags |= NFS_MOUNT_SOFT; ctx->flags |= NFS_MOUNT_SOFT;
mnt->flags &= ~NFS_MOUNT_SOFTERR; ctx->flags &= ~NFS_MOUNT_SOFTERR;
break; break;
case Opt_softerr: case Opt_softerr:
mnt->flags |= NFS_MOUNT_SOFTERR; ctx->flags |= NFS_MOUNT_SOFTERR;
mnt->flags &= ~NFS_MOUNT_SOFT; ctx->flags &= ~NFS_MOUNT_SOFT;
break; break;
case Opt_hard: case Opt_hard:
mnt->flags &= ~(NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR); ctx->flags &= ~(NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR);
break; break;
case Opt_posix: case Opt_posix:
mnt->flags |= NFS_MOUNT_POSIX; ctx->flags |= NFS_MOUNT_POSIX;
break; break;
case Opt_noposix: case Opt_noposix:
mnt->flags &= ~NFS_MOUNT_POSIX; ctx->flags &= ~NFS_MOUNT_POSIX;
break; break;
case Opt_cto: case Opt_cto:
mnt->flags &= ~NFS_MOUNT_NOCTO; ctx->flags &= ~NFS_MOUNT_NOCTO;
break; break;
case Opt_nocto: case Opt_nocto:
mnt->flags |= NFS_MOUNT_NOCTO; ctx->flags |= NFS_MOUNT_NOCTO;
break; break;
case Opt_ac: case Opt_ac:
mnt->flags &= ~NFS_MOUNT_NOAC; ctx->flags &= ~NFS_MOUNT_NOAC;
break; break;
case Opt_noac: case Opt_noac:
mnt->flags |= NFS_MOUNT_NOAC; ctx->flags |= NFS_MOUNT_NOAC;
break; break;
case Opt_lock: case Opt_lock:
mnt->flags &= ~NFS_MOUNT_NONLM; ctx->flags &= ~NFS_MOUNT_NONLM;
mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FCNTL);
break; break;
case Opt_nolock: case Opt_nolock:
mnt->flags |= NFS_MOUNT_NONLM; ctx->flags |= NFS_MOUNT_NONLM;
mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK | ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FCNTL);
break; break;
case Opt_udp: case Opt_udp:
mnt->flags &= ~NFS_MOUNT_TCP; ctx->flags &= ~NFS_MOUNT_TCP;
mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
break; break;
case Opt_tcp: case Opt_tcp:
mnt->flags |= NFS_MOUNT_TCP; ctx->flags |= NFS_MOUNT_TCP;
mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
break; break;
case Opt_rdma: case Opt_rdma:
mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */ ctx->flags |= NFS_MOUNT_TCP; /* for side protocols */
mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA; ctx->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
xprt_load_transport(p); xprt_load_transport(p);
break; break;
case Opt_acl: case Opt_acl:
mnt->flags &= ~NFS_MOUNT_NOACL; ctx->flags &= ~NFS_MOUNT_NOACL;
break; break;
case Opt_noacl: case Opt_noacl:
mnt->flags |= NFS_MOUNT_NOACL; ctx->flags |= NFS_MOUNT_NOACL;
break; break;
case Opt_rdirplus: case Opt_rdirplus:
mnt->flags &= ~NFS_MOUNT_NORDIRPLUS; ctx->flags &= ~NFS_MOUNT_NORDIRPLUS;
break; break;
case Opt_nordirplus: case Opt_nordirplus:
mnt->flags |= NFS_MOUNT_NORDIRPLUS; ctx->flags |= NFS_MOUNT_NORDIRPLUS;
break; break;
case Opt_sharecache: case Opt_sharecache:
mnt->flags &= ~NFS_MOUNT_UNSHARED; ctx->flags &= ~NFS_MOUNT_UNSHARED;
break; break;
case Opt_nosharecache: case Opt_nosharecache:
mnt->flags |= NFS_MOUNT_UNSHARED; ctx->flags |= NFS_MOUNT_UNSHARED;
break; break;
case Opt_resvport: case Opt_resvport:
mnt->flags &= ~NFS_MOUNT_NORESVPORT; ctx->flags &= ~NFS_MOUNT_NORESVPORT;
break; break;
case Opt_noresvport: case Opt_noresvport:
mnt->flags |= NFS_MOUNT_NORESVPORT; ctx->flags |= NFS_MOUNT_NORESVPORT;
break; break;
case Opt_fscache: case Opt_fscache:
mnt->options |= NFS_OPTION_FSCACHE; ctx->options |= NFS_OPTION_FSCACHE;
kfree(mnt->fscache_uniq); kfree(ctx->fscache_uniq);
mnt->fscache_uniq = NULL; ctx->fscache_uniq = NULL;
break; break;
case Opt_nofscache: case Opt_nofscache:
mnt->options &= ~NFS_OPTION_FSCACHE; ctx->options &= ~NFS_OPTION_FSCACHE;
kfree(mnt->fscache_uniq); kfree(ctx->fscache_uniq);
mnt->fscache_uniq = NULL; ctx->fscache_uniq = NULL;
break; break;
case Opt_migration: case Opt_migration:
mnt->options |= NFS_OPTION_MIGRATION; ctx->options |= NFS_OPTION_MIGRATION;
break; break;
case Opt_nomigration: case Opt_nomigration:
mnt->options &= ~NFS_OPTION_MIGRATION; ctx->options &= ~NFS_OPTION_MIGRATION;
break; break;
/* /*
@ -635,83 +634,83 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
if (nfs_get_option_ul(args, &option) || if (nfs_get_option_ul(args, &option) ||
option > USHRT_MAX) option > USHRT_MAX)
goto out_invalid_value; goto out_invalid_value;
mnt->nfs_server.port = option; ctx->nfs_server.port = option;
break; break;
case Opt_rsize: case Opt_rsize:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->rsize = option; ctx->rsize = option;
break; break;
case Opt_wsize: case Opt_wsize:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->wsize = option; ctx->wsize = option;
break; break;
case Opt_bsize: case Opt_bsize:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->bsize = option; ctx->bsize = option;
break; break;
case Opt_timeo: case Opt_timeo:
if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX)) if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
goto out_invalid_value; goto out_invalid_value;
mnt->timeo = option; ctx->timeo = option;
break; break;
case Opt_retrans: case Opt_retrans:
if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX)) if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
goto out_invalid_value; goto out_invalid_value;
mnt->retrans = option; ctx->retrans = option;
break; break;
case Opt_acregmin: case Opt_acregmin:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->acregmin = option; ctx->acregmin = option;
break; break;
case Opt_acregmax: case Opt_acregmax:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->acregmax = option; ctx->acregmax = option;
break; break;
case Opt_acdirmin: case Opt_acdirmin:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->acdirmin = option; ctx->acdirmin = option;
break; break;
case Opt_acdirmax: case Opt_acdirmax:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->acdirmax = option; ctx->acdirmax = option;
break; break;
case Opt_actimeo: case Opt_actimeo:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->acregmin = mnt->acregmax = ctx->acregmin = ctx->acregmax =
mnt->acdirmin = mnt->acdirmax = option; ctx->acdirmin = ctx->acdirmax = option;
break; break;
case Opt_namelen: case Opt_namelen:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
mnt->namlen = option; ctx->namlen = option;
break; break;
case Opt_mountport: case Opt_mountport:
if (nfs_get_option_ul(args, &option) || if (nfs_get_option_ul(args, &option) ||
option > USHRT_MAX) option > USHRT_MAX)
goto out_invalid_value; goto out_invalid_value;
mnt->mount_server.port = option; ctx->mount_server.port = option;
break; break;
case Opt_mountvers: case Opt_mountvers:
if (nfs_get_option_ul(args, &option) || if (nfs_get_option_ul(args, &option) ||
option < NFS_MNT_VERSION || option < NFS_MNT_VERSION ||
option > NFS_MNT3_VERSION) option > NFS_MNT3_VERSION)
goto out_invalid_value; goto out_invalid_value;
mnt->mount_server.version = option; ctx->mount_server.version = option;
break; break;
case Opt_minorversion: case Opt_minorversion:
if (nfs_get_option_ul(args, &option)) if (nfs_get_option_ul(args, &option))
goto out_invalid_value; goto out_invalid_value;
if (option > NFS4_MAX_MINOR_VERSION) if (option > NFS4_MAX_MINOR_VERSION)
goto out_invalid_value; goto out_invalid_value;
mnt->minorversion = option; ctx->minorversion = option;
break; break;
/* /*
@ -721,7 +720,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
string = match_strdup(args); string = match_strdup(args);
if (string == NULL) if (string == NULL)
goto out_nomem; goto out_nomem;
rc = nfs_parse_version_string(string, mnt, args); rc = nfs_parse_version_string(string, ctx, args);
kfree(string); kfree(string);
if (!rc) if (!rc)
goto out_invalid_value; goto out_invalid_value;
@ -730,7 +729,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
string = match_strdup(args); string = match_strdup(args);
if (string == NULL) if (string == NULL)
goto out_nomem; goto out_nomem;
rc = nfs_parse_security_flavors(string, mnt); rc = nfs_parse_security_flavors(string, ctx);
kfree(string); kfree(string);
if (!rc) { if (!rc) {
dfprintk(MOUNT, "NFS: unrecognized " dfprintk(MOUNT, "NFS: unrecognized "
@ -751,23 +750,23 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
protofamily = AF_INET6; protofamily = AF_INET6;
/* fall through */ /* fall through */
case Opt_xprt_udp: case Opt_xprt_udp:
mnt->flags &= ~NFS_MOUNT_TCP; ctx->flags &= ~NFS_MOUNT_TCP;
mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
break; break;
case Opt_xprt_tcp6: case Opt_xprt_tcp6:
protofamily = AF_INET6; protofamily = AF_INET6;
/* fall through */ /* fall through */
case Opt_xprt_tcp: case Opt_xprt_tcp:
mnt->flags |= NFS_MOUNT_TCP; ctx->flags |= NFS_MOUNT_TCP;
mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
break; break;
case Opt_xprt_rdma6: case Opt_xprt_rdma6:
protofamily = AF_INET6; protofamily = AF_INET6;
/* fall through */ /* fall through */
case Opt_xprt_rdma: case Opt_xprt_rdma:
/* vector side protocols to TCP */ /* vector side protocols to TCP */
mnt->flags |= NFS_MOUNT_TCP; ctx->flags |= NFS_MOUNT_TCP;
mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA; ctx->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
xprt_load_transport(string); xprt_load_transport(string);
break; break;
default: default:
@ -792,13 +791,13 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
mountfamily = AF_INET6; mountfamily = AF_INET6;
/* fall through */ /* fall through */
case Opt_xprt_udp: case Opt_xprt_udp:
mnt->mount_server.protocol = XPRT_TRANSPORT_UDP; ctx->mount_server.protocol = XPRT_TRANSPORT_UDP;
break; break;
case Opt_xprt_tcp6: case Opt_xprt_tcp6:
mountfamily = AF_INET6; mountfamily = AF_INET6;
/* fall through */ /* fall through */
case Opt_xprt_tcp: case Opt_xprt_tcp:
mnt->mount_server.protocol = XPRT_TRANSPORT_TCP; ctx->mount_server.protocol = XPRT_TRANSPORT_TCP;
break; break;
case Opt_xprt_rdma: /* not used for side protocols */ case Opt_xprt_rdma: /* not used for side protocols */
default: default:
@ -811,41 +810,41 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
string = match_strdup(args); string = match_strdup(args);
if (string == NULL) if (string == NULL)
goto out_nomem; goto out_nomem;
mnt->nfs_server.addrlen = ctx->nfs_server.addrlen =
rpc_pton(mnt->net, string, strlen(string), rpc_pton(ctx->net, string, strlen(string),
(struct sockaddr *) (struct sockaddr *)
&mnt->nfs_server.address, &ctx->nfs_server.address,
sizeof(mnt->nfs_server.address)); sizeof(ctx->nfs_server.address));
kfree(string); kfree(string);
if (mnt->nfs_server.addrlen == 0) if (ctx->nfs_server.addrlen == 0)
goto out_invalid_address; goto out_invalid_address;
break; break;
case Opt_clientaddr: case Opt_clientaddr:
if (nfs_get_option_str(args, &mnt->client_address)) if (nfs_get_option_str(args, &ctx->client_address))
goto out_nomem; goto out_nomem;
break; break;
case Opt_mounthost: case Opt_mounthost:
if (nfs_get_option_str(args, if (nfs_get_option_str(args,
&mnt->mount_server.hostname)) &ctx->mount_server.hostname))
goto out_nomem; goto out_nomem;
break; break;
case Opt_mountaddr: case Opt_mountaddr:
string = match_strdup(args); string = match_strdup(args);
if (string == NULL) if (string == NULL)
goto out_nomem; goto out_nomem;
mnt->mount_server.addrlen = ctx->mount_server.addrlen =
rpc_pton(mnt->net, string, strlen(string), rpc_pton(ctx->net, string, strlen(string),
(struct sockaddr *) (struct sockaddr *)
&mnt->mount_server.address, &ctx->mount_server.address,
sizeof(mnt->mount_server.address)); sizeof(ctx->mount_server.address));
kfree(string); kfree(string);
if (mnt->mount_server.addrlen == 0) if (ctx->mount_server.addrlen == 0)
goto out_invalid_address; goto out_invalid_address;
break; break;
case Opt_nconnect: case Opt_nconnect:
if (nfs_get_option_ul_bound(args, &option, 1, NFS_MAX_CONNECTIONS)) if (nfs_get_option_ul_bound(args, &option, 1, NFS_MAX_CONNECTIONS))
goto out_invalid_value; goto out_invalid_value;
mnt->nfs_server.nconnect = option; ctx->nfs_server.nconnect = option;
break; break;
case Opt_lookupcache: case Opt_lookupcache:
string = match_strdup(args); string = match_strdup(args);
@ -856,14 +855,14 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
kfree(string); kfree(string);
switch (token) { switch (token) {
case Opt_lookupcache_all: case Opt_lookupcache_all:
mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE); ctx->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
break; break;
case Opt_lookupcache_positive: case Opt_lookupcache_positive:
mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE; ctx->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG; ctx->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
break; break;
case Opt_lookupcache_none: case Opt_lookupcache_none:
mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE; ctx->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
break; break;
default: default:
dfprintk(MOUNT, "NFS: invalid " dfprintk(MOUNT, "NFS: invalid "
@ -872,9 +871,9 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
} }
break; break;
case Opt_fscache_uniq: case Opt_fscache_uniq:
if (nfs_get_option_str(args, &mnt->fscache_uniq)) if (nfs_get_option_str(args, &ctx->fscache_uniq))
goto out_nomem; goto out_nomem;
mnt->options |= NFS_OPTION_FSCACHE; ctx->options |= NFS_OPTION_FSCACHE;
break; break;
case Opt_local_lock: case Opt_local_lock:
string = match_strdup(args); string = match_strdup(args);
@ -885,17 +884,17 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
kfree(string); kfree(string);
switch (token) { switch (token) {
case Opt_local_lock_all: case Opt_local_lock_all:
mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK | ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FCNTL);
break; break;
case Opt_local_lock_flock: case Opt_local_lock_flock:
mnt->flags |= NFS_MOUNT_LOCAL_FLOCK; ctx->flags |= NFS_MOUNT_LOCAL_FLOCK;
break; break;
case Opt_local_lock_posix: case Opt_local_lock_posix:
mnt->flags |= NFS_MOUNT_LOCAL_FCNTL; ctx->flags |= NFS_MOUNT_LOCAL_FCNTL;
break; break;
case Opt_local_lock_none: case Opt_local_lock_none:
mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FCNTL);
break; break;
default: default:
@ -928,11 +927,11 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
if (!sloppy && invalid_option) if (!sloppy && invalid_option)
return 0; return 0;
if (mnt->minorversion && mnt->version != 4) if (ctx->minorversion && ctx->version != 4)
goto out_minorversion_mismatch; goto out_minorversion_mismatch;
if (mnt->options & NFS_OPTION_MIGRATION && if (ctx->options & NFS_OPTION_MIGRATION &&
(mnt->version != 4 || mnt->minorversion != 0)) (ctx->version != 4 || ctx->minorversion != 0))
goto out_migration_misuse; goto out_migration_misuse;
/* /*
@ -940,15 +939,15 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
* families in the addr=/mountaddr= options. * families in the addr=/mountaddr= options.
*/ */
if (protofamily != AF_UNSPEC && if (protofamily != AF_UNSPEC &&
protofamily != mnt->nfs_server.address.ss_family) protofamily != ctx->nfs_server.address.ss_family)
goto out_proto_mismatch; goto out_proto_mismatch;
if (mountfamily != AF_UNSPEC) { if (mountfamily != AF_UNSPEC) {
if (mnt->mount_server.addrlen) { if (ctx->mount_server.addrlen) {
if (mountfamily != mnt->mount_server.address.ss_family) if (mountfamily != ctx->mount_server.address.ss_family)
goto out_mountproto_mismatch; goto out_mountproto_mismatch;
} else { } else {
if (mountfamily != mnt->nfs_server.address.ss_family) if (mountfamily != ctx->nfs_server.address.ss_family)
goto out_mountproto_mismatch; goto out_mountproto_mismatch;
} }
} }
@ -970,7 +969,7 @@ out_invalid_value:
return 0; return 0;
out_minorversion_mismatch: out_minorversion_mismatch:
printk(KERN_INFO "NFS: mount option vers=%u does not support " printk(KERN_INFO "NFS: mount option vers=%u does not support "
"minorversion=%u\n", mnt->version, mnt->minorversion); "minorversion=%u\n", ctx->version, ctx->minorversion);
return 0; return 0;
out_migration_misuse: out_migration_misuse:
printk(KERN_INFO printk(KERN_INFO
@ -1078,18 +1077,18 @@ out_path:
* mountproto=tcp after mountproto=udp, and so on * mountproto=tcp after mountproto=udp, and so on
*/ */
static int nfs23_validate_mount_data(void *options, static int nfs23_validate_mount_data(void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
struct nfs_fh *mntfh, struct nfs_fh *mntfh,
const char *dev_name) const char *dev_name)
{ {
struct nfs_mount_data *data = (struct nfs_mount_data *)options; struct nfs_mount_data *data = (struct nfs_mount_data *)options;
struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
int extra_flags = NFS_MOUNT_LEGACY_INTERFACE; int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
if (data == NULL) if (data == NULL)
goto out_no_data; goto out_no_data;
args->version = NFS_DEFAULT_VERSION; ctx->version = NFS_DEFAULT_VERSION;
switch (data->version) { switch (data->version) {
case 1: case 1:
data->namlen = 0; /* fall through */ data->namlen = 0; /* fall through */
@ -1115,10 +1114,10 @@ static int nfs23_validate_mount_data(void *options,
if (data->root.size > NFS3_FHSIZE || data->root.size == 0) if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
goto out_invalid_fh; goto out_invalid_fh;
mntfh->size = data->root.size; mntfh->size = data->root.size;
args->version = 3; ctx->version = 3;
} else { } else {
mntfh->size = NFS2_FHSIZE; mntfh->size = NFS2_FHSIZE;
args->version = 2; ctx->version = 2;
} }
@ -1128,47 +1127,47 @@ static int nfs23_validate_mount_data(void *options,
sizeof(mntfh->data) - mntfh->size); sizeof(mntfh->data) - mntfh->size);
/* /*
* Translate to nfs_parsed_mount_data, which nfs_fill_super * Translate to nfs_fs_context, which nfs_fill_super
* can deal with. * can deal with.
*/ */
args->flags = data->flags & NFS_MOUNT_FLAGMASK; ctx->flags = data->flags & NFS_MOUNT_FLAGMASK;
args->flags |= extra_flags; ctx->flags |= extra_flags;
args->rsize = data->rsize; ctx->rsize = data->rsize;
args->wsize = data->wsize; ctx->wsize = data->wsize;
args->timeo = data->timeo; ctx->timeo = data->timeo;
args->retrans = data->retrans; ctx->retrans = data->retrans;
args->acregmin = data->acregmin; ctx->acregmin = data->acregmin;
args->acregmax = data->acregmax; ctx->acregmax = data->acregmax;
args->acdirmin = data->acdirmin; ctx->acdirmin = data->acdirmin;
args->acdirmax = data->acdirmax; ctx->acdirmax = data->acdirmax;
args->need_mount = false; ctx->need_mount = false;
memcpy(sap, &data->addr, sizeof(data->addr)); memcpy(sap, &data->addr, sizeof(data->addr));
args->nfs_server.addrlen = sizeof(data->addr); ctx->nfs_server.addrlen = sizeof(data->addr);
args->nfs_server.port = ntohs(data->addr.sin_port); ctx->nfs_server.port = ntohs(data->addr.sin_port);
if (sap->sa_family != AF_INET || if (sap->sa_family != AF_INET ||
!nfs_verify_server_address(sap)) !nfs_verify_server_address(sap))
goto out_no_address; goto out_no_address;
if (!(data->flags & NFS_MOUNT_TCP)) if (!(data->flags & NFS_MOUNT_TCP))
args->nfs_server.protocol = XPRT_TRANSPORT_UDP; ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
/* N.B. caller will free nfs_server.hostname in all cases */ /* N.B. caller will free nfs_server.hostname in all cases */
args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL); ctx->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
args->namlen = data->namlen; ctx->namlen = data->namlen;
args->bsize = data->bsize; ctx->bsize = data->bsize;
if (data->flags & NFS_MOUNT_SECFLAVOUR) if (data->flags & NFS_MOUNT_SECFLAVOUR)
args->selected_flavor = data->pseudoflavor; ctx->selected_flavor = data->pseudoflavor;
else else
args->selected_flavor = RPC_AUTH_UNIX; ctx->selected_flavor = RPC_AUTH_UNIX;
if (!args->nfs_server.hostname) if (!ctx->nfs_server.hostname)
goto out_nomem; goto out_nomem;
if (!(data->flags & NFS_MOUNT_NONLM)) if (!(data->flags & NFS_MOUNT_NONLM))
args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK| ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FCNTL);
else else
args->flags |= (NFS_MOUNT_LOCAL_FLOCK| ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK|
NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FCNTL);
/* /*
* The legacy version 6 binary mount data from userspace has a * The legacy version 6 binary mount data from userspace has a
@ -1183,7 +1182,7 @@ static int nfs23_validate_mount_data(void *options,
int rc; int rc;
data->context[NFS_MAX_CONTEXT_LEN] = '\0'; data->context[NFS_MAX_CONTEXT_LEN] = '\0';
rc = security_add_mnt_opt("context", data->context, rc = security_add_mnt_opt("context", data->context,
strlen(data->context), &args->lsm_opts); strlen(data->context), ctx->lsm_opts);
if (rc) if (rc)
return rc; return rc;
#else #else
@ -1225,10 +1224,9 @@ out_invalid_fh:
} }
#if IS_ENABLED(CONFIG_NFS_V4) #if IS_ENABLED(CONFIG_NFS_V4)
static void nfs4_validate_mount_flags(struct nfs_fs_context *ctx)
static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
{ {
args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3| ctx->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL); NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
} }
@ -1236,30 +1234,30 @@ static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
* Validate NFSv4 mount options * Validate NFSv4 mount options
*/ */
static int nfs4_validate_mount_data(void *options, static int nfs4_validate_mount_data(void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
const char *dev_name) const char *dev_name)
{ {
struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
struct nfs4_mount_data *data = (struct nfs4_mount_data *)options; struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
char *c; char *c;
if (data == NULL) if (data == NULL)
goto out_no_data; goto out_no_data;
args->version = 4; ctx->version = 4;
switch (data->version) { switch (data->version) {
case 1: case 1:
if (data->host_addrlen > sizeof(args->nfs_server.address)) if (data->host_addrlen > sizeof(ctx->nfs_server.address))
goto out_no_address; goto out_no_address;
if (data->host_addrlen == 0) if (data->host_addrlen == 0)
goto out_no_address; goto out_no_address;
args->nfs_server.addrlen = data->host_addrlen; ctx->nfs_server.addrlen = data->host_addrlen;
if (copy_from_user(sap, data->host_addr, data->host_addrlen)) if (copy_from_user(sap, data->host_addr, data->host_addrlen))
return -EFAULT; return -EFAULT;
if (!nfs_verify_server_address(sap)) if (!nfs_verify_server_address(sap))
goto out_no_address; goto out_no_address;
args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port); ctx->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
if (data->auth_flavourlen) { if (data->auth_flavourlen) {
rpc_authflavor_t pseudoflavor; rpc_authflavor_t pseudoflavor;
@ -1269,43 +1267,43 @@ static int nfs4_validate_mount_data(void *options,
data->auth_flavours, data->auth_flavours,
sizeof(pseudoflavor))) sizeof(pseudoflavor)))
return -EFAULT; return -EFAULT;
args->selected_flavor = pseudoflavor; ctx->selected_flavor = pseudoflavor;
} else } else
args->selected_flavor = RPC_AUTH_UNIX; ctx->selected_flavor = RPC_AUTH_UNIX;
c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN); c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
if (IS_ERR(c)) if (IS_ERR(c))
return PTR_ERR(c); return PTR_ERR(c);
args->nfs_server.hostname = c; ctx->nfs_server.hostname = c;
c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN); c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
if (IS_ERR(c)) if (IS_ERR(c))
return PTR_ERR(c); return PTR_ERR(c);
args->nfs_server.export_path = c; ctx->nfs_server.export_path = c;
dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c); dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
c = strndup_user(data->client_addr.data, 16); c = strndup_user(data->client_addr.data, 16);
if (IS_ERR(c)) if (IS_ERR(c))
return PTR_ERR(c); return PTR_ERR(c);
args->client_address = c; ctx->client_address = c;
/* /*
* Translate to nfs_parsed_mount_data, which nfs4_fill_super * Translate to nfs_fs_context, which nfs4_fill_super
* can deal with. * can deal with.
*/ */
args->flags = data->flags & NFS4_MOUNT_FLAGMASK; ctx->flags = data->flags & NFS4_MOUNT_FLAGMASK;
args->rsize = data->rsize; ctx->rsize = data->rsize;
args->wsize = data->wsize; ctx->wsize = data->wsize;
args->timeo = data->timeo; ctx->timeo = data->timeo;
args->retrans = data->retrans; ctx->retrans = data->retrans;
args->acregmin = data->acregmin; ctx->acregmin = data->acregmin;
args->acregmax = data->acregmax; ctx->acregmax = data->acregmax;
args->acdirmin = data->acdirmin; ctx->acdirmin = data->acdirmin;
args->acdirmax = data->acdirmax; ctx->acdirmax = data->acdirmax;
args->nfs_server.protocol = data->proto; ctx->nfs_server.protocol = data->proto;
nfs_validate_transport_protocol(args); nfs_validate_transport_protocol(ctx);
if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP) if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
goto out_invalid_transport_udp; goto out_invalid_transport_udp;
break; break;
@ -1335,67 +1333,67 @@ out_invalid_transport_udp:
int nfs_validate_mount_data(struct file_system_type *fs_type, int nfs_validate_mount_data(struct file_system_type *fs_type,
void *options, void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
struct nfs_fh *mntfh, struct nfs_fh *mntfh,
const char *dev_name) const char *dev_name)
{ {
if (fs_type == &nfs_fs_type) if (fs_type == &nfs_fs_type)
return nfs23_validate_mount_data(options, args, mntfh, dev_name); return nfs23_validate_mount_data(options, ctx, mntfh, dev_name);
return nfs4_validate_mount_data(options, args, dev_name); return nfs4_validate_mount_data(options, ctx, dev_name);
} }
#else #else
int nfs_validate_mount_data(struct file_system_type *fs_type, int nfs_validate_mount_data(struct file_system_type *fs_type,
void *options, void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
struct nfs_fh *mntfh, struct nfs_fh *mntfh,
const char *dev_name) const char *dev_name)
{ {
return nfs23_validate_mount_data(options, args, mntfh, dev_name); return nfs23_validate_mount_data(options, ctx, mntfh, dev_name);
} }
#endif #endif
int nfs_validate_text_mount_data(void *options, int nfs_validate_text_mount_data(void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
const char *dev_name) const char *dev_name)
{ {
int port = 0; int port = 0;
int max_namelen = PAGE_SIZE; int max_namelen = PAGE_SIZE;
int max_pathlen = NFS_MAXPATHLEN; int max_pathlen = NFS_MAXPATHLEN;
struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
if (nfs_parse_mount_options((char *)options, args) == 0) if (nfs_parse_mount_options((char *)options, ctx) == 0)
return -EINVAL; return -EINVAL;
if (!nfs_verify_server_address(sap)) if (!nfs_verify_server_address(sap))
goto out_no_address; goto out_no_address;
if (args->version == 4) { if (ctx->version == 4) {
#if IS_ENABLED(CONFIG_NFS_V4) #if IS_ENABLED(CONFIG_NFS_V4)
if (args->nfs_server.protocol == XPRT_TRANSPORT_RDMA) if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
port = NFS_RDMA_PORT; port = NFS_RDMA_PORT;
else else
port = NFS_PORT; port = NFS_PORT;
max_namelen = NFS4_MAXNAMLEN; max_namelen = NFS4_MAXNAMLEN;
max_pathlen = NFS4_MAXPATHLEN; max_pathlen = NFS4_MAXPATHLEN;
nfs_validate_transport_protocol(args); nfs_validate_transport_protocol(ctx);
if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP) if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
goto out_invalid_transport_udp; goto out_invalid_transport_udp;
nfs4_validate_mount_flags(args); nfs4_validate_mount_flags(ctx);
#else #else
goto out_v4_not_compiled; goto out_v4_not_compiled;
#endif /* CONFIG_NFS_V4 */ #endif /* CONFIG_NFS_V4 */
} else { } else {
nfs_set_mount_transport_protocol(args); nfs_set_mount_transport_protocol(ctx);
if (args->nfs_server.protocol == XPRT_TRANSPORT_RDMA) if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
port = NFS_RDMA_PORT; port = NFS_RDMA_PORT;
} }
nfs_set_port(sap, &args->nfs_server.port, port); nfs_set_port(sap, &ctx->nfs_server.port, port);
return nfs_parse_devname(dev_name, return nfs_parse_devname(dev_name,
&args->nfs_server.hostname, &ctx->nfs_server.hostname,
max_namelen, max_namelen,
&args->nfs_server.export_path, &ctx->nfs_server.export_path,
max_pathlen); max_pathlen);
#if !IS_ENABLED(CONFIG_NFS_V4) #if !IS_ENABLED(CONFIG_NFS_V4)

14
fs/nfs/internal.h
View file

@ -81,7 +81,7 @@ struct nfs_client_initdata {
/* /*
* In-kernel mount arguments * In-kernel mount arguments
*/ */
struct nfs_parsed_mount_data { struct nfs_fs_context {
int flags; int flags;
unsigned int rsize, wsize; unsigned int rsize, wsize;
unsigned int timeo, retrans; unsigned int timeo, retrans;
@ -138,7 +138,7 @@ struct nfs_mount_request {
struct nfs_mount_info { struct nfs_mount_info {
unsigned int inherited_bsize; unsigned int inherited_bsize;
struct nfs_parsed_mount_data *parsed; struct nfs_fs_context *ctx;
struct nfs_clone_mount *cloned; struct nfs_clone_mount *cloned;
struct nfs_server *server; struct nfs_server *server;
struct nfs_fh *mntfh; struct nfs_fh *mntfh;
@ -229,16 +229,16 @@ struct nfs_pageio_descriptor;
/* mount.c */ /* mount.c */
#define NFS_TEXT_DATA 1 #define NFS_TEXT_DATA 1
extern struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void); extern struct nfs_fs_context *nfs_alloc_parsed_mount_data(void);
extern void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data); extern void nfs_free_parsed_mount_data(struct nfs_fs_context *ctx);
extern int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt); 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, extern int nfs_validate_mount_data(struct file_system_type *fs_type,
void *options, void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
struct nfs_fh *mntfh, struct nfs_fh *mntfh,
const char *dev_name); const char *dev_name);
extern int nfs_validate_text_mount_data(void *options, extern int nfs_validate_text_mount_data(void *options,
struct nfs_parsed_mount_data *args, struct nfs_fs_context *ctx,
const char *dev_name); const char *dev_name);
/* pagelist.c */ /* pagelist.c */

60
fs/nfs/nfs4client.c
View file

@ -1056,61 +1056,61 @@ out:
* Create a version 4 volume record * Create a version 4 volume record
*/ */
static int nfs4_init_server(struct nfs_server *server, static int nfs4_init_server(struct nfs_server *server,
struct nfs_parsed_mount_data *data) struct nfs_fs_context *ctx)
{ {
struct rpc_timeout timeparms; struct rpc_timeout timeparms;
int error; int error;
nfs_init_timeout_values(&timeparms, data->nfs_server.protocol, nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
data->timeo, data->retrans); ctx->timeo, ctx->retrans);
/* Initialise the client representation from the mount data */ /* Initialise the client representation from the mount data */
server->flags = data->flags; server->flags = ctx->flags;
server->options = data->options; server->options = ctx->options;
server->auth_info = data->auth_info; server->auth_info = ctx->auth_info;
/* Use the first specified auth flavor. If this flavor isn't /* Use the first specified auth flavor. If this flavor isn't
* allowed by the server, use the SECINFO path to try the * allowed by the server, use the SECINFO path to try the
* other specified flavors */ * other specified flavors */
if (data->auth_info.flavor_len >= 1) if (ctx->auth_info.flavor_len >= 1)
data->selected_flavor = data->auth_info.flavors[0]; ctx->selected_flavor = ctx->auth_info.flavors[0];
else else
data->selected_flavor = RPC_AUTH_UNIX; ctx->selected_flavor = RPC_AUTH_UNIX;
/* Get a client record */ /* Get a client record */
error = nfs4_set_client(server, error = nfs4_set_client(server,
data->nfs_server.hostname, ctx->nfs_server.hostname,
(const struct sockaddr *)&data->nfs_server.address, (const struct sockaddr *)&ctx->nfs_server.address,
data->nfs_server.addrlen, ctx->nfs_server.addrlen,
data->client_address, ctx->client_address,
data->nfs_server.protocol, ctx->nfs_server.protocol,
&timeparms, &timeparms,
data->minorversion, ctx->minorversion,
data->nfs_server.nconnect, ctx->nfs_server.nconnect,
data->net); ctx->net);
if (error < 0) if (error < 0)
return error; return error;
if (data->rsize) if (ctx->rsize)
server->rsize = nfs_block_size(data->rsize, NULL); server->rsize = nfs_block_size(ctx->rsize, NULL);
if (data->wsize) if (ctx->wsize)
server->wsize = nfs_block_size(data->wsize, NULL); server->wsize = nfs_block_size(ctx->wsize, NULL);
server->acregmin = data->acregmin * HZ; server->acregmin = ctx->acregmin * HZ;
server->acregmax = data->acregmax * HZ; server->acregmax = ctx->acregmax * HZ;
server->acdirmin = data->acdirmin * HZ; server->acdirmin = ctx->acdirmin * HZ;
server->acdirmax = data->acdirmax * HZ; server->acdirmax = ctx->acdirmax * HZ;
server->port = data->nfs_server.port; server->port = ctx->nfs_server.port;
return nfs_init_server_rpcclient(server, &timeparms, return nfs_init_server_rpcclient(server, &timeparms,
data->selected_flavor); ctx->selected_flavor);
} }
/* /*
* Create a version 4 volume record * Create a version 4 volume record
* - keyed on server and FSID * - keyed on server and FSID
*/ */
/*struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data, /*struct nfs_server *nfs4_create_server(const struct nfs_fs_context *data,
struct nfs_fh *mntfh)*/ struct nfs_fh *mntfh)*/
struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info) struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info)
{ {
@ -1124,10 +1124,10 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info)
server->cred = get_cred(current_cred()); server->cred = get_cred(current_cred());
auth_probe = mount_info->parsed->auth_info.flavor_len < 1; auth_probe = mount_info->ctx->auth_info.flavor_len < 1;
/* set up the general RPC client */ /* set up the general RPC client */
error = nfs4_init_server(server, mount_info->parsed); error = nfs4_init_server(server, mount_info->ctx);
if (error < 0) if (error < 0)
goto error; goto error;

6
fs/nfs/nfs4super.c
View file

@ -198,15 +198,15 @@ static struct dentry *do_nfs4_mount(struct nfs_server *server, int flags,
struct dentry *nfs4_try_mount(int flags, const char *dev_name, struct dentry *nfs4_try_mount(int flags, const char *dev_name,
struct nfs_mount_info *mount_info) struct nfs_mount_info *mount_info)
{ {
struct nfs_parsed_mount_data *data = mount_info->parsed; struct nfs_fs_context *ctx = mount_info->ctx;
struct dentry *res; struct dentry *res;
dfprintk(MOUNT, "--> nfs4_try_mount()\n"); dfprintk(MOUNT, "--> nfs4_try_mount()\n");
res = do_nfs4_mount(nfs4_create_server(mount_info), res = do_nfs4_mount(nfs4_create_server(mount_info),
flags, mount_info, flags, mount_info,
data->nfs_server.hostname, ctx->nfs_server.hostname,
data->nfs_server.export_path); ctx->nfs_server.export_path);
dfprintk(MOUNT, "<-- nfs4_try_mount() = %d%s\n", dfprintk(MOUNT, "<-- nfs4_try_mount() = %d%s\n",
PTR_ERR_OR_ZERO(res), PTR_ERR_OR_ZERO(res),

194
fs/nfs/super.c
View file

@ -726,12 +726,13 @@ bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
EXPORT_SYMBOL_GPL(nfs_auth_info_match); EXPORT_SYMBOL_GPL(nfs_auth_info_match);
/* /*
* Ensure that a specified authtype in args->auth_info is supported by * Ensure that a specified authtype in cfg->auth_info is supported by
* the server. Returns 0 and sets args->selected_flavor if it's ok, and * the server. Returns 0 and sets cfg->selected_flavor if it's ok, and
* -EACCES if not. * -EACCES if not.
*/ */
static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args, static int nfs_verify_authflavors(struct nfs_fs_context *cfg,
rpc_authflavor_t *server_authlist, unsigned int count) rpc_authflavor_t *server_authlist,
unsigned int count)
{ {
rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR; rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
bool found_auth_null = false; bool found_auth_null = false;
@ -752,7 +753,7 @@ static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
flavor = server_authlist[i]; flavor = server_authlist[i];
if (nfs_auth_info_match(&args->auth_info, flavor)) if (nfs_auth_info_match(&cfg->auth_info, flavor))
goto out; goto out;
if (flavor == RPC_AUTH_NULL) if (flavor == RPC_AUTH_NULL)
@ -760,7 +761,7 @@ static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
} }
if (found_auth_null) { if (found_auth_null) {
flavor = args->auth_info.flavors[0]; flavor = cfg->auth_info.flavors[0];
goto out; goto out;
} }
@ -769,8 +770,8 @@ static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
return -EACCES; return -EACCES;
out: out:
args->selected_flavor = flavor; cfg->selected_flavor = flavor;
dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->selected_flavor); dfprintk(MOUNT, "NFS: using auth flavor %u\n", cfg->selected_flavor);
return 0; return 0;
} }
@ -778,50 +779,50 @@ out:
* Use the remote server's MOUNT service to request the NFS file handle * Use the remote server's MOUNT service to request the NFS file handle
* corresponding to the provided path. * corresponding to the provided path.
*/ */
static int nfs_request_mount(struct nfs_parsed_mount_data *args, static int nfs_request_mount(struct nfs_fs_context *cfg,
struct nfs_fh *root_fh, struct nfs_fh *root_fh,
rpc_authflavor_t *server_authlist, rpc_authflavor_t *server_authlist,
unsigned int *server_authlist_len) unsigned int *server_authlist_len)
{ {
struct nfs_mount_request request = { struct nfs_mount_request request = {
.sap = (struct sockaddr *) .sap = (struct sockaddr *)
&args->mount_server.address, &cfg->mount_server.address,
.dirpath = args->nfs_server.export_path, .dirpath = cfg->nfs_server.export_path,
.protocol = args->mount_server.protocol, .protocol = cfg->mount_server.protocol,
.fh = root_fh, .fh = root_fh,
.noresvport = args->flags & NFS_MOUNT_NORESVPORT, .noresvport = cfg->flags & NFS_MOUNT_NORESVPORT,
.auth_flav_len = server_authlist_len, .auth_flav_len = server_authlist_len,
.auth_flavs = server_authlist, .auth_flavs = server_authlist,
.net = args->net, .net = cfg->net,
}; };
int status; int status;
if (args->mount_server.version == 0) { if (cfg->mount_server.version == 0) {
switch (args->version) { switch (cfg->version) {
default: default:
args->mount_server.version = NFS_MNT3_VERSION; cfg->mount_server.version = NFS_MNT3_VERSION;
break; break;
case 2: case 2:
args->mount_server.version = NFS_MNT_VERSION; cfg->mount_server.version = NFS_MNT_VERSION;
} }
} }
request.version = args->mount_server.version; request.version = cfg->mount_server.version;
if (args->mount_server.hostname) if (cfg->mount_server.hostname)
request.hostname = args->mount_server.hostname; request.hostname = cfg->mount_server.hostname;
else else
request.hostname = args->nfs_server.hostname; request.hostname = cfg->nfs_server.hostname;
/* /*
* Construct the mount server's address. * Construct the mount server's address.
*/ */
if (args->mount_server.address.ss_family == AF_UNSPEC) { if (cfg->mount_server.address.ss_family == AF_UNSPEC) {
memcpy(request.sap, &args->nfs_server.address, memcpy(request.sap, &cfg->nfs_server.address,
args->nfs_server.addrlen); cfg->nfs_server.addrlen);
args->mount_server.addrlen = args->nfs_server.addrlen; cfg->mount_server.addrlen = cfg->nfs_server.addrlen;
} }
request.salen = args->mount_server.addrlen; request.salen = cfg->mount_server.addrlen;
nfs_set_port(request.sap, &args->mount_server.port, 0); nfs_set_port(request.sap, &cfg->mount_server.port, 0);
/* /*
* Now ask the mount server to map our export path * Now ask the mount server to map our export path
@ -844,12 +845,12 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
bool tried_auth_unix = false; bool tried_auth_unix = false;
bool auth_null_in_list = false; bool auth_null_in_list = false;
struct nfs_server *server = ERR_PTR(-EACCES); struct nfs_server *server = ERR_PTR(-EACCES);
struct nfs_parsed_mount_data *args = mount_info->parsed; struct nfs_fs_context *ctx = mount_info->ctx;
rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS]; rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
unsigned int authlist_len = ARRAY_SIZE(authlist); unsigned int authlist_len = ARRAY_SIZE(authlist);
struct nfs_subversion *nfs_mod = mount_info->nfs_mod; struct nfs_subversion *nfs_mod = mount_info->nfs_mod;
status = nfs_request_mount(args, mount_info->mntfh, authlist, status = nfs_request_mount(ctx, mount_info->mntfh, authlist,
&authlist_len); &authlist_len);
if (status) if (status)
return ERR_PTR(status); return ERR_PTR(status);
@ -858,10 +859,10 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
* Was a sec= authflavor specified in the options? First, verify * Was a sec= authflavor specified in the options? First, verify
* whether the server supports it, and then just try to use it if so. * whether the server supports it, and then just try to use it if so.
*/ */
if (args->auth_info.flavor_len > 0) { if (ctx->auth_info.flavor_len > 0) {
status = nfs_verify_authflavors(args, authlist, authlist_len); status = nfs_verify_authflavors(ctx, authlist, authlist_len);
dfprintk(MOUNT, "NFS: using auth flavor %u\n", dfprintk(MOUNT, "NFS: using auth flavor %u\n",
args->selected_flavor); ctx->selected_flavor);
if (status) if (status)
return ERR_PTR(status); return ERR_PTR(status);
return nfs_mod->rpc_ops->create_server(mount_info); return nfs_mod->rpc_ops->create_server(mount_info);
@ -890,7 +891,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
/* Fallthrough */ /* Fallthrough */
} }
dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor); dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
args->selected_flavor = flavor; ctx->selected_flavor = flavor;
server = nfs_mod->rpc_ops->create_server(mount_info); server = nfs_mod->rpc_ops->create_server(mount_info);
if (!IS_ERR(server)) if (!IS_ERR(server))
return server; return server;
@ -906,7 +907,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
/* Last chance! Try AUTH_UNIX */ /* Last chance! Try AUTH_UNIX */
dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX); dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
args->selected_flavor = RPC_AUTH_UNIX; ctx->selected_flavor = RPC_AUTH_UNIX;
return nfs_mod->rpc_ops->create_server(mount_info); return nfs_mod->rpc_ops->create_server(mount_info);
} }
@ -916,7 +917,7 @@ struct dentry *nfs_try_mount(int flags, const char *dev_name,
struct nfs_mount_info *mount_info) struct nfs_mount_info *mount_info)
{ {
struct nfs_subversion *nfs_mod = mount_info->nfs_mod; struct nfs_subversion *nfs_mod = mount_info->nfs_mod;
if (mount_info->parsed->need_mount) if (mount_info->ctx->need_mount)
mount_info->server = nfs_try_mount_request(mount_info); mount_info->server = nfs_try_mount_request(mount_info);
else else
mount_info->server = nfs_mod->rpc_ops->create_server(mount_info); mount_info->server = nfs_mod->rpc_ops->create_server(mount_info);
@ -940,24 +941,24 @@ EXPORT_SYMBOL_GPL(nfs_try_mount);
static int static int
nfs_compare_remount_data(struct nfs_server *nfss, nfs_compare_remount_data(struct nfs_server *nfss,
struct nfs_parsed_mount_data *data) struct nfs_fs_context *ctx)
{ {
if ((data->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK || if ((ctx->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK ||
data->rsize != nfss->rsize || ctx->rsize != nfss->rsize ||
data->wsize != nfss->wsize || ctx->wsize != nfss->wsize ||
data->version != nfss->nfs_client->rpc_ops->version || ctx->version != nfss->nfs_client->rpc_ops->version ||
data->minorversion != nfss->nfs_client->cl_minorversion || ctx->minorversion != nfss->nfs_client->cl_minorversion ||
data->retrans != nfss->client->cl_timeout->to_retries || ctx->retrans != nfss->client->cl_timeout->to_retries ||
!nfs_auth_info_match(&data->auth_info, nfss->client->cl_auth->au_flavor) || !nfs_auth_info_match(&ctx->auth_info, nfss->client->cl_auth->au_flavor) ||
data->acregmin != nfss->acregmin / HZ || ctx->acregmin != nfss->acregmin / HZ ||
data->acregmax != nfss->acregmax / HZ || ctx->acregmax != nfss->acregmax / HZ ||
data->acdirmin != nfss->acdirmin / HZ || ctx->acdirmin != nfss->acdirmin / HZ ||
data->acdirmax != nfss->acdirmax / HZ || ctx->acdirmax != nfss->acdirmax / HZ ||
data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) || ctx->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
(data->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) || (ctx->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) ||
data->nfs_server.port != nfss->port || ctx->nfs_server.port != nfss->port ||
data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen || ctx->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
!rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address, !rpc_cmp_addr((struct sockaddr *)&ctx->nfs_server.address,
(struct sockaddr *)&nfss->nfs_client->cl_addr)) (struct sockaddr *)&nfss->nfs_client->cl_addr))
return -EINVAL; return -EINVAL;
@ -969,7 +970,7 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
{ {
int error; int error;
struct nfs_server *nfss = sb->s_fs_info; struct nfs_server *nfss = sb->s_fs_info;
struct nfs_parsed_mount_data *data; struct nfs_fs_context *ctx;
struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data; struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data; struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
u32 nfsvers = nfss->nfs_client->rpc_ops->version; u32 nfsvers = nfss->nfs_client->rpc_ops->version;
@ -987,32 +988,32 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
options->version <= 6)))) options->version <= 6))))
return 0; return 0;
data = nfs_alloc_parsed_mount_data(); ctx = nfs_alloc_parsed_mount_data();
if (data == NULL) if (ctx == NULL)
return -ENOMEM; return -ENOMEM;
/* fill out struct with values from existing mount */ /* fill out struct with values from existing mount */
data->flags = nfss->flags; ctx->flags = nfss->flags;
data->rsize = nfss->rsize; ctx->rsize = nfss->rsize;
data->wsize = nfss->wsize; ctx->wsize = nfss->wsize;
data->retrans = nfss->client->cl_timeout->to_retries; ctx->retrans = nfss->client->cl_timeout->to_retries;
data->selected_flavor = nfss->client->cl_auth->au_flavor; ctx->selected_flavor = nfss->client->cl_auth->au_flavor;
data->acregmin = nfss->acregmin / HZ; ctx->acregmin = nfss->acregmin / HZ;
data->acregmax = nfss->acregmax / HZ; ctx->acregmax = nfss->acregmax / HZ;
data->acdirmin = nfss->acdirmin / HZ; ctx->acdirmin = nfss->acdirmin / HZ;
data->acdirmax = nfss->acdirmax / HZ; ctx->acdirmax = nfss->acdirmax / HZ;
data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ; ctx->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
data->nfs_server.port = nfss->port; ctx->nfs_server.port = nfss->port;
data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen; ctx->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
data->version = nfsvers; ctx->version = nfsvers;
data->minorversion = nfss->nfs_client->cl_minorversion; ctx->minorversion = nfss->nfs_client->cl_minorversion;
data->net = current->nsproxy->net_ns; ctx->net = current->nsproxy->net_ns;
memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr, memcpy(&ctx->nfs_server.address, &nfss->nfs_client->cl_addr,
data->nfs_server.addrlen); ctx->nfs_server.addrlen);
/* overwrite those values with any that were specified */ /* overwrite those values with any that were specified */
error = -EINVAL; error = -EINVAL;
if (!nfs_parse_mount_options((char *)options, data)) if (!nfs_parse_mount_options((char *)options, ctx))
goto out; goto out;
/* /*
@ -1021,15 +1022,15 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
* will clear SB_SYNCHRONOUS if -o sync wasn't specified in the * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
* remount options, so we have to explicitly reset it. * remount options, so we have to explicitly reset it.
*/ */
if (data->flags & NFS_MOUNT_NOAC) if (ctx->flags & NFS_MOUNT_NOAC)
*flags |= SB_SYNCHRONOUS; *flags |= SB_SYNCHRONOUS;
/* compare new mount options with old ones */ /* compare new mount options with old ones */
error = nfs_compare_remount_data(nfss, data); error = nfs_compare_remount_data(nfss, ctx);
if (!error) if (!error)
error = security_sb_remount(sb, data->lsm_opts); error = security_sb_remount(sb, ctx->lsm_opts);
out: out:
nfs_free_parsed_mount_data(data); nfs_free_parsed_mount_data(ctx);
return error; return error;
} }
EXPORT_SYMBOL_GPL(nfs_remount); EXPORT_SYMBOL_GPL(nfs_remount);
@ -1039,15 +1040,15 @@ EXPORT_SYMBOL_GPL(nfs_remount);
*/ */
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_mount_info *mount_info)
{ {
struct nfs_parsed_mount_data *data = mount_info->parsed; struct nfs_fs_context *ctx = mount_info->ctx;
struct nfs_server *server = NFS_SB(sb); struct nfs_server *server = NFS_SB(sb);
sb->s_blocksize_bits = 0; sb->s_blocksize_bits = 0;
sb->s_blocksize = 0; sb->s_blocksize = 0;
sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr; sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
sb->s_op = server->nfs_client->cl_nfs_mod->sops; sb->s_op = server->nfs_client->cl_nfs_mod->sops;
if (data && data->bsize) if (ctx && ctx->bsize)
sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits); sb->s_blocksize = nfs_block_size(ctx->bsize, &sb->s_blocksize_bits);
if (server->nfs_client->rpc_ops->version != 2) { if (server->nfs_client->rpc_ops->version != 2) {
/* The VFS shouldn't apply the umask to mode bits. We will do /* The VFS shouldn't apply the umask to mode bits. We will do
@ -1208,7 +1209,7 @@ static int nfs_compare_super(struct super_block *sb, void *data)
#ifdef CONFIG_NFS_FSCACHE #ifdef CONFIG_NFS_FSCACHE
static void nfs_get_cache_cookie(struct super_block *sb, static void nfs_get_cache_cookie(struct super_block *sb,
struct nfs_parsed_mount_data *parsed, struct nfs_fs_context *ctx,
struct nfs_clone_mount *cloned) struct nfs_clone_mount *cloned)
{ {
struct nfs_server *nfss = NFS_SB(sb); struct nfs_server *nfss = NFS_SB(sb);
@ -1218,12 +1219,12 @@ static void nfs_get_cache_cookie(struct super_block *sb,
nfss->fscache_key = NULL; nfss->fscache_key = NULL;
nfss->fscache = NULL; nfss->fscache = NULL;
if (parsed) { if (ctx) {
if (!(parsed->options & NFS_OPTION_FSCACHE)) if (!(ctx->options & NFS_OPTION_FSCACHE))
return; return;
if (parsed->fscache_uniq) { if (ctx->fscache_uniq) {
uniq = parsed->fscache_uniq; uniq = ctx->fscache_uniq;
ulen = strlen(parsed->fscache_uniq); ulen = strlen(ctx->fscache_uniq);
} }
} else if (cloned) { } else if (cloned) {
struct nfs_server *mnt_s = NFS_SB(cloned->sb); struct nfs_server *mnt_s = NFS_SB(cloned->sb);
@ -1240,7 +1241,7 @@ static void nfs_get_cache_cookie(struct super_block *sb,
} }
#else #else
static void nfs_get_cache_cookie(struct super_block *sb, static void nfs_get_cache_cookie(struct super_block *sb,
struct nfs_parsed_mount_data *parsed, struct nfs_fs_context *parsed,
struct nfs_clone_mount *cloned) struct nfs_clone_mount *cloned)
{ {
} }
@ -1312,7 +1313,7 @@ static struct dentry *nfs_fs_mount_common(int flags, const char *dev_name,
s->s_blocksize_bits = bsize; s->s_blocksize_bits = bsize;
s->s_blocksize = 1U << bsize; s->s_blocksize = 1U << bsize;
} }
nfs_get_cache_cookie(s, mount_info->parsed, mount_info->cloned); nfs_get_cache_cookie(s, mount_info->ctx, mount_info->cloned);
if (!(server->flags & NFS_MOUNT_UNSHARED)) if (!(server->flags & NFS_MOUNT_UNSHARED))
s->s_iflags |= SB_I_MULTIROOT; s->s_iflags |= SB_I_MULTIROOT;
} }
@ -1333,7 +1334,7 @@ static struct dentry *nfs_fs_mount_common(int flags, const char *dev_name,
error = security_sb_clone_mnt_opts(mount_info->cloned->sb, s, kflags, error = security_sb_clone_mnt_opts(mount_info->cloned->sb, s, kflags,
&kflags_out); &kflags_out);
} else { } else {
error = security_sb_set_mnt_opts(s, mount_info->parsed->lsm_opts, error = security_sb_set_mnt_opts(s, mount_info->ctx->lsm_opts,
kflags, &kflags_out); kflags, &kflags_out);
} }
if (error) if (error)
@ -1370,21 +1371,22 @@ struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
struct nfs_subversion *nfs_mod; struct nfs_subversion *nfs_mod;
int error; int error;
mount_info.parsed = nfs_alloc_parsed_mount_data(); mount_info.ctx = nfs_alloc_parsed_mount_data();
mount_info.mntfh = nfs_alloc_fhandle(); mount_info.mntfh = nfs_alloc_fhandle();
if (mount_info.parsed == NULL || mount_info.mntfh == NULL) if (mount_info.ctx == NULL || mount_info.mntfh == NULL)
goto out; goto out;
/* Validate the mount data */ /* Validate the mount data */
error = nfs_validate_mount_data(fs_type, raw_data, mount_info.parsed, mount_info.mntfh, dev_name); error = nfs_validate_mount_data(fs_type, raw_data, mount_info.ctx, mount_info.mntfh, dev_name);
if (error == NFS_TEXT_DATA) if (error == NFS_TEXT_DATA)
error = nfs_validate_text_mount_data(raw_data, mount_info.parsed, dev_name); error = nfs_validate_text_mount_data(raw_data,
mount_info.ctx, dev_name);
if (error < 0) { if (error < 0) {
mntroot = ERR_PTR(error); mntroot = ERR_PTR(error);
goto out; goto out;
} }
nfs_mod = get_nfs_version(mount_info.parsed->version); nfs_mod = get_nfs_version(mount_info.ctx->version);
if (IS_ERR(nfs_mod)) { if (IS_ERR(nfs_mod)) {
mntroot = ERR_CAST(nfs_mod); mntroot = ERR_CAST(nfs_mod);
goto out; goto out;
@ -1395,7 +1397,7 @@ struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
put_nfs_version(nfs_mod); put_nfs_version(nfs_mod);
out: out:
nfs_free_parsed_mount_data(mount_info.parsed); nfs_free_parsed_mount_data(mount_info.ctx);
nfs_free_fhandle(mount_info.mntfh); nfs_free_fhandle(mount_info.mntfh);
return mntroot; return mntroot;
} }