mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

NFS/NFSD/SUNRPC: replace generic creds with 'struct cred'. 

SUNRPC has two sorts of credentials, both of which appear as
"struct rpc_cred".
There are "generic credentials" which are supplied by clients
such as NFS and passed in 'struct rpc_message' to indicate
which user should be used to authorize the request, and there
are low-level credentials such as AUTH_NULL, AUTH_UNIX, AUTH_GSS
which describe the credential to be sent over the wires.

This patch replaces all the generic credentials by 'struct cred'
pointers - the credential structure used throughout Linux.

For machine credentials, there is a special 'struct cred *' pointer
which is statically allocated and recognized where needed as
having a special meaning.  A look-up of a low-level cred will
map this to a machine credential.

Signed-off-by: NeilBrown <neilb@suse.com>
Acked-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>
This commit is contained in:
NeilBrown 2018-12-03 11:30:31 +11:00 committed by Anna Schumaker
parent 684f39b4cf
commit a52458b48a
33 changed files with 261 additions and 343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/lockd/clntproc.c
View File

@ -256,7 +256,7 @@ static int nlm_wait_on_grace(wait_queue_head_t *queue)
* Generic NLM call * Generic NLM call
*/ */
static int static int
nlmclnt_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc) nlmclnt_call(const struct cred *cred, struct nlm_rqst *req, u32 proc)
{ {
struct nlm_host *host = req->a_host; struct nlm_host *host = req->a_host;
struct rpc_clnt *clnt; struct rpc_clnt *clnt;
@ -401,7 +401,7 @@ int nlm_async_reply(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *t
* completion in order to be able to correctly track the lock * completion in order to be able to correctly track the lock
* state. * state.
*/ */
static int nlmclnt_async_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) static int nlmclnt_async_call(const struct cred *cred, struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
{ {
struct rpc_message msg = { struct rpc_message msg = {
.rpc_argp = &req->a_args, .rpc_argp = &req->a_args,
@ -510,7 +510,7 @@ static int do_vfs_lock(struct file_lock *fl)
static int static int
nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl)
{ {
struct rpc_cred *cred = nfs_file_cred(fl->fl_file); const struct cred *cred = nfs_file_cred(fl->fl_file);
struct nlm_host *host = req->a_host; struct nlm_host *host = req->a_host;
struct nlm_res *resp = &req->a_res; struct nlm_res *resp = &req->a_res;
struct nlm_wait *block = NULL; struct nlm_wait *block = NULL;

2
fs/nfs/blocklayout/blocklayout.c
View File

@ -584,7 +584,7 @@ static int decode_sector_number(__be32 **rp, sector_t *sp)
static struct nfs4_deviceid_node * static struct nfs4_deviceid_node *
bl_find_get_deviceid(struct nfs_server *server, bl_find_get_deviceid(struct nfs_server *server,
const struct nfs4_deviceid *id, struct rpc_cred *cred, const struct nfs4_deviceid *id, const struct cred *cred,
gfp_t gfp_mask) gfp_t gfp_mask)
{ {
struct nfs4_deviceid_node *node; struct nfs4_deviceid_node *node;

28
fs/nfs/delegation.c
View File

@ -26,10 +26,8 @@
static void nfs_free_delegation(struct nfs_delegation *delegation) static void nfs_free_delegation(struct nfs_delegation *delegation)
{ {
if (delegation->cred) { put_cred(delegation->cred);
put_rpccred(delegation->cred); delegation->cred = NULL;
delegation->cred = NULL;
}
kfree_rcu(delegation, rcu); kfree_rcu(delegation, rcu);
} }
@ -178,13 +176,13 @@ again:
* @pagemod_limit: write delegation "space_limit" * @pagemod_limit: write delegation "space_limit"
* *
*/ */
void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
fmode_t type, fmode_t type,
const nfs4_stateid *stateid, const nfs4_stateid *stateid,
unsigned long pagemod_limit) unsigned long pagemod_limit)
{ {
struct nfs_delegation *delegation; struct nfs_delegation *delegation;
struct rpc_cred *oldcred = NULL; const struct cred *oldcred = NULL;
rcu_read_lock(); rcu_read_lock();
delegation = rcu_dereference(NFS_I(inode)->delegation); delegation = rcu_dereference(NFS_I(inode)->delegation);
@ -195,12 +193,12 @@ void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
delegation->type = type; delegation->type = type;
delegation->pagemod_limit = pagemod_limit; delegation->pagemod_limit = pagemod_limit;
oldcred = delegation->cred; oldcred = delegation->cred;
delegation->cred = get_rpccred(cred); delegation->cred = get_cred(cred);
clear_bit(NFS_DELEGATION_NEED_RECLAIM, clear_bit(NFS_DELEGATION_NEED_RECLAIM,
&delegation->flags); &delegation->flags);
spin_unlock(&delegation->lock); spin_unlock(&delegation->lock);
rcu_read_unlock(); rcu_read_unlock();
put_rpccred(oldcred); put_cred(oldcred);
trace_nfs4_reclaim_delegation(inode, type); trace_nfs4_reclaim_delegation(inode, type);
return; return;
} }
@ -341,7 +339,7 @@ nfs_update_inplace_delegation(struct nfs_delegation *delegation,
* *
* Returns zero on success, or a negative errno value. * Returns zero on success, or a negative errno value.
*/ */
int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
fmode_t type, fmode_t type,
const nfs4_stateid *stateid, const nfs4_stateid *stateid,
unsigned long pagemod_limit) unsigned long pagemod_limit)
@ -360,7 +358,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred,
delegation->type = type; delegation->type = type;
delegation->pagemod_limit = pagemod_limit; delegation->pagemod_limit = pagemod_limit;
delegation->change_attr = inode_peek_iversion_raw(inode); delegation->change_attr = inode_peek_iversion_raw(inode);
delegation->cred = get_rpccred(cred); delegation->cred = get_cred(cred);
delegation->inode = inode; delegation->inode = inode;
delegation->flags = 1<<NFS_DELEGATION_REFERENCED; delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
spin_lock_init(&delegation->lock); spin_lock_init(&delegation->lock);
@ -1047,7 +1045,7 @@ void nfs_reap_expired_delegations(struct nfs_client *clp)
struct nfs_delegation *delegation; struct nfs_delegation *delegation;
struct nfs_server *server; struct nfs_server *server;
struct inode *inode; struct inode *inode;
struct rpc_cred *cred; const struct cred *cred;
nfs4_stateid stateid; nfs4_stateid stateid;
restart: restart:
@ -1069,7 +1067,7 @@ restart:
nfs_sb_deactive(server->super); nfs_sb_deactive(server->super);
goto restart; goto restart;
} }
cred = get_rpccred_rcu(delegation->cred); cred = get_cred_rcu(delegation->cred);
nfs4_stateid_copy(&stateid, &delegation->stateid); nfs4_stateid_copy(&stateid, &delegation->stateid);
clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
rcu_read_unlock(); rcu_read_unlock();
@ -1078,7 +1076,7 @@ restart:
nfs_revoke_delegation(inode, &stateid); nfs_revoke_delegation(inode, &stateid);
nfs_inode_find_state_and_recover(inode, &stateid); nfs_inode_find_state_and_recover(inode, &stateid);
} }
put_rpccred(cred); put_cred(cred);
if (nfs4_server_rebooted(clp)) { if (nfs4_server_rebooted(clp)) {
nfs_inode_mark_test_expired_delegation(server,inode); nfs_inode_mark_test_expired_delegation(server,inode);
iput(inode); iput(inode);
@ -1173,7 +1171,7 @@ out:
* otherwise "false" is returned. * otherwise "false" is returned.
*/ */
bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags, bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
nfs4_stateid *dst, struct rpc_cred **cred) nfs4_stateid *dst, const struct cred **cred)
{ {
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
struct nfs_delegation *delegation; struct nfs_delegation *delegation;
@ -1187,7 +1185,7 @@ bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
nfs4_stateid_copy(dst, &delegation->stateid); nfs4_stateid_copy(dst, &delegation->stateid);
nfs_mark_delegation_referenced(delegation); nfs_mark_delegation_referenced(delegation);
if (cred) if (cred)
*cred = get_rpccred(delegation->cred); *cred = get_cred(delegation->cred);
} }
rcu_read_unlock(); rcu_read_unlock();
return ret; return ret;

10
fs/nfs/delegation.h
View File

@ -15,7 +15,7 @@
*/ */
struct nfs_delegation { struct nfs_delegation {
struct list_head super_list; struct list_head super_list;
struct rpc_cred *cred; const struct cred *cred;
struct inode *inode; struct inode *inode;
nfs4_stateid stateid; nfs4_stateid stateid;
fmode_t type; fmode_t type;
@ -36,9 +36,9 @@ enum {
NFS_DELEGATION_TEST_EXPIRED, NFS_DELEGATION_TEST_EXPIRED,
}; };
int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
fmode_t type, const nfs4_stateid *stateid, unsigned long pagemod_limit); fmode_t type, const nfs4_stateid *stateid, unsigned long pagemod_limit);
void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
fmode_t type, const nfs4_stateid *stateid, unsigned long pagemod_limit); fmode_t type, const nfs4_stateid *stateid, unsigned long pagemod_limit);
int nfs4_inode_return_delegation(struct inode *inode); int nfs4_inode_return_delegation(struct inode *inode);
int nfs_async_inode_return_delegation(struct inode *inode, const nfs4_stateid *stateid); int nfs_async_inode_return_delegation(struct inode *inode, const nfs4_stateid *stateid);
@ -60,10 +60,10 @@ void nfs_mark_test_expired_all_delegations(struct nfs_client *clp);
void nfs_reap_expired_delegations(struct nfs_client *clp); void nfs_reap_expired_delegations(struct nfs_client *clp);
/* NFSv4 delegation-related procedures */ /* NFSv4 delegation-related procedures */
int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync); int nfs4_proc_delegreturn(struct inode *inode, const struct cred *cred, const nfs4_stateid *stateid, int issync);
int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid, fmode_t type); int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid, fmode_t type);
int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid); int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid);
bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags, nfs4_stateid *dst, struct rpc_cred **cred); bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags, nfs4_stateid *dst, const struct cred **cred);
bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode); bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode);
void nfs_mark_delegation_referenced(struct nfs_delegation *delegation); void nfs_mark_delegation_referenced(struct nfs_delegation *delegation);

33
fs/nfs/flexfilelayout/flexfilelayout.c
View File

@ -224,16 +224,14 @@ static struct nfs4_ff_layout_mirror *ff_layout_alloc_mirror(gfp_t gfp_flags)
static void ff_layout_free_mirror(struct nfs4_ff_layout_mirror *mirror) static void ff_layout_free_mirror(struct nfs4_ff_layout_mirror *mirror)
{ {
struct rpc_cred *cred; const struct cred *cred;
ff_layout_remove_mirror(mirror); ff_layout_remove_mirror(mirror);
kfree(mirror->fh_versions); kfree(mirror->fh_versions);
cred = rcu_access_pointer(mirror->ro_cred); cred = rcu_access_pointer(mirror->ro_cred);
if (cred) put_cred(cred);
put_rpccred(cred);
cred = rcu_access_pointer(mirror->rw_cred); cred = rcu_access_pointer(mirror->rw_cred);
if (cred) put_cred(cred);
put_rpccred(cred);
nfs4_ff_layout_put_deviceid(mirror->mirror_ds); nfs4_ff_layout_put_deviceid(mirror->mirror_ds);
kfree(mirror); kfree(mirror);
} }
@ -411,9 +409,8 @@ ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh,
for (i = 0; i < fls->mirror_array_cnt; i++) { for (i = 0; i < fls->mirror_array_cnt; i++) {
struct nfs4_ff_layout_mirror *mirror; struct nfs4_ff_layout_mirror *mirror;
struct auth_cred acred = {};
struct rpc_cred __rcu *cred;
struct cred *kcred; struct cred *kcred;
const struct cred *cred;
kuid_t uid; kuid_t uid;
kgid_t gid; kgid_t gid;
u32 ds_count, fh_count, id; u32 ds_count, fh_count, id;
@ -504,15 +501,7 @@ ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh,
goto out_err_free; goto out_err_free;
kcred->fsuid = uid; kcred->fsuid = uid;
kcred->fsgid = gid; kcred->fsgid = gid;
acred.cred = kcred; cred = kcred;
/* find the cred for it */
rcu_assign_pointer(cred, rpc_lookup_generic_cred(&acred, 0, gfp_flags));
put_cred(kcred);
if (IS_ERR(cred)) {
rc = PTR_ERR(cred);
goto out_err_free;
}
if (lgr->range.iomode == IOMODE_READ) if (lgr->range.iomode == IOMODE_READ)
rcu_assign_pointer(fls->mirror_array[i]->ro_cred, cred); rcu_assign_pointer(fls->mirror_array[i]->ro_cred, cred);
@ -1714,7 +1703,7 @@ ff_layout_read_pagelist(struct nfs_pgio_header *hdr)
struct pnfs_layout_segment *lseg = hdr->lseg; struct pnfs_layout_segment *lseg = hdr->lseg;
struct nfs4_pnfs_ds *ds; struct nfs4_pnfs_ds *ds;
struct rpc_clnt *ds_clnt; struct rpc_clnt *ds_clnt;
struct rpc_cred *ds_cred; const struct cred *ds_cred;
loff_t offset = hdr->args.offset; loff_t offset = hdr->args.offset;
u32 idx = hdr->pgio_mirror_idx; u32 idx = hdr->pgio_mirror_idx;
int vers; int vers;
@ -1765,7 +1754,7 @@ ff_layout_read_pagelist(struct nfs_pgio_header *hdr)
vers == 3 ? &ff_layout_read_call_ops_v3 : vers == 3 ? &ff_layout_read_call_ops_v3 :
&ff_layout_read_call_ops_v4, &ff_layout_read_call_ops_v4,
0, RPC_TASK_SOFTCONN); 0, RPC_TASK_SOFTCONN);
put_rpccred(ds_cred); put_cred(ds_cred);
return PNFS_ATTEMPTED; return PNFS_ATTEMPTED;
out_failed: out_failed:
@ -1781,7 +1770,7 @@ ff_layout_write_pagelist(struct nfs_pgio_header *hdr, int sync)
struct pnfs_layout_segment *lseg = hdr->lseg; struct pnfs_layout_segment *lseg = hdr->lseg;
struct nfs4_pnfs_ds *ds; struct nfs4_pnfs_ds *ds;
struct rpc_clnt *ds_clnt; struct rpc_clnt *ds_clnt;
struct rpc_cred *ds_cred; const struct cred *ds_cred;
loff_t offset = hdr->args.offset; loff_t offset = hdr->args.offset;
int vers; int vers;
struct nfs_fh *fh; struct nfs_fh *fh;
@ -1830,7 +1819,7 @@ ff_layout_write_pagelist(struct nfs_pgio_header *hdr, int sync)
vers == 3 ? &ff_layout_write_call_ops_v3 : vers == 3 ? &ff_layout_write_call_ops_v3 :
&ff_layout_write_call_ops_v4, &ff_layout_write_call_ops_v4,
sync, RPC_TASK_SOFTCONN); sync, RPC_TASK_SOFTCONN);
put_rpccred(ds_cred); put_cred(ds_cred);
return PNFS_ATTEMPTED; return PNFS_ATTEMPTED;
out_failed: out_failed:
@ -1860,7 +1849,7 @@ static int ff_layout_initiate_commit(struct nfs_commit_data *data, int how)
struct pnfs_layout_segment *lseg = data->lseg; struct pnfs_layout_segment *lseg = data->lseg;
struct nfs4_pnfs_ds *ds; struct nfs4_pnfs_ds *ds;
struct rpc_clnt *ds_clnt; struct rpc_clnt *ds_clnt;
struct rpc_cred *ds_cred; const struct cred *ds_cred;
u32 idx; u32 idx;
int vers, ret; int vers, ret;
struct nfs_fh *fh; struct nfs_fh *fh;
@ -1900,7 +1889,7 @@ static int ff_layout_initiate_commit(struct nfs_commit_data *data, int how)
vers == 3 ? &ff_layout_commit_call_ops_v3 : vers == 3 ? &ff_layout_commit_call_ops_v3 :
&ff_layout_commit_call_ops_v4, &ff_layout_commit_call_ops_v4,
how, RPC_TASK_SOFTCONN); how, RPC_TASK_SOFTCONN);
put_rpccred(ds_cred); put_cred(ds_cred);
return ret; return ret;
out_err: out_err:
pnfs_generic_prepare_to_resend_writes(data); pnfs_generic_prepare_to_resend_writes(data);

8
fs/nfs/flexfilelayout/flexfilelayout.h
View File

@ -81,8 +81,8 @@ struct nfs4_ff_layout_mirror {
u32 fh_versions_cnt; u32 fh_versions_cnt;
struct nfs_fh *fh_versions; struct nfs_fh *fh_versions;
nfs4_stateid stateid; nfs4_stateid stateid;
struct rpc_cred __rcu *ro_cred; const struct cred __rcu *ro_cred;
struct rpc_cred __rcu *rw_cred; const struct cred __rcu *rw_cred;
refcount_t ref; refcount_t ref;
spinlock_t lock; spinlock_t lock;
unsigned long flags; unsigned long flags;
@ -229,8 +229,8 @@ nfs4_ff_find_or_create_ds_client(struct pnfs_layout_segment *lseg,
u32 ds_idx, u32 ds_idx,
struct nfs_client *ds_clp, struct nfs_client *ds_clp,
struct inode *inode); struct inode *inode);
struct rpc_cred *ff_layout_get_ds_cred(struct pnfs_layout_segment *lseg, const struct cred *ff_layout_get_ds_cred(struct pnfs_layout_segment *lseg,
u32 ds_idx, struct rpc_cred *mdscred); u32 ds_idx, const struct cred *mdscred);
bool ff_layout_avoid_mds_available_ds(struct pnfs_layout_segment *lseg); bool ff_layout_avoid_mds_available_ds(struct pnfs_layout_segment *lseg);
bool ff_layout_avoid_read_on_rw(struct pnfs_layout_segment *lseg); bool ff_layout_avoid_read_on_rw(struct pnfs_layout_segment *lseg);

16
fs/nfs/flexfilelayout/flexfilelayoutdev.c
View File

@ -330,10 +330,10 @@ int ff_layout_track_ds_error(struct nfs4_flexfile_layout *flo,
return 0; return 0;
} }
static struct rpc_cred * static const struct cred *
ff_layout_get_mirror_cred(struct nfs4_ff_layout_mirror *mirror, u32 iomode) ff_layout_get_mirror_cred(struct nfs4_ff_layout_mirror *mirror, u32 iomode)
{ {
struct rpc_cred *cred, __rcu **pcred; const struct cred *cred, __rcu **pcred;
if (iomode == IOMODE_READ) if (iomode == IOMODE_READ)
pcred = &mirror->ro_cred; pcred = &mirror->ro_cred;
@ -346,7 +346,7 @@ ff_layout_get_mirror_cred(struct nfs4_ff_layout_mirror *mirror, u32 iomode)
if (!cred) if (!cred)
break; break;
cred = get_rpccred_rcu(cred); cred = get_cred_rcu(cred);
} while(!cred); } while(!cred);
rcu_read_unlock(); rcu_read_unlock();
return cred; return cred;
@ -465,19 +465,19 @@ out:
return ds; return ds;
} }
struct rpc_cred * const struct cred *
ff_layout_get_ds_cred(struct pnfs_layout_segment *lseg, u32 ds_idx, ff_layout_get_ds_cred(struct pnfs_layout_segment *lseg, u32 ds_idx,
struct rpc_cred *mdscred) const struct cred *mdscred)
{ {
struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx); struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
struct rpc_cred *cred; const struct cred *cred;
if (mirror && !mirror->mirror_ds->ds_versions[0].tightly_coupled) { if (mirror && !mirror->mirror_ds->ds_versions[0].tightly_coupled) {
cred = ff_layout_get_mirror_cred(mirror, lseg->pls_range.iomode); cred = ff_layout_get_mirror_cred(mirror, lseg->pls_range.iomode);
if (!cred) if (!cred)
cred = get_rpccred(mdscred); cred = get_cred(mdscred);
} else { } else {
cred = get_rpccred(mdscred); cred = get_cred(mdscred);
} }
return cred; return cred;
} }

11
fs/nfs/inode.c
View File

@ -950,13 +950,11 @@ struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry,
struct file *filp) struct file *filp)
{ {
struct nfs_open_context *ctx; struct nfs_open_context *ctx;
struct rpc_cred *cred = rpc_lookup_cred(); const struct cred *cred = get_current_cred();
if (IS_ERR(cred))
return ERR_CAST(cred);
ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx) { if (!ctx) {
put_rpccred(cred); put_cred(cred);
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
nfs_sb_active(dentry->d_sb); nfs_sb_active(dentry->d_sb);
@ -998,8 +996,7 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
} }
if (inode != NULL) if (inode != NULL)
NFS_PROTO(inode)->close_context(ctx, is_sync); NFS_PROTO(inode)->close_context(ctx, is_sync);
if (ctx->cred != NULL) put_cred(ctx->cred);
put_rpccred(ctx->cred);
dput(ctx->dentry); dput(ctx->dentry);
nfs_sb_deactive(sb); nfs_sb_deactive(sb);
put_rpccred(ctx->ll_cred); put_rpccred(ctx->ll_cred);
@ -1044,7 +1041,7 @@ EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
/* /*
* Given an inode, search for an open context with the desired characteristics * Given an inode, search for an open context with the desired characteristics
*/ */
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode) struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
{ {
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
struct nfs_open_context *pos, *ctx = NULL; struct nfs_open_context *pos, *ctx = NULL;

8
fs/nfs/internal.h
View File

@ -254,7 +254,7 @@ struct nfs_pgio_header *nfs_pgio_header_alloc(const struct nfs_rw_ops *);
void nfs_pgio_header_free(struct nfs_pgio_header *); void nfs_pgio_header_free(struct nfs_pgio_header *);
int nfs_generic_pgio(struct nfs_pageio_descriptor *, struct nfs_pgio_header *); int nfs_generic_pgio(struct nfs_pageio_descriptor *, struct nfs_pgio_header *);
int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr, int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr,
struct rpc_cred *cred, const struct nfs_rpc_ops *rpc_ops, const struct cred *cred, const struct nfs_rpc_ops *rpc_ops,
const struct rpc_call_ops *call_ops, int how, int flags); const struct rpc_call_ops *call_ops, int how, int flags);
void nfs_free_request(struct nfs_page *req); void nfs_free_request(struct nfs_page *req);
struct nfs_pgio_mirror * struct nfs_pgio_mirror *
@ -269,7 +269,7 @@ static inline bool nfs_pgio_has_mirroring(struct nfs_pageio_descriptor *desc)
static inline bool nfs_match_open_context(const struct nfs_open_context *ctx1, static inline bool nfs_match_open_context(const struct nfs_open_context *ctx1,
const struct nfs_open_context *ctx2) const struct nfs_open_context *ctx2)
{ {
return ctx1->cred == ctx2->cred && ctx1->state == ctx2->state; return cred_fscmp(ctx1->cred, ctx2->cred) == 0 && ctx1->state == ctx2->state;
} }
/* nfs2xdr.c */ /* nfs2xdr.c */
@ -564,10 +564,10 @@ extern struct nfs_client *nfs4_init_client(struct nfs_client *clp,
const struct nfs_client_initdata *); const struct nfs_client_initdata *);
extern int nfs40_walk_client_list(struct nfs_client *clp, extern int nfs40_walk_client_list(struct nfs_client *clp,
struct nfs_client **result, struct nfs_client **result,
struct rpc_cred *cred); const struct cred *cred);
extern int nfs41_walk_client_list(struct nfs_client *clp, extern int nfs41_walk_client_list(struct nfs_client *clp,
struct nfs_client **result, struct nfs_client **result,
struct rpc_cred *cred); const struct cred *cred);
extern int nfs4_test_session_trunk(struct rpc_clnt *, extern int nfs4_test_session_trunk(struct rpc_clnt *,
struct rpc_xprt *, struct rpc_xprt *,
void *); void *);

18
fs/nfs/nfs3proc.c
View File

@ -195,20 +195,15 @@ static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
.access = entry->mask, .access = entry->mask,
}; };
struct nfs3_accessres res; struct nfs3_accessres res;
struct auth_cred acred = {
.cred = entry->cred,
};
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS], .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS],
.rpc_argp = &arg, .rpc_argp = &arg,
.rpc_resp = &res, .rpc_resp = &res,
.rpc_cred = rpc_lookup_generic_cred(&acred, 0, GFP_NOFS), .rpc_cred = entry->cred,
}; };
int status = -ENOMEM; int status = -ENOMEM;
dprintk("NFS call access\n"); dprintk("NFS call access\n");
if (!msg.rpc_cred)
goto out;
res.fattr = nfs_alloc_fattr(); res.fattr = nfs_alloc_fattr();
if (res.fattr == NULL) if (res.fattr == NULL)
goto out; goto out;
@ -219,8 +214,6 @@ static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
nfs_access_set_mask(entry, res.access); nfs_access_set_mask(entry, res.access);
nfs_free_fattr(res.fattr); nfs_free_fattr(res.fattr);
out: out:
if (msg.rpc_cred)
put_rpccred(msg.rpc_cred);
dprintk("NFS reply access: %d\n", status); dprintk("NFS reply access: %d\n", status);
return status; return status;
} }
@ -631,15 +624,11 @@ nfs3_proc_readdir(struct dentry *dentry, const struct cred *cred,
.verf = verf, .verf = verf,
.plus = plus .plus = plus
}; };
struct auth_cred acred = {
.cred = cred,
};
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR],
.rpc_argp = &arg, .rpc_argp = &arg,
.rpc_resp = &res, .rpc_resp = &res,
.rpc_cred = rpc_lookup_generic_cred(&acred, .rpc_cred = cred,
0, GFP_NOFS),
}; };
int status = -ENOMEM; int status = -ENOMEM;
@ -649,8 +638,6 @@ nfs3_proc_readdir(struct dentry *dentry, const struct cred *cred,
dprintk("NFS call readdir%s %d\n", dprintk("NFS call readdir%s %d\n",
plus? "plus" : "", (unsigned int) cookie); plus? "plus" : "", (unsigned int) cookie);
if (!msg.rpc_cred)
return -ENOMEM;
res.dir_attr = nfs_alloc_fattr(); res.dir_attr = nfs_alloc_fattr();
if (res.dir_attr == NULL) if (res.dir_attr == NULL)
goto out; goto out;
@ -662,7 +649,6 @@ nfs3_proc_readdir(struct dentry *dentry, const struct cred *cred,
nfs_free_fattr(res.dir_attr); nfs_free_fattr(res.dir_attr);
out: out:
put_rpccred(msg.rpc_cred);
dprintk("NFS reply readdir%s: %d\n", dprintk("NFS reply readdir%s: %d\n",
plus? "plus" : "", status); plus? "plus" : "", status);
return status; return status;

56
fs/nfs/nfs4_fs.h
View File

@ -62,7 +62,7 @@ struct nfs4_minor_version_ops {
void (*free_lock_state)(struct nfs_server *, void (*free_lock_state)(struct nfs_server *,
struct nfs4_lock_state *); struct nfs4_lock_state *);
int (*test_and_free_expired)(struct nfs_server *, int (*test_and_free_expired)(struct nfs_server *,
nfs4_stateid *, struct rpc_cred *); nfs4_stateid *, const struct cred *);
struct nfs_seqid * struct nfs_seqid *
(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); (*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
int (*session_trunk)(struct rpc_clnt *, struct rpc_xprt *, void *); int (*session_trunk)(struct rpc_clnt *, struct rpc_xprt *, void *);
@ -107,7 +107,7 @@ struct nfs4_state_owner {
unsigned long so_expires; unsigned long so_expires;
struct rb_node so_server_node; struct rb_node so_server_node;
struct rpc_cred *so_cred; /* Associated cred */ const struct cred *so_cred; /* Associated cred */
spinlock_t so_lock; spinlock_t so_lock;
atomic_t so_count; atomic_t so_count;
@ -212,10 +212,10 @@ struct nfs4_state_recovery_ops {
int state_flag_bit; int state_flag_bit;
int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *); int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
int (*recover_lock)(struct nfs4_state *, struct file_lock *); int (*recover_lock)(struct nfs4_state *, struct file_lock *);
int (*establish_clid)(struct nfs_client *, struct rpc_cred *); int (*establish_clid)(struct nfs_client *, const struct cred *);
int (*reclaim_complete)(struct nfs_client *, struct rpc_cred *); int (*reclaim_complete)(struct nfs_client *, const struct cred *);
int (*detect_trunking)(struct nfs_client *, struct nfs_client **, int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
struct rpc_cred *); const struct cred *);
}; };
struct nfs4_opendata { struct nfs4_opendata {
@ -245,19 +245,19 @@ struct nfs4_opendata {
struct nfs4_add_xprt_data { struct nfs4_add_xprt_data {
struct nfs_client *clp; struct nfs_client *clp;
struct rpc_cred *cred; const struct cred *cred;
}; };
struct nfs4_state_maintenance_ops { struct nfs4_state_maintenance_ops {
int (*sched_state_renewal)(struct nfs_client *, struct rpc_cred *, unsigned); int (*sched_state_renewal)(struct nfs_client *, const struct cred *, unsigned);
struct rpc_cred * (*get_state_renewal_cred)(struct nfs_client *); const struct cred * (*get_state_renewal_cred)(struct nfs_client *);
int (*renew_lease)(struct nfs_client *, struct rpc_cred *); int (*renew_lease)(struct nfs_client *, const struct cred *);
}; };
struct nfs4_mig_recovery_ops { struct nfs4_mig_recovery_ops {
int (*get_locations)(struct inode *, struct nfs4_fs_locations *, int (*get_locations)(struct inode *, struct nfs4_fs_locations *,
struct page *, struct rpc_cred *); struct page *, const struct cred *);
int (*fsid_present)(struct inode *, struct rpc_cred *); int (*fsid_present)(struct inode *, const struct cred *);
}; };
extern const struct dentry_operations nfs4_dentry_operations; extern const struct dentry_operations nfs4_dentry_operations;
@ -286,21 +286,21 @@ extern int nfs4_call_sync(struct rpc_clnt *, struct nfs_server *,
struct rpc_message *, struct nfs4_sequence_args *, struct rpc_message *, struct nfs4_sequence_args *,
struct nfs4_sequence_res *, int); struct nfs4_sequence_res *, int);
extern void nfs4_init_sequence(struct nfs4_sequence_args *, struct nfs4_sequence_res *, int, int); extern void nfs4_init_sequence(struct nfs4_sequence_args *, struct nfs4_sequence_res *, int, int);
extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, struct rpc_cred *, struct nfs4_setclientid_res *); extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, const struct cred *, struct nfs4_setclientid_res *);
extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, struct rpc_cred *); extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, const struct cred *);
extern int nfs4_proc_get_rootfh(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *, bool); extern int nfs4_proc_get_rootfh(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *, bool);
extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, struct rpc_cred *cred); extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, const struct cred *cred);
extern int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred); extern int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred);
extern int nfs4_destroy_clientid(struct nfs_client *clp); extern int nfs4_destroy_clientid(struct nfs_client *clp);
extern int nfs4_init_clientid(struct nfs_client *, struct rpc_cred *); extern int nfs4_init_clientid(struct nfs_client *, const struct cred *);
extern int nfs41_init_clientid(struct nfs_client *, struct rpc_cred *); extern int nfs41_init_clientid(struct nfs_client *, const struct cred *);
extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait); extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait);
extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle); extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *, extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *,
struct nfs4_fs_locations *, struct page *); struct nfs4_fs_locations *, struct page *);
extern int nfs4_proc_get_locations(struct inode *, struct nfs4_fs_locations *, extern int nfs4_proc_get_locations(struct inode *, struct nfs4_fs_locations *,
struct page *page, struct rpc_cred *); struct page *page, const struct cred *);
extern int nfs4_proc_fsid_present(struct inode *, struct rpc_cred *); extern int nfs4_proc_fsid_present(struct inode *, const struct cred *);
extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, const struct qstr *, extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, const struct qstr *,
struct nfs_fh *, struct nfs_fattr *); struct nfs_fh *, struct nfs_fattr *);
extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *); extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
@ -312,8 +312,8 @@ extern int nfs4_set_rw_stateid(nfs4_stateid *stateid,
#if defined(CONFIG_NFS_V4_1) #if defined(CONFIG_NFS_V4_1)
extern int nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *); extern int nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *);
extern int nfs4_proc_create_session(struct nfs_client *, struct rpc_cred *); extern int nfs4_proc_create_session(struct nfs_client *, const struct cred *);
extern int nfs4_proc_destroy_session(struct nfs4_session *, struct rpc_cred *); extern int nfs4_proc_destroy_session(struct nfs4_session *, const struct cred *);
extern int nfs4_proc_get_lease_time(struct nfs_client *clp, extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
struct nfs_fsinfo *fsinfo); struct nfs_fsinfo *fsinfo);
extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
@ -443,16 +443,16 @@ extern void nfs4_set_lease_period(struct nfs_client *clp,
/* nfs4state.c */ /* nfs4state.c */
struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp); const struct cred *nfs4_get_clid_cred(struct nfs_client *clp);
struct rpc_cred *nfs4_get_machine_cred(struct nfs_client *clp); const struct cred *nfs4_get_machine_cred(struct nfs_client *clp);
struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp); const struct cred *nfs4_get_renew_cred(struct nfs_client *clp);
int nfs4_discover_server_trunking(struct nfs_client *clp, int nfs4_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **); struct nfs_client **);
int nfs40_discover_server_trunking(struct nfs_client *clp, int nfs40_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **, struct rpc_cred *); struct nfs_client **, const struct cred *);
#if defined(CONFIG_NFS_V4_1) #if defined(CONFIG_NFS_V4_1)
int nfs41_discover_server_trunking(struct nfs_client *clp, int nfs41_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **, struct rpc_cred *); struct nfs_client **, const struct cred *);
extern void nfs4_schedule_session_recovery(struct nfs4_session *, int); extern void nfs4_schedule_session_recovery(struct nfs4_session *, int);
extern void nfs41_notify_server(struct nfs_client *); extern void nfs41_notify_server(struct nfs_client *);
#else #else
@ -461,7 +461,7 @@ static inline void nfs4_schedule_session_recovery(struct nfs4_session *session,
} }
#endif /* CONFIG_NFS_V4_1 */ #endif /* CONFIG_NFS_V4_1 */
extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *, gfp_t); extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, const struct cred *, gfp_t);
extern void nfs4_put_state_owner(struct nfs4_state_owner *); extern void nfs4_put_state_owner(struct nfs4_state_owner *);
extern void nfs4_purge_state_owners(struct nfs_server *); extern void nfs4_purge_state_owners(struct nfs_server *);
extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *); extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
@ -487,7 +487,7 @@ extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl); extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
extern int nfs4_select_rw_stateid(struct nfs4_state *, fmode_t, extern int nfs4_select_rw_stateid(struct nfs4_state *, fmode_t,
const struct nfs_lock_context *, nfs4_stateid *, const struct nfs_lock_context *, nfs4_stateid *,
struct rpc_cred **); const struct cred **);
extern bool nfs4_refresh_open_stateid(nfs4_stateid *dst, extern bool nfs4_refresh_open_stateid(nfs4_stateid *dst,
struct nfs4_state *state); struct nfs4_state *state);
extern bool nfs4_copy_open_stateid(nfs4_stateid *dst, extern bool nfs4_copy_open_stateid(nfs4_stateid *dst,

4
fs/nfs/nfs4client.c
View File

@ -545,7 +545,7 @@ static int nfs4_match_client(struct nfs_client *pos, struct nfs_client *new,
*/ */
int nfs40_walk_client_list(struct nfs_client *new, int nfs40_walk_client_list(struct nfs_client *new,
struct nfs_client **result, struct nfs_client **result,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id); struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
struct nfs_client *pos, *prev = NULL; struct nfs_client *pos, *prev = NULL;
@ -711,7 +711,7 @@ out_err:
*/ */
int nfs41_walk_client_list(struct nfs_client *new, int nfs41_walk_client_list(struct nfs_client *new,
struct nfs_client **result, struct nfs_client **result,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id); struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
struct nfs_client *pos, *prev = NULL; struct nfs_client *pos, *prev = NULL;

167
fs/nfs/nfs4proc.c
View File

@ -93,19 +93,19 @@ static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinf
static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr); static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label, struct inode *inode); static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label, struct inode *inode);
static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label, struct inode *inode); static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label, struct inode *inode);
static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, static int nfs4_do_setattr(struct inode *inode, const struct cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr, struct nfs_fattr *fattr, struct iattr *sattr,
struct nfs_open_context *ctx, struct nfs4_label *ilabel, struct nfs_open_context *ctx, struct nfs4_label *ilabel,
struct nfs4_label *olabel); struct nfs4_label *olabel);
#ifdef CONFIG_NFS_V4_1 #ifdef CONFIG_NFS_V4_1
static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
struct rpc_cred *cred, const struct cred *cred,
struct nfs4_slot *slot, struct nfs4_slot *slot,
bool is_privileged); bool is_privileged);
static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *, static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
struct rpc_cred *); const struct cred *);
static int nfs41_free_stateid(struct nfs_server *, const nfs4_stateid *, static int nfs41_free_stateid(struct nfs_server *, const nfs4_stateid *,
struct rpc_cred *, bool); const struct cred *, bool);
#endif #endif
#ifdef CONFIG_NFS_V4_SECURITY_LABEL #ifdef CONFIG_NFS_V4_SECURITY_LABEL
@ -361,7 +361,7 @@ static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dent
static void nfs4_test_and_free_stateid(struct nfs_server *server, static void nfs4_test_and_free_stateid(struct nfs_server *server,
nfs4_stateid *stateid, nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops; const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
@ -370,7 +370,7 @@ static void nfs4_test_and_free_stateid(struct nfs_server *server,
static void __nfs4_free_revoked_stateid(struct nfs_server *server, static void __nfs4_free_revoked_stateid(struct nfs_server *server,
nfs4_stateid *stateid, nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
stateid->type = NFS4_REVOKED_STATEID_TYPE; stateid->type = NFS4_REVOKED_STATEID_TYPE;
nfs4_test_and_free_stateid(server, stateid, cred); nfs4_test_and_free_stateid(server, stateid, cred);
@ -378,7 +378,7 @@ static void __nfs4_free_revoked_stateid(struct nfs_server *server,
static void nfs4_free_revoked_stateid(struct nfs_server *server, static void nfs4_free_revoked_stateid(struct nfs_server *server,
const nfs4_stateid *stateid, const nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
nfs4_stateid tmp; nfs4_stateid tmp;
@ -908,7 +908,7 @@ static const struct rpc_call_ops nfs41_call_sync_ops = {
static void static void
nfs4_sequence_process_interrupted(struct nfs_client *client, nfs4_sequence_process_interrupted(struct nfs_client *client,
struct nfs4_slot *slot, struct rpc_cred *cred) struct nfs4_slot *slot, const struct cred *cred)
{ {
struct rpc_task *task; struct rpc_task *task;
@ -939,7 +939,7 @@ EXPORT_SYMBOL_GPL(nfs4_sequence_done);
static void static void
nfs4_sequence_process_interrupted(struct nfs_client *client, nfs4_sequence_process_interrupted(struct nfs_client *client,
struct nfs4_slot *slot, struct rpc_cred *cred) struct nfs4_slot *slot, const struct cred *cred)
{ {
WARN_ON_ONCE(1); WARN_ON_ONCE(1);
slot->interrupted = 0; slot->interrupted = 0;
@ -1772,7 +1772,7 @@ static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
rcu_read_unlock(); rcu_read_unlock();
nfs_release_seqid(opendata->o_arg.seqid); nfs_release_seqid(opendata->o_arg.seqid);
if (!opendata->is_recover) { if (!opendata->is_recover) {
ret = nfs_may_open(state->inode, state->owner->so_cred->cr_cred, open_mode); ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
if (ret != 0) if (ret != 0)
goto out; goto out;
} }
@ -2484,7 +2484,7 @@ static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
* Note that in the non-execute case, we want to turn off permission * Note that in the non-execute case, we want to turn off permission
* checking if we just created a new file (POSIX open() semantics). * checking if we just created a new file (POSIX open() semantics).
*/ */
static int nfs4_opendata_access(struct rpc_cred *cred, static int nfs4_opendata_access(const struct cred *cred,
struct nfs4_opendata *opendata, struct nfs4_opendata *opendata,
struct nfs4_state *state, fmode_t fmode, struct nfs4_state *state, fmode_t fmode,
int openflags) int openflags)
@ -2511,7 +2511,7 @@ static int nfs4_opendata_access(struct rpc_cred *cred,
} else if ((fmode & FMODE_READ) && !opendata->file_created) } else if ((fmode & FMODE_READ) && !opendata->file_created)
mask = NFS4_ACCESS_READ; mask = NFS4_ACCESS_READ;
cache.cred = cred->cr_cred; cache.cred = cred;
nfs_access_set_mask(&cache, opendata->o_res.access_result); nfs_access_set_mask(&cache, opendata->o_res.access_result);
nfs_access_add_cache(state->inode, &cache); nfs_access_add_cache(state->inode, &cache);
@ -2651,7 +2651,7 @@ static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
static int nfs40_test_and_free_expired_stateid(struct nfs_server *server, static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
nfs4_stateid *stateid, nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
return -NFS4ERR_BAD_STATEID; return -NFS4ERR_BAD_STATEID;
} }
@ -2659,7 +2659,7 @@ static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
#if defined(CONFIG_NFS_V4_1) #if defined(CONFIG_NFS_V4_1)
static int nfs41_test_and_free_expired_stateid(struct nfs_server *server, static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
nfs4_stateid *stateid, nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
int status; int status;
@ -2693,7 +2693,7 @@ static void nfs41_check_delegation_stateid(struct nfs4_state *state)
struct nfs_server *server = NFS_SERVER(state->inode); struct nfs_server *server = NFS_SERVER(state->inode);
nfs4_stateid stateid; nfs4_stateid stateid;
struct nfs_delegation *delegation; struct nfs_delegation *delegation;
struct rpc_cred *cred; const struct cred *cred = NULL;
int status; int status;
/* Get the delegation credential for use by test/free_stateid */ /* Get the delegation credential for use by test/free_stateid */
@ -2718,14 +2718,16 @@ static void nfs41_check_delegation_stateid(struct nfs4_state *state)
return; return;
} }
cred = get_rpccred(delegation->cred); if (delegation->cred)
cred = get_cred(delegation->cred);
rcu_read_unlock(); rcu_read_unlock();
status = nfs41_test_and_free_expired_stateid(server, &stateid, cred); status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
trace_nfs4_test_delegation_stateid(state, NULL, status); trace_nfs4_test_delegation_stateid(state, NULL, status);
if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
nfs_finish_clear_delegation_stateid(state, &stateid); nfs_finish_clear_delegation_stateid(state, &stateid);
put_rpccred(cred); if (delegation->cred)
put_cred(cred);
} }
/** /**
@ -2748,7 +2750,7 @@ static int nfs41_check_expired_locks(struct nfs4_state *state)
spin_lock(&state->state_lock); spin_lock(&state->state_lock);
list_for_each_entry(lsp, &state->lock_states, ls_locks) { list_for_each_entry(lsp, &state->lock_states, ls_locks) {
if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) { if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
struct rpc_cred *cred = lsp->ls_state->owner->so_cred; const struct cred *cred = lsp->ls_state->owner->so_cred;
refcount_inc(&lsp->ls_count); refcount_inc(&lsp->ls_count);
spin_unlock(&state->state_lock); spin_unlock(&state->state_lock);
@ -2792,7 +2794,7 @@ static int nfs41_check_open_stateid(struct nfs4_state *state)
{ {
struct nfs_server *server = NFS_SERVER(state->inode); struct nfs_server *server = NFS_SERVER(state->inode);
nfs4_stateid *stateid = &state->open_stateid; nfs4_stateid *stateid = &state->open_stateid;
struct rpc_cred *cred = state->owner->so_cred; const struct cred *cred = state->owner->so_cred;
int status; int status;
if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) { if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
@ -2950,7 +2952,7 @@ static int _nfs4_do_open(struct inode *dir,
struct nfs_server *server = NFS_SERVER(dir); struct nfs_server *server = NFS_SERVER(dir);
struct nfs4_opendata *opendata; struct nfs4_opendata *opendata;
struct dentry *dentry = ctx->dentry; struct dentry *dentry = ctx->dentry;
struct rpc_cred *cred = ctx->cred; const struct cred *cred = ctx->cred;
struct nfs4_threshold **ctx_th = &ctx->mdsthreshold; struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC); fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL; enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
@ -3120,7 +3122,7 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
static int _nfs4_do_setattr(struct inode *inode, static int _nfs4_do_setattr(struct inode *inode,
struct nfs_setattrargs *arg, struct nfs_setattrargs *arg,
struct nfs_setattrres *res, struct nfs_setattrres *res,
struct rpc_cred *cred, const struct cred *cred,
struct nfs_open_context *ctx) struct nfs_open_context *ctx)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
@ -3130,7 +3132,7 @@ static int _nfs4_do_setattr(struct inode *inode,
.rpc_resp = res, .rpc_resp = res,
.rpc_cred = cred, .rpc_cred = cred,
}; };
struct rpc_cred *delegation_cred = NULL; const struct cred *delegation_cred = NULL;
unsigned long timestamp = jiffies; unsigned long timestamp = jiffies;
bool truncate; bool truncate;
int status; int status;
@ -3165,14 +3167,14 @@ zero_stateid:
status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1); status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
put_rpccred(delegation_cred); put_cred(delegation_cred);
if (status == 0 && ctx != NULL) if (status == 0 && ctx != NULL)
renew_lease(server, timestamp); renew_lease(server, timestamp);
trace_nfs4_setattr(inode, &arg->stateid, status); trace_nfs4_setattr(inode, &arg->stateid, status);
return status; return status;
} }
static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, static int nfs4_do_setattr(struct inode *inode, const struct cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr, struct nfs_fattr *fattr, struct iattr *sattr,
struct nfs_open_context *ctx, struct nfs4_label *ilabel, struct nfs_open_context *ctx, struct nfs4_label *ilabel,
struct nfs4_label *olabel) struct nfs4_label *olabel)
@ -3973,7 +3975,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
struct iattr *sattr) struct iattr *sattr)
{ {
struct inode *inode = d_inode(dentry); struct inode *inode = d_inode(dentry);
struct rpc_cred *cred = NULL; const struct cred *cred = NULL;
struct nfs_open_context *ctx = NULL; struct nfs_open_context *ctx = NULL;
struct nfs4_label *label = NULL; struct nfs4_label *label = NULL;
int status; int status;
@ -4188,28 +4190,20 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
struct nfs4_accessres res = { struct nfs4_accessres res = {
.server = server, .server = server,
}; };
struct auth_cred acred = {
.cred = entry->cred,
};
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
.rpc_argp = &args, .rpc_argp = &args,
.rpc_resp = &res, .rpc_resp = &res,
.rpc_cred = rpc_lookup_generic_cred(&acred, 0, GFP_NOFS), .rpc_cred = entry->cred,
}; };
int status = 0; int status = 0;
if (!msg.rpc_cred)
return -ENOMEM;
if (!nfs4_have_delegation(inode, FMODE_READ)) { if (!nfs4_have_delegation(inode, FMODE_READ)) {
res.fattr = nfs_alloc_fattr(); res.fattr = nfs_alloc_fattr();
if (res.fattr == NULL) { if (res.fattr == NULL)
put_rpccred(msg.rpc_cred);
return -ENOMEM; return -ENOMEM;
}
args.bitmask = server->cache_consistency_bitmask; args.bitmask = server->cache_consistency_bitmask;
} }
status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
if (!status) { if (!status) {
nfs_access_set_mask(entry, res.access); nfs_access_set_mask(entry, res.access);
@ -4217,7 +4211,6 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
nfs_refresh_inode(inode, res.fattr); nfs_refresh_inode(inode, res.fattr);
} }
nfs_free_fattr(res.fattr); nfs_free_fattr(res.fattr);
put_rpccred(msg.rpc_cred);
return status; return status;
} }
@ -4712,23 +4705,17 @@ static int _nfs4_proc_readdir(struct dentry *dentry, const struct cred *cred,
.plus = plus, .plus = plus,
}; };
struct nfs4_readdir_res res; struct nfs4_readdir_res res;
struct auth_cred acred = {
.cred = cred,
};
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
.rpc_argp = &args, .rpc_argp = &args,
.rpc_resp = &res, .rpc_resp = &res,
.rpc_cred = rpc_lookup_generic_cred(&acred, .rpc_cred = cred,
0, GFP_NOFS),
}; };
int status; int status;
dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__, dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
dentry, dentry,
(unsigned long long)cookie); (unsigned long long)cookie);
if (!msg.rpc_cred)
return -ENOMEM;
nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args); nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
res.pgbase = args.pgbase; res.pgbase = args.pgbase;
status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0); status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
@ -4739,7 +4726,6 @@ static int _nfs4_proc_readdir(struct dentry *dentry, const struct cred *cred,
nfs_invalidate_atime(dir); nfs_invalidate_atime(dir);
put_rpccred(msg.rpc_cred);
dprintk("%s: returns %d\n", __func__, status); dprintk("%s: returns %d\n", __func__, status);
return status; return status;
} }
@ -5272,7 +5258,7 @@ static const struct rpc_call_ops nfs4_renew_ops = {
.rpc_release = nfs4_renew_release, .rpc_release = nfs4_renew_release,
}; };
static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags) static int nfs4_proc_async_renew(struct nfs_client *clp, const struct cred *cred, unsigned renew_flags)
{ {
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
@ -5296,7 +5282,7 @@ static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred,
&nfs4_renew_ops, data); &nfs4_renew_ops, data);
} }
static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) static int nfs4_proc_renew(struct nfs_client *clp, const struct cred *cred)
{ {
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
@ -5711,7 +5697,6 @@ nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
{ {
struct nfs4_label ilabel, *olabel = NULL; struct nfs4_label ilabel, *olabel = NULL;
struct nfs_fattr fattr; struct nfs_fattr fattr;
struct rpc_cred *cred;
int status; int status;
if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
@ -5724,10 +5709,6 @@ nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
ilabel.label = (char *)buf; ilabel.label = (char *)buf;
ilabel.len = buflen; ilabel.len = buflen;
cred = rpc_lookup_cred();
if (IS_ERR(cred))
return PTR_ERR(cred);
olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
if (IS_ERR(olabel)) { if (IS_ERR(olabel)) {
status = -PTR_ERR(olabel); status = -PTR_ERR(olabel);
@ -5740,7 +5721,6 @@ nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
nfs4_label_free(olabel); nfs4_label_free(olabel);
out: out:
put_rpccred(cred);
return status; return status;
} }
#endif /* CONFIG_NFS_V4_SECURITY_LABEL */ #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
@ -5909,13 +5889,13 @@ static const struct rpc_call_ops nfs4_setclientid_ops = {
* @clp: state data structure * @clp: state data structure
* @program: RPC program for NFSv4 callback service * @program: RPC program for NFSv4 callback service
* @port: IP port number for NFS4 callback service * @port: IP port number for NFS4 callback service
* @cred: RPC credential to use for this call * @cred: credential to use for this call
* @res: where to place the result * @res: where to place the result
* *
* Returns zero, a negative errno, or a negative NFS4ERR status code. * Returns zero, a negative errno, or a negative NFS4ERR status code.
*/ */
int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
unsigned short port, struct rpc_cred *cred, unsigned short port, const struct cred *cred,
struct nfs4_setclientid_res *res) struct nfs4_setclientid_res *res)
{ {
nfs4_verifier sc_verifier; nfs4_verifier sc_verifier;
@ -5984,13 +5964,13 @@ out:
* nfs4_proc_setclientid_confirm - Confirm client ID * nfs4_proc_setclientid_confirm - Confirm client ID
* @clp: state data structure * @clp: state data structure
* @res: result of a previous SETCLIENTID * @res: result of a previous SETCLIENTID
* @cred: RPC credential to use for this call * @cred: credential to use for this call
* *
* Returns zero, a negative errno, or a negative NFS4ERR status code. * Returns zero, a negative errno, or a negative NFS4ERR status code.
*/ */
int nfs4_proc_setclientid_confirm(struct nfs_client *clp, int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
struct nfs4_setclientid_res *arg, struct nfs4_setclientid_res *arg,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
@ -6153,7 +6133,7 @@ static const struct rpc_call_ops nfs4_delegreturn_ops = {
.rpc_release = nfs4_delegreturn_release, .rpc_release = nfs4_delegreturn_release,
}; };
static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) static int _nfs4_proc_delegreturn(struct inode *inode, const struct cred *cred, const nfs4_stateid *stateid, int issync)
{ {
struct nfs4_delegreturndata *data; struct nfs4_delegreturndata *data;
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
@ -6220,7 +6200,7 @@ out:
return status; return status;
} }
int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) int nfs4_proc_delegreturn(struct inode *inode, const struct cred *cred, const nfs4_stateid *stateid, int issync)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct nfs4_exception exception = { }; struct nfs4_exception exception = { };
@ -7281,7 +7261,7 @@ int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
*/ */
static int _nfs40_proc_get_locations(struct inode *inode, static int _nfs40_proc_get_locations(struct inode *inode,
struct nfs4_fs_locations *locations, struct nfs4_fs_locations *locations,
struct page *page, struct rpc_cred *cred) struct page *page, const struct cred *cred)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct rpc_clnt *clnt = server->client; struct rpc_clnt *clnt = server->client;
@ -7338,7 +7318,7 @@ static int _nfs40_proc_get_locations(struct inode *inode,
*/ */
static int _nfs41_proc_get_locations(struct inode *inode, static int _nfs41_proc_get_locations(struct inode *inode,
struct nfs4_fs_locations *locations, struct nfs4_fs_locations *locations,
struct page *page, struct rpc_cred *cred) struct page *page, const struct cred *cred)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct rpc_clnt *clnt = server->client; struct rpc_clnt *clnt = server->client;
@ -7397,7 +7377,7 @@ static int _nfs41_proc_get_locations(struct inode *inode,
*/ */
int nfs4_proc_get_locations(struct inode *inode, int nfs4_proc_get_locations(struct inode *inode,
struct nfs4_fs_locations *locations, struct nfs4_fs_locations *locations,
struct page *page, struct rpc_cred *cred) struct page *page, const struct cred *cred)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct nfs_client *clp = server->nfs_client; struct nfs_client *clp = server->nfs_client;
@ -7428,7 +7408,7 @@ int nfs4_proc_get_locations(struct inode *inode,
* is appended to this compound to identify the client ID which is * is appended to this compound to identify the client ID which is
* performing recovery. * performing recovery.
*/ */
static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) static int _nfs40_proc_fsid_present(struct inode *inode, const struct cred *cred)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
@ -7474,7 +7454,7 @@ static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
* this operation is identified in the SEQUENCE operation in this * this operation is identified in the SEQUENCE operation in this
* compound. * compound.
*/ */
static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) static int _nfs41_proc_fsid_present(struct inode *inode, const struct cred *cred)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct rpc_clnt *clnt = server->client; struct rpc_clnt *clnt = server->client;
@ -7521,7 +7501,7 @@ static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
* NFS4ERR code if some error occurred on the server, or a * NFS4ERR code if some error occurred on the server, or a
* negative errno if a local failure occurred. * negative errno if a local failure occurred.
*/ */
int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) int nfs4_proc_fsid_present(struct inode *inode, const struct cred *cred)
{ {
struct nfs_server *server = NFS_SERVER(inode); struct nfs_server *server = NFS_SERVER(inode);
struct nfs_client *clp = server->nfs_client; struct nfs_client *clp = server->nfs_client;
@ -7568,7 +7548,7 @@ static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct
.rpc_resp = &res, .rpc_resp = &res,
}; };
struct rpc_clnt *clnt = NFS_SERVER(dir)->client; struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
struct rpc_cred *cred = NULL; const struct cred *cred = NULL;
if (use_integrity) { if (use_integrity) {
clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient; clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
@ -7585,8 +7565,7 @@ static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct
&res.seq_res, 0); &res.seq_res, 0);
dprintk("NFS reply secinfo: %d\n", status); dprintk("NFS reply secinfo: %d\n", status);
if (cred) put_cred(cred);
put_rpccred(cred);
return status; return status;
} }
@ -7667,7 +7646,7 @@ static
int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt, int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
struct rpc_xprt *xprt, struct rpc_xprt *xprt,
struct nfs_client *clp, struct nfs_client *clp,
struct rpc_cred *cred) const struct cred *cred)
{ {
int status; int status;
struct nfs41_bind_conn_to_session_args args = { struct nfs41_bind_conn_to_session_args args = {
@ -7729,7 +7708,7 @@ int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
struct rpc_bind_conn_calldata { struct rpc_bind_conn_calldata {
struct nfs_client *clp; struct nfs_client *clp;
struct rpc_cred *cred; const struct cred *cred;
}; };
static int static int
@ -7742,7 +7721,7 @@ nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred); return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
} }
int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred) int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, const struct cred *cred)
{ {
struct rpc_bind_conn_calldata data = { struct rpc_bind_conn_calldata data = {
.clp = clp, .clp = clp,
@ -7908,7 +7887,7 @@ static const struct rpc_call_ops nfs4_exchange_id_call_ops = {
* Wrapper for EXCHANGE_ID operation. * Wrapper for EXCHANGE_ID operation.
*/ */
static struct rpc_task * static struct rpc_task *
nfs4_run_exchange_id(struct nfs_client *clp, struct rpc_cred *cred, nfs4_run_exchange_id(struct nfs_client *clp, const struct cred *cred,
u32 sp4_how, struct rpc_xprt *xprt) u32 sp4_how, struct rpc_xprt *xprt)
{ {
struct rpc_message msg = { struct rpc_message msg = {
@ -8004,7 +7983,7 @@ out:
* *
* Wrapper for EXCHANGE_ID operation. * Wrapper for EXCHANGE_ID operation.
*/ */
static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred, static int _nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred,
u32 sp4_how) u32 sp4_how)
{ {
struct rpc_task *task; struct rpc_task *task;
@ -8071,7 +8050,7 @@ out:
* *
* Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used. * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
*/ */
int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred) int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred)
{ {
rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor; rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
int status; int status;
@ -8133,7 +8112,7 @@ int nfs4_test_session_trunk(struct rpc_clnt *clnt, struct rpc_xprt *xprt,
EXPORT_SYMBOL_GPL(nfs4_test_session_trunk); EXPORT_SYMBOL_GPL(nfs4_test_session_trunk);
static int _nfs4_proc_destroy_clientid(struct nfs_client *clp, static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
@ -8151,7 +8130,7 @@ static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
} }
static int nfs4_proc_destroy_clientid(struct nfs_client *clp, static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
struct rpc_cred *cred) const struct cred *cred)
{ {
unsigned int loop; unsigned int loop;
int ret; int ret;
@ -8172,7 +8151,7 @@ static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
int nfs4_destroy_clientid(struct nfs_client *clp) int nfs4_destroy_clientid(struct nfs_client *clp)
{ {
struct rpc_cred *cred; const struct cred *cred;
int ret = 0; int ret = 0;
if (clp->cl_mvops->minor_version < 1) if (clp->cl_mvops->minor_version < 1)
@ -8183,8 +8162,7 @@ int nfs4_destroy_clientid(struct nfs_client *clp)
goto out; goto out;
cred = nfs4_get_clid_cred(clp); cred = nfs4_get_clid_cred(clp);
ret = nfs4_proc_destroy_clientid(clp, cred); ret = nfs4_proc_destroy_clientid(clp, cred);
if (cred) put_cred(cred);
put_rpccred(cred);
switch (ret) { switch (ret) {
case 0: case 0:
case -NFS4ERR_STALE_CLIENTID: case -NFS4ERR_STALE_CLIENTID:
@ -8400,7 +8378,7 @@ static void nfs4_update_session(struct nfs4_session *session,
} }
static int _nfs4_proc_create_session(struct nfs_client *clp, static int _nfs4_proc_create_session(struct nfs_client *clp,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs4_session *session = clp->cl_session; struct nfs4_session *session = clp->cl_session;
struct nfs41_create_session_args args = { struct nfs41_create_session_args args = {
@ -8452,7 +8430,7 @@ out:
* It is the responsibility of the caller to verify the session is * It is the responsibility of the caller to verify the session is
* expired before calling this routine. * expired before calling this routine.
*/ */
int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred) int nfs4_proc_create_session(struct nfs_client *clp, const struct cred *cred)
{ {
int status; int status;
unsigned *ptr; unsigned *ptr;
@ -8483,7 +8461,7 @@ out:
* The caller must serialize access to this routine. * The caller must serialize access to this routine.
*/ */
int nfs4_proc_destroy_session(struct nfs4_session *session, int nfs4_proc_destroy_session(struct nfs4_session *session,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION], .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
@ -8585,7 +8563,7 @@ static const struct rpc_call_ops nfs41_sequence_ops = {
}; };
static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
struct rpc_cred *cred, const struct cred *cred,
struct nfs4_slot *slot, struct nfs4_slot *slot,
bool is_privileged) bool is_privileged)
{ {
@ -8628,7 +8606,7 @@ out_err:
return ret; return ret;
} }
static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags) static int nfs41_proc_async_sequence(struct nfs_client *clp, const struct cred *cred, unsigned renew_flags)
{ {
struct rpc_task *task; struct rpc_task *task;
int ret = 0; int ret = 0;
@ -8644,7 +8622,7 @@ static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cr
return ret; return ret;
} }
static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) static int nfs4_proc_sequence(struct nfs_client *clp, const struct cred *cred)
{ {
struct rpc_task *task; struct rpc_task *task;
int ret; int ret;
@ -8740,7 +8718,7 @@ static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
* Issue a global reclaim complete. * Issue a global reclaim complete.
*/ */
static int nfs41_proc_reclaim_complete(struct nfs_client *clp, static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs4_reclaim_complete_data *calldata; struct nfs4_reclaim_complete_data *calldata;
struct rpc_task *task; struct rpc_task *task;
@ -9093,7 +9071,7 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
static int static int
_nfs4_proc_getdeviceinfo(struct nfs_server *server, _nfs4_proc_getdeviceinfo(struct nfs_server *server,
struct pnfs_device *pdev, struct pnfs_device *pdev,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs4_getdeviceinfo_args args = { struct nfs4_getdeviceinfo_args args = {
.pdev = pdev, .pdev = pdev,
@ -9125,7 +9103,7 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server,
int nfs4_proc_getdeviceinfo(struct nfs_server *server, int nfs4_proc_getdeviceinfo(struct nfs_server *server,
struct pnfs_device *pdev, struct pnfs_device *pdev,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs4_exception exception = { }; struct nfs4_exception exception = { };
int err; int err;
@ -9182,7 +9160,7 @@ static void nfs4_layoutcommit_release(void *calldata)
pnfs_cleanup_layoutcommit(data); pnfs_cleanup_layoutcommit(data);
nfs_post_op_update_inode_force_wcc(data->args.inode, nfs_post_op_update_inode_force_wcc(data->args.inode,
data->res.fattr); data->res.fattr);
put_rpccred(data->cred); put_cred(data->cred);
nfs_iput_and_deactive(data->inode); nfs_iput_and_deactive(data->inode);
kfree(data); kfree(data);
} }
@ -9258,7 +9236,7 @@ _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
.rpc_resp = &res, .rpc_resp = &res,
}; };
struct rpc_clnt *clnt = server->client; struct rpc_clnt *clnt = server->client;
struct rpc_cred *cred = NULL; const struct cred *cred = NULL;
int status; int status;
if (use_integrity) { if (use_integrity) {
@ -9272,8 +9250,7 @@ _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
&res.seq_res, 0); &res.seq_res, 0);
dprintk("<-- %s status=%d\n", __func__, status); dprintk("<-- %s status=%d\n", __func__, status);
if (cred) put_cred(cred);
put_rpccred(cred);
return status; return status;
} }
@ -9386,7 +9363,7 @@ out:
static int _nfs41_test_stateid(struct nfs_server *server, static int _nfs41_test_stateid(struct nfs_server *server,
nfs4_stateid *stateid, nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
int status; int status;
struct nfs41_test_stateid_args args = { struct nfs41_test_stateid_args args = {
@ -9447,7 +9424,7 @@ static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
*/ */
static int nfs41_test_stateid(struct nfs_server *server, static int nfs41_test_stateid(struct nfs_server *server,
nfs4_stateid *stateid, nfs4_stateid *stateid,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs4_exception exception = { }; struct nfs4_exception exception = { };
int err; int err;
@ -9509,7 +9486,7 @@ static const struct rpc_call_ops nfs41_free_stateid_ops = {
*/ */
static int nfs41_free_stateid(struct nfs_server *server, static int nfs41_free_stateid(struct nfs_server *server,
const nfs4_stateid *stateid, const nfs4_stateid *stateid,
struct rpc_cred *cred, const struct cred *cred,
bool privileged) bool privileged)
{ {
struct rpc_message msg = { struct rpc_message msg = {
@ -9550,7 +9527,7 @@ static int nfs41_free_stateid(struct nfs_server *server,
static void static void
nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp) nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
{ {
struct rpc_cred *cred = lsp->ls_state->owner->so_cred; const struct cred *cred = lsp->ls_state->owner->so_cred;
nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
nfs4_free_lock_state(server, lsp); nfs4_free_lock_state(server, lsp);

4
fs/nfs/nfs4renewd.c
View File

@ -57,7 +57,7 @@ nfs4_renew_state(struct work_struct *work)
const struct nfs4_state_maintenance_ops *ops; const struct nfs4_state_maintenance_ops *ops;
struct nfs_client *clp = struct nfs_client *clp =
container_of(work, struct nfs_client, cl_renewd.work); container_of(work, struct nfs_client, cl_renewd.work);
struct rpc_cred *cred; const struct cred *cred;
long lease; long lease;
unsigned long last, now; unsigned long last, now;
unsigned renew_flags = 0; unsigned renew_flags = 0;
@ -90,7 +90,7 @@ nfs4_renew_state(struct work_struct *work)
/* Queue an asynchronous RENEW. */ /* Queue an asynchronous RENEW. */
ret = ops->sched_state_renewal(clp, cred, renew_flags); ret = ops->sched_state_renewal(clp, cred, renew_flags);
put_rpccred(cred); put_cred(cred);
switch (ret) { switch (ret) {
default: default:
goto out_exp; goto out_exp;

5
fs/nfs/nfs4session.c
View File

@ -573,12 +573,11 @@ static void nfs4_destroy_session_slot_tables(struct nfs4_session *session)
void nfs4_destroy_session(struct nfs4_session *session) void nfs4_destroy_session(struct nfs4_session *session)
{ {
struct rpc_xprt *xprt; struct rpc_xprt *xprt;
struct rpc_cred *cred; const struct cred *cred;
cred = nfs4_get_clid_cred(session->clp); cred = nfs4_get_clid_cred(session->clp);
nfs4_proc_destroy_session(session, cred); nfs4_proc_destroy_session(session, cred);
if (cred) put_cred(cred);
put_rpccred(cred);
rcu_read_lock(); rcu_read_lock();
xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt); xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt);

92
fs/nfs/nfs4state.c
View File

@ -87,7 +87,7 @@ const nfs4_stateid current_stateid = {
static DEFINE_MUTEX(nfs_clid_init_mutex); static DEFINE_MUTEX(nfs_clid_init_mutex);
int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred) int nfs4_init_clientid(struct nfs_client *clp, const struct cred *cred)
{ {
struct nfs4_setclientid_res clid = { struct nfs4_setclientid_res clid = {
.clientid = clp->cl_clientid, .clientid = clp->cl_clientid,
@ -134,7 +134,7 @@ out:
*/ */
int nfs40_discover_server_trunking(struct nfs_client *clp, int nfs40_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **result, struct nfs_client **result,
struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs4_setclientid_res clid = { struct nfs4_setclientid_res clid = {
.clientid = clp->cl_clientid, .clientid = clp->cl_clientid,
@ -164,9 +164,9 @@ out:
return status; return status;
} }
struct rpc_cred *nfs4_get_machine_cred(struct nfs_client *clp) const struct cred *nfs4_get_machine_cred(struct nfs_client *clp)
{ {
return get_rpccred(rpc_machine_cred()); return get_cred(rpc_machine_cred());
} }
static void nfs4_root_machine_cred(struct nfs_client *clp) static void nfs4_root_machine_cred(struct nfs_client *clp)
@ -177,10 +177,10 @@ static void nfs4_root_machine_cred(struct nfs_client *clp)
clp->cl_rpcclient->cl_principal = NULL; clp->cl_rpcclient->cl_principal = NULL;
} }
static struct rpc_cred * static const struct cred *
nfs4_get_renew_cred_server_locked(struct nfs_server *server) nfs4_get_renew_cred_server_locked(struct nfs_server *server)
{ {
struct rpc_cred *cred = NULL; const struct cred *cred = NULL;
struct nfs4_state_owner *sp; struct nfs4_state_owner *sp;
struct rb_node *pos; struct rb_node *pos;
@ -190,7 +190,7 @@ nfs4_get_renew_cred_server_locked(struct nfs_server *server)
sp = rb_entry(pos, struct nfs4_state_owner, so_server_node); sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
if (list_empty(&sp->so_states)) if (list_empty(&sp->so_states))
continue; continue;
cred = get_rpccred(sp->so_cred); cred = get_cred(sp->so_cred);
break; break;
} }
return cred; return cred;
@ -203,9 +203,9 @@ nfs4_get_renew_cred_server_locked(struct nfs_server *server)
* Returns an rpc_cred with reference count bumped, or NULL. * Returns an rpc_cred with reference count bumped, or NULL.
* Caller must hold clp->cl_lock. * Caller must hold clp->cl_lock.
*/ */
struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp) const struct cred *nfs4_get_renew_cred(struct nfs_client *clp)
{ {
struct rpc_cred *cred = NULL; const struct cred *cred = NULL;
struct nfs_server *server; struct nfs_server *server;
/* Use machine credentials if available */ /* Use machine credentials if available */
@ -312,7 +312,7 @@ static void nfs41_finish_session_reset(struct nfs_client *clp)
nfs41_setup_state_renewal(clp); nfs41_setup_state_renewal(clp);
} }
int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred) int nfs41_init_clientid(struct nfs_client *clp, const struct cred *cred)
{ {
int status; int status;
@ -347,7 +347,7 @@ out:
*/ */
int nfs41_discover_server_trunking(struct nfs_client *clp, int nfs41_discover_server_trunking(struct nfs_client *clp,
struct nfs_client **result, struct nfs_client **result,
struct rpc_cred *cred) const struct cred *cred)
{ {
int status; int status;
@ -385,30 +385,32 @@ int nfs41_discover_server_trunking(struct nfs_client *clp,
* nfs4_get_clid_cred - Acquire credential for a setclientid operation * nfs4_get_clid_cred - Acquire credential for a setclientid operation
* @clp: client state handle * @clp: client state handle
* *
* Returns an rpc_cred with reference count bumped, or NULL. * Returns a cred with reference count bumped, or NULL.
*/ */
struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp) const struct cred *nfs4_get_clid_cred(struct nfs_client *clp)
{ {
struct rpc_cred *cred; const struct cred *cred;
cred = nfs4_get_machine_cred(clp); cred = nfs4_get_machine_cred(clp);
return cred; return cred;
} }
static struct nfs4_state_owner * static struct nfs4_state_owner *
nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred) nfs4_find_state_owner_locked(struct nfs_server *server, const struct cred *cred)
{ {
struct rb_node **p = &server->state_owners.rb_node, struct rb_node **p = &server->state_owners.rb_node,
*parent = NULL; *parent = NULL;
struct nfs4_state_owner *sp; struct nfs4_state_owner *sp;
int cmp;
while (*p != NULL) { while (*p != NULL) {
parent = *p; parent = *p;
sp = rb_entry(parent, struct nfs4_state_owner, so_server_node); sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
cmp = cred_fscmp(cred, sp->so_cred);
if (cred < sp->so_cred) if (cmp < 0)
p = &parent->rb_left; p = &parent->rb_left;
else if (cred > sp->so_cred) else if (cmp > 0)
p = &parent->rb_right; p = &parent->rb_right;
else { else {
if (!list_empty(&sp->so_lru)) if (!list_empty(&sp->so_lru))
@ -427,14 +429,16 @@ nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
struct rb_node **p = &server->state_owners.rb_node, struct rb_node **p = &server->state_owners.rb_node,
*parent = NULL; *parent = NULL;
struct nfs4_state_owner *sp; struct nfs4_state_owner *sp;
int cmp;
while (*p != NULL) { while (*p != NULL) {
parent = *p; parent = *p;
sp = rb_entry(parent, struct nfs4_state_owner, so_server_node); sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
cmp = cred_fscmp(new->so_cred, sp->so_cred);
if (new->so_cred < sp->so_cred) if (cmp < 0)
p = &parent->rb_left; p = &parent->rb_left;
else if (new->so_cred > sp->so_cred) else if (cmp > 0)
p = &parent->rb_right; p = &parent->rb_right;
else { else {
if (!list_empty(&sp->so_lru)) if (!list_empty(&sp->so_lru))
@ -481,7 +485,7 @@ nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
*/ */
static struct nfs4_state_owner * static struct nfs4_state_owner *
nfs4_alloc_state_owner(struct nfs_server *server, nfs4_alloc_state_owner(struct nfs_server *server,
struct rpc_cred *cred, const struct cred *cred,
gfp_t gfp_flags) gfp_t gfp_flags)
{ {
struct nfs4_state_owner *sp; struct nfs4_state_owner *sp;
@ -496,7 +500,7 @@ nfs4_alloc_state_owner(struct nfs_server *server,
return NULL; return NULL;
} }
sp->so_server = server; sp->so_server = server;
sp->so_cred = get_rpccred(cred); sp->so_cred = get_cred(cred);
spin_lock_init(&sp->so_lock); spin_lock_init(&sp->so_lock);
INIT_LIST_HEAD(&sp->so_states); INIT_LIST_HEAD(&sp->so_states);
nfs4_init_seqid_counter(&sp->so_seqid); nfs4_init_seqid_counter(&sp->so_seqid);
@ -525,7 +529,7 @@ nfs4_reset_state_owner(struct nfs4_state_owner *sp)
static void nfs4_free_state_owner(struct nfs4_state_owner *sp) static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
{ {
nfs4_destroy_seqid_counter(&sp->so_seqid); nfs4_destroy_seqid_counter(&sp->so_seqid);
put_rpccred(sp->so_cred); put_cred(sp->so_cred);
ida_simple_remove(&sp->so_server->openowner_id, sp->so_seqid.owner_id); ida_simple_remove(&sp->so_server->openowner_id, sp->so_seqid.owner_id);
kfree(sp); kfree(sp);
} }
@ -563,7 +567,7 @@ static void nfs4_gc_state_owners(struct nfs_server *server)
* Returns a pointer to an instantiated nfs4_state_owner struct, or NULL. * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
*/ */
struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
struct rpc_cred *cred, const struct cred *cred,
gfp_t gfp_flags) gfp_t gfp_flags)
{ {
struct nfs_client *clp = server->nfs_client; struct nfs_client *clp = server->nfs_client;
@ -1032,7 +1036,7 @@ bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
*/ */
int nfs4_select_rw_stateid(struct nfs4_state *state, int nfs4_select_rw_stateid(struct nfs4_state *state,
fmode_t fmode, const struct nfs_lock_context *l_ctx, fmode_t fmode, const struct nfs_lock_context *l_ctx,
nfs4_stateid *dst, struct rpc_cred **cred) nfs4_stateid *dst, const struct cred **cred)
{ {
int ret; int ret;
@ -1732,7 +1736,7 @@ static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
static int nfs4_reclaim_complete(struct nfs_client *clp, static int nfs4_reclaim_complete(struct nfs_client *clp,
const struct nfs4_state_recovery_ops *ops, const struct nfs4_state_recovery_ops *ops,
struct rpc_cred *cred) const struct cred *cred)
{ {
/* Notify the server we're done reclaiming our state */ /* Notify the server we're done reclaiming our state */
if (ops->reclaim_complete) if (ops->reclaim_complete)
@ -1783,7 +1787,7 @@ static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp) static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
{ {
const struct nfs4_state_recovery_ops *ops; const struct nfs4_state_recovery_ops *ops;
struct rpc_cred *cred; const struct cred *cred;
int err; int err;
if (!nfs4_state_clear_reclaim_reboot(clp)) if (!nfs4_state_clear_reclaim_reboot(clp))
@ -1791,7 +1795,7 @@ static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
ops = clp->cl_mvops->reboot_recovery_ops; ops = clp->cl_mvops->reboot_recovery_ops;
cred = nfs4_get_clid_cred(clp); cred = nfs4_get_clid_cred(clp);
err = nfs4_reclaim_complete(clp, ops, cred); err = nfs4_reclaim_complete(clp, ops, cred);
put_rpccred(cred); put_cred(cred);
if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION) if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
} }
@ -1887,7 +1891,7 @@ restart:
static int nfs4_check_lease(struct nfs_client *clp) static int nfs4_check_lease(struct nfs_client *clp)
{ {
struct rpc_cred *cred; const struct cred *cred;
const struct nfs4_state_maintenance_ops *ops = const struct nfs4_state_maintenance_ops *ops =
clp->cl_mvops->state_renewal_ops; clp->cl_mvops->state_renewal_ops;
int status; int status;
@ -1903,7 +1907,7 @@ static int nfs4_check_lease(struct nfs_client *clp)
goto out; goto out;
} }
status = ops->renew_lease(clp, cred); status = ops->renew_lease(clp, cred);
put_rpccred(cred); put_cred(cred);
if (status == -ETIMEDOUT) { if (status == -ETIMEDOUT) {
set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
return 0; return 0;
@ -1963,7 +1967,7 @@ static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
static int nfs4_establish_lease(struct nfs_client *clp) static int nfs4_establish_lease(struct nfs_client *clp)
{ {
struct rpc_cred *cred; const struct cred *cred;
const struct nfs4_state_recovery_ops *ops = const struct nfs4_state_recovery_ops *ops =
clp->cl_mvops->reboot_recovery_ops; clp->cl_mvops->reboot_recovery_ops;
int status; int status;
@ -1975,7 +1979,7 @@ static int nfs4_establish_lease(struct nfs_client *clp)
if (cred == NULL) if (cred == NULL)
return -ENOENT; return -ENOENT;
status = ops->establish_clid(clp, cred); status = ops->establish_clid(clp, cred);
put_rpccred(cred); put_cred(cred);
if (status != 0) if (status != 0)
return status; return status;
pnfs_destroy_all_layouts(clp); pnfs_destroy_all_layouts(clp);
@ -2022,7 +2026,7 @@ static int nfs4_purge_lease(struct nfs_client *clp)
* *
* Returns zero or a negative NFS4ERR status code. * Returns zero or a negative NFS4ERR status code.
*/ */
static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred) static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)
{ {
struct nfs_client *clp = server->nfs_client; struct nfs_client *clp = server->nfs_client;
struct nfs4_fs_locations *locations = NULL; struct nfs4_fs_locations *locations = NULL;
@ -2092,7 +2096,7 @@ static int nfs4_handle_migration(struct nfs_client *clp)
const struct nfs4_state_maintenance_ops *ops = const struct nfs4_state_maintenance_ops *ops =
clp->cl_mvops->state_renewal_ops; clp->cl_mvops->state_renewal_ops;
struct nfs_server *server; struct nfs_server *server;
struct rpc_cred *cred; const struct cred *cred;
dprintk("%s: migration reported on \"%s\"\n", __func__, dprintk("%s: migration reported on \"%s\"\n", __func__,
clp->cl_hostname); clp->cl_hostname);
@ -2118,13 +2122,13 @@ restart:
rcu_read_unlock(); rcu_read_unlock();
status = nfs4_try_migration(server, cred); status = nfs4_try_migration(server, cred);
if (status < 0) { if (status < 0) {
put_rpccred(cred); put_cred(cred);
return status; return status;
} }
goto restart; goto restart;
} }
rcu_read_unlock(); rcu_read_unlock();
put_rpccred(cred); put_cred(cred);
return 0; return 0;
} }
@ -2138,7 +2142,7 @@ static int nfs4_handle_lease_moved(struct nfs_client *clp)
const struct nfs4_state_maintenance_ops *ops = const struct nfs4_state_maintenance_ops *ops =
clp->cl_mvops->state_renewal_ops; clp->cl_mvops->state_renewal_ops;
struct nfs_server *server; struct nfs_server *server;
struct rpc_cred *cred; const struct cred *cred;
dprintk("%s: lease moved reported on \"%s\"\n", __func__, dprintk("%s: lease moved reported on \"%s\"\n", __func__,
clp->cl_hostname); clp->cl_hostname);
@ -2171,7 +2175,7 @@ restart:
rcu_read_unlock(); rcu_read_unlock();
out: out:
put_rpccred(cred); put_cred(cred);
return 0; return 0;
} }
@ -2194,7 +2198,7 @@ int nfs4_discover_server_trunking(struct nfs_client *clp,
const struct nfs4_state_recovery_ops *ops = const struct nfs4_state_recovery_ops *ops =
clp->cl_mvops->reboot_recovery_ops; clp->cl_mvops->reboot_recovery_ops;
struct rpc_clnt *clnt; struct rpc_clnt *clnt;
struct rpc_cred *cred; const struct cred *cred;
int i, status; int i, status;
dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname); dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
@ -2210,7 +2214,7 @@ again:
goto out_unlock; goto out_unlock;
status = ops->detect_trunking(clp, result, cred); status = ops->detect_trunking(clp, result, cred);
put_rpccred(cred); put_cred(cred);
switch (status) { switch (status) {
case 0: case 0:
case -EINTR: case -EINTR:
@ -2401,7 +2405,7 @@ out_recovery:
static int nfs4_reset_session(struct nfs_client *clp) static int nfs4_reset_session(struct nfs_client *clp)
{ {
struct rpc_cred *cred; const struct cred *cred;
int status; int status;
if (!nfs4_has_session(clp)) if (!nfs4_has_session(clp))
@ -2439,14 +2443,13 @@ static int nfs4_reset_session(struct nfs_client *clp)
dprintk("%s: session reset was successful for server %s!\n", dprintk("%s: session reset was successful for server %s!\n",
__func__, clp->cl_hostname); __func__, clp->cl_hostname);
out: out:
if (cred) put_cred(cred);
put_rpccred(cred);
return status; return status;
} }
static int nfs4_bind_conn_to_session(struct nfs_client *clp) static int nfs4_bind_conn_to_session(struct nfs_client *clp)
{ {
struct rpc_cred *cred; const struct cred *cred;
int ret; int ret;
if (!nfs4_has_session(clp)) if (!nfs4_has_session(clp))
@ -2456,8 +2459,7 @@ static int nfs4_bind_conn_to_session(struct nfs_client *clp)
return ret; return ret;
cred = nfs4_get_clid_cred(clp); cred = nfs4_get_clid_cred(clp);
ret = nfs4_proc_bind_conn_to_session(clp, cred); ret = nfs4_proc_bind_conn_to_session(clp, cred);
if (cred) put_cred(cred);
put_rpccred(cred);
clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
switch (ret) { switch (ret) {
case 0: case 0:

2
fs/nfs/pagelist.c
View File

@ -587,7 +587,7 @@ static void nfs_pgio_prepare(struct rpc_task *task, void *calldata)
} }
int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr, int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr,
struct rpc_cred *cred, const struct nfs_rpc_ops *rpc_ops, const struct cred *cred, const struct nfs_rpc_ops *rpc_ops,
const struct rpc_call_ops *call_ops, int how, int flags) const struct rpc_call_ops *call_ops, int how, int flags)
{ {
struct rpc_task *task; struct rpc_task *task;

14
fs/nfs/pnfs.c
View File

@ -275,7 +275,7 @@ pnfs_free_layout_hdr(struct pnfs_layout_hdr *lo)
list_del_init(&lo->plh_layouts); list_del_init(&lo->plh_layouts);
spin_unlock(&clp->cl_lock); spin_unlock(&clp->cl_lock);
} }
put_rpccred(lo->plh_lc_cred); put_cred(lo->plh_lc_cred);
return ld->free_layout_hdr(lo); return ld->free_layout_hdr(lo);
} }
@ -1038,7 +1038,7 @@ pnfs_alloc_init_layoutget_args(struct inode *ino,
lgp->args.ctx = get_nfs_open_context(ctx); lgp->args.ctx = get_nfs_open_context(ctx);
nfs4_stateid_copy(&lgp->args.stateid, stateid); nfs4_stateid_copy(&lgp->args.stateid, stateid);
lgp->gfp_flags = gfp_flags; lgp->gfp_flags = gfp_flags;
lgp->cred = get_rpccred(ctx->cred); lgp->cred = get_cred(ctx->cred);
return lgp; return lgp;
} }
@ -1049,7 +1049,7 @@ void pnfs_layoutget_free(struct nfs4_layoutget *lgp)
nfs4_free_pages(lgp->args.layout.pages, max_pages); nfs4_free_pages(lgp->args.layout.pages, max_pages);
if (lgp->args.inode) if (lgp->args.inode)
pnfs_put_layout_hdr(NFS_I(lgp->args.inode)->layout); pnfs_put_layout_hdr(NFS_I(lgp->args.inode)->layout);
put_rpccred(lgp->cred); put_cred(lgp->cred);
put_nfs_open_context(lgp->args.ctx); put_nfs_open_context(lgp->args.ctx);
kfree(lgp); kfree(lgp);
} }
@ -1324,7 +1324,7 @@ pnfs_commit_and_return_layout(struct inode *inode)
bool pnfs_roc(struct inode *ino, bool pnfs_roc(struct inode *ino,
struct nfs4_layoutreturn_args *args, struct nfs4_layoutreturn_args *args,
struct nfs4_layoutreturn_res *res, struct nfs4_layoutreturn_res *res,
const struct rpc_cred *cred) const struct cred *cred)
{ {
struct nfs_inode *nfsi = NFS_I(ino); struct nfs_inode *nfsi = NFS_I(ino);
struct nfs_open_context *ctx; struct nfs_open_context *ctx;
@ -1583,7 +1583,7 @@ alloc_init_layout_hdr(struct inode *ino,
INIT_LIST_HEAD(&lo->plh_return_segs); INIT_LIST_HEAD(&lo->plh_return_segs);
INIT_LIST_HEAD(&lo->plh_bulk_destroy); INIT_LIST_HEAD(&lo->plh_bulk_destroy);
lo->plh_inode = ino; lo->plh_inode = ino;
lo->plh_lc_cred = get_rpccred(ctx->cred); lo->plh_lc_cred = get_cred(ctx->cred);
lo->plh_flags |= 1 << NFS_LAYOUT_INVALID_STID; lo->plh_flags |= 1 << NFS_LAYOUT_INVALID_STID;
return lo; return lo;
} }
@ -2928,7 +2928,7 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
data->args.inode = inode; data->args.inode = inode;
data->cred = get_rpccred(nfsi->layout->plh_lc_cred); data->cred = get_cred(nfsi->layout->plh_lc_cred);
nfs_fattr_init(&data->fattr); nfs_fattr_init(&data->fattr);
data->args.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask; data->args.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
data->res.fattr = &data->fattr; data->res.fattr = &data->fattr;
@ -2941,7 +2941,7 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
if (ld->prepare_layoutcommit) { if (ld->prepare_layoutcommit) {
status = ld->prepare_layoutcommit(&data->args); status = ld->prepare_layoutcommit(&data->args);
if (status) { if (status) {
put_rpccred(data->cred); put_cred(data->cred);
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags); set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags);
if (end_pos > nfsi->layout->plh_lwb) if (end_pos > nfsi->layout->plh_lwb)

10
fs/nfs/pnfs.h
View File

@ -200,7 +200,7 @@ struct pnfs_layout_hdr {
u32 plh_return_seq; u32 plh_return_seq;
enum pnfs_iomode plh_return_iomode; enum pnfs_iomode plh_return_iomode;
loff_t plh_lwb; /* last write byte for layoutcommit */ loff_t plh_lwb; /* last write byte for layoutcommit */
struct rpc_cred *plh_lc_cred; /* layoutcommit cred */ const struct cred *plh_lc_cred; /* layoutcommit cred */
struct inode *plh_inode; struct inode *plh_inode;
}; };
@ -230,7 +230,7 @@ extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
extern size_t max_response_pages(struct nfs_server *server); extern size_t max_response_pages(struct nfs_server *server);
extern int nfs4_proc_getdeviceinfo(struct nfs_server *server, extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
struct pnfs_device *dev, struct pnfs_device *dev,
struct rpc_cred *cred); const struct cred *cred);
extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout); extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout);
extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync); extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync);
@ -280,7 +280,7 @@ int pnfs_mark_layout_stateid_invalid(struct pnfs_layout_hdr *lo,
bool pnfs_roc(struct inode *ino, bool pnfs_roc(struct inode *ino,
struct nfs4_layoutreturn_args *args, struct nfs4_layoutreturn_args *args,
struct nfs4_layoutreturn_res *res, struct nfs4_layoutreturn_res *res,
const struct rpc_cred *cred); const struct cred *cred);
void pnfs_roc_release(struct nfs4_layoutreturn_args *args, void pnfs_roc_release(struct nfs4_layoutreturn_args *args,
struct nfs4_layoutreturn_res *res, struct nfs4_layoutreturn_res *res,
int ret); int ret);
@ -343,7 +343,7 @@ struct nfs4_deviceid_node {
struct nfs4_deviceid_node * struct nfs4_deviceid_node *
nfs4_find_get_deviceid(struct nfs_server *server, nfs4_find_get_deviceid(struct nfs_server *server,
const struct nfs4_deviceid *id, struct rpc_cred *cred, const struct nfs4_deviceid *id, const struct cred *cred,
gfp_t gfp_mask); gfp_t gfp_mask);
void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *); void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
void nfs4_init_deviceid_node(struct nfs4_deviceid_node *, struct nfs_server *, void nfs4_init_deviceid_node(struct nfs4_deviceid_node *, struct nfs_server *,
@ -694,7 +694,7 @@ static inline bool
pnfs_roc(struct inode *ino, pnfs_roc(struct inode *ino,
struct nfs4_layoutreturn_args *args, struct nfs4_layoutreturn_args *args,
struct nfs4_layoutreturn_res *res, struct nfs4_layoutreturn_res *res,
const struct rpc_cred *cred) const struct cred *cred)
{ {
return false; return false;
} }

4
fs/nfs/pnfs_dev.c
View File

@ -94,7 +94,7 @@ _lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
static struct nfs4_deviceid_node * static struct nfs4_deviceid_node *
nfs4_get_device_info(struct nfs_server *server, nfs4_get_device_info(struct nfs_server *server,
const struct nfs4_deviceid *dev_id, const struct nfs4_deviceid *dev_id,
struct rpc_cred *cred, gfp_t gfp_flags) const struct cred *cred, gfp_t gfp_flags)
{ {
struct nfs4_deviceid_node *d = NULL; struct nfs4_deviceid_node *d = NULL;
struct pnfs_device *pdev = NULL; struct pnfs_device *pdev = NULL;
@ -184,7 +184,7 @@ __nfs4_find_get_deviceid(struct nfs_server *server,
struct nfs4_deviceid_node * struct nfs4_deviceid_node *
nfs4_find_get_deviceid(struct nfs_server *server, nfs4_find_get_deviceid(struct nfs_server *server,
const struct nfs4_deviceid *id, struct rpc_cred *cred, const struct nfs4_deviceid *id, const struct cred *cred,
gfp_t gfp_mask) gfp_t gfp_mask)
{ {
long hash = nfs4_deviceid_hash(id); long hash = nfs4_deviceid_hash(id);

2
fs/nfs/pnfs_nfs.c
View File

@ -686,7 +686,7 @@ static int _nfs4_pnfs_v4_ds_connect(struct nfs_server *mds_srv,
rpc_clnt_setup_test_and_add_xprt, rpc_clnt_setup_test_and_add_xprt,
&rpcdata); &rpcdata);
if (xprtdata.cred) if (xprtdata.cred)
put_rpccred(xprtdata.cred); put_cred(xprtdata.cred);
} else { } else {
clp = nfs4_set_ds_client(mds_srv, clp = nfs4_set_ds_client(mds_srv,
(struct sockaddr *)&da->da_addr, (struct sockaddr *)&da->da_addr,

9
fs/nfs/proc.c
View File

@ -500,25 +500,18 @@ nfs_proc_readdir(struct dentry *dentry, const struct cred *cred,
.count = count, .count = count,
.pages = pages, .pages = pages,
}; };
struct auth_cred acred = {
.cred = cred,
};
struct rpc_message msg = { struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_READDIR], .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
.rpc_argp = &arg, .rpc_argp = &arg,
.rpc_cred = rpc_lookup_generic_cred(&acred, .rpc_cred = cred,
0, GFP_NOFS),
}; };
int status; int status;
dprintk("NFS call readdir %d\n", (unsigned int)cookie); dprintk("NFS call readdir %d\n", (unsigned int)cookie);
if (!msg.rpc_cred)
return -ENOMEM;
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
nfs_invalidate_atime(dir); nfs_invalidate_atime(dir);
put_rpccred(msg.rpc_cred);
dprintk("NFS reply readdir: %d\n", status); dprintk("NFS reply readdir: %d\n", status);
return status; return status;
} }

15
fs/nfs/unlink.c
View File

@ -31,7 +31,7 @@
static void static void
nfs_free_unlinkdata(struct nfs_unlinkdata *data) nfs_free_unlinkdata(struct nfs_unlinkdata *data)
{ {
put_rpccred(data->cred); put_cred(data->cred);
kfree(data->args.name.name); kfree(data->args.name.name);
kfree(data); kfree(data);
} }
@ -177,11 +177,7 @@ nfs_async_unlink(struct dentry *dentry, const struct qstr *name)
goto out_free; goto out_free;
data->args.name.len = name->len; data->args.name.len = name->len;
data->cred = rpc_lookup_cred(); data->cred = get_current_cred();
if (IS_ERR(data->cred)) {
status = PTR_ERR(data->cred);
goto out_free_name;
}
data->res.dir_attr = &data->dir_attr; data->res.dir_attr = &data->dir_attr;
init_waitqueue_head(&data->wq); init_waitqueue_head(&data->wq);
@ -202,8 +198,7 @@ nfs_async_unlink(struct dentry *dentry, const struct qstr *name)
return 0; return 0;
out_unlock: out_unlock:
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
put_rpccred(data->cred); put_cred(data->cred);
out_free_name:
kfree(data->args.name.name); kfree(data->args.name.name);
out_free: out_free:
kfree(data); kfree(data);
@ -307,7 +302,7 @@ static void nfs_async_rename_release(void *calldata)
iput(data->old_dir); iput(data->old_dir);
iput(data->new_dir); iput(data->new_dir);
nfs_sb_deactive(sb); nfs_sb_deactive(sb);
put_rpccred(data->cred); put_cred(data->cred);
kfree(data); kfree(data);
} }
@ -352,7 +347,7 @@ nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
task_setup_data.callback_data = data; task_setup_data.callback_data = data;
data->cred = rpc_lookup_cred(); data->cred = get_current_cred();
if (IS_ERR(data->cred)) { if (IS_ERR(data->cred)) {
struct rpc_task *task = ERR_CAST(data->cred); struct rpc_task *task = ERR_CAST(data->cred);
kfree(data); kfree(data);

2
fs/nfs/write.c
View File

@ -1249,7 +1249,7 @@ bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx, struct inode *inode)
struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth; struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth;
struct rpc_cred *cred = ctx->ll_cred; struct rpc_cred *cred = ctx->ll_cred;
struct auth_cred acred = { struct auth_cred acred = {
.cred = ctx->cred->cr_cred, .cred = ctx->cred,
}; };
if (cred && !cred->cr_ops->crmatch(&acred, cred, 0)) { if (cred && !cred->cr_ops->crmatch(&acred, cred, 0)) {

16
fs/nfsd/nfs4callback.c
View File

@ -844,18 +844,15 @@ static int max_cb_time(struct net *net)
return max(nn->nfsd4_lease/10, (time_t)1) * HZ; return max(nn->nfsd4_lease/10, (time_t)1) * HZ;
} }
static struct rpc_cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc_clnt *client, struct nfsd4_session *ses) static const struct cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc_clnt *client, struct nfsd4_session *ses)
{ {
if (clp->cl_minorversion == 0) { if (clp->cl_minorversion == 0) {
client->cl_principal = clp->cl_cred.cr_targ_princ ? client->cl_principal = clp->cl_cred.cr_targ_princ ?
clp->cl_cred.cr_targ_princ : "nfs"; clp->cl_cred.cr_targ_princ : "nfs";
return get_rpccred(rpc_machine_cred()); return get_cred(rpc_machine_cred());
} else { } else {
struct rpc_auth *auth = client->cl_auth;
struct auth_cred acred = {};
struct cred *kcred; struct cred *kcred;
struct rpc_cred *ret;
kcred = prepare_kernel_cred(NULL); kcred = prepare_kernel_cred(NULL);
if (!kcred) if (!kcred)
@ -863,10 +860,7 @@ static struct rpc_cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc
kcred->uid = ses->se_cb_sec.uid; kcred->uid = ses->se_cb_sec.uid;
kcred->gid = ses->se_cb_sec.gid; kcred->gid = ses->se_cb_sec.gid;
acred.cred = kcred; return kcred;
ret = auth->au_ops->lookup_cred(client->cl_auth, &acred, 0);
put_cred(kcred);
return ret;
} }
} }
@ -889,7 +883,7 @@ static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *c
.flags = (RPC_CLNT_CREATE_NOPING | RPC_CLNT_CREATE_QUIET), .flags = (RPC_CLNT_CREATE_NOPING | RPC_CLNT_CREATE_QUIET),
}; };
struct rpc_clnt *client; struct rpc_clnt *client;
struct rpc_cred *cred; const struct cred *cred;
if (clp->cl_minorversion == 0) { if (clp->cl_minorversion == 0) {
if (!clp->cl_cred.cr_principal && if (!clp->cl_cred.cr_principal &&
@ -1219,7 +1213,7 @@ static void nfsd4_process_cb_update(struct nfsd4_callback *cb)
if (clp->cl_cb_client) { if (clp->cl_cb_client) {
rpc_shutdown_client(clp->cl_cb_client); rpc_shutdown_client(clp->cl_cb_client);
clp->cl_cb_client = NULL; clp->cl_cb_client = NULL;
put_rpccred(clp->cl_cb_cred); put_cred(clp->cl_cb_cred);
clp->cl_cb_cred = NULL; clp->cl_cb_cred = NULL;
} }
if (clp->cl_cb_conn.cb_xprt) { if (clp->cl_cb_conn.cb_xprt) {

2
fs/nfsd/state.h
View File

@ -327,7 +327,7 @@ struct nfs4_client {
#define NFSD4_CLIENT_CB_FLAG_MASK (1 << NFSD4_CLIENT_CB_UPDATE | \ #define NFSD4_CLIENT_CB_FLAG_MASK (1 << NFSD4_CLIENT_CB_UPDATE | \
1 << NFSD4_CLIENT_CB_KILL) 1 << NFSD4_CLIENT_CB_KILL)
unsigned long cl_flags; unsigned long cl_flags;
struct rpc_cred *cl_cb_cred; const struct cred *cl_cb_cred;
struct rpc_clnt *cl_cb_client; struct rpc_clnt *cl_cb_client;
u32 cl_cb_ident; u32 cl_cb_ident;
#define NFSD4_CB_UP 0 #define NFSD4_CB_UP 0

6
include/linux/nfs_fs.h
View File

@ -70,7 +70,7 @@ struct nfs_open_context {
struct nfs_lock_context lock_context; struct nfs_lock_context lock_context;
fl_owner_t flock_owner; fl_owner_t flock_owner;
struct dentry *dentry; struct dentry *dentry;
struct rpc_cred *cred; const struct cred *cred;
struct rpc_cred *ll_cred; /* low-level cred - use to check for expiry */ struct rpc_cred *ll_cred; /* low-level cred - use to check for expiry */
struct nfs4_state *state; struct nfs4_state *state;
fmode_t mode; fmode_t mode;
@ -391,7 +391,7 @@ extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
struct nfs4_label *label); struct nfs4_label *label);
extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx); extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
extern void put_nfs_open_context(struct nfs_open_context *ctx); extern void put_nfs_open_context(struct nfs_open_context *ctx);
extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode); extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode);
extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode, struct file *filp); extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode, struct file *filp);
extern void nfs_inode_attach_open_context(struct nfs_open_context *ctx); extern void nfs_inode_attach_open_context(struct nfs_open_context *ctx);
extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx); extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
@ -462,7 +462,7 @@ static inline struct nfs_open_context *nfs_file_open_context(struct file *filp)
return filp->private_data; return filp->private_data;
} }
static inline struct rpc_cred *nfs_file_cred(struct file *file) static inline const struct cred *nfs_file_cred(struct file *file)
{ {
if (file != NULL) { if (file != NULL) {
struct nfs_open_context *ctx = struct nfs_open_context *ctx =

14
include/linux/nfs_xdr.h
View File

@ -270,7 +270,7 @@ struct nfs4_layoutget_res {
struct nfs4_layoutget { struct nfs4_layoutget {
struct nfs4_layoutget_args args; struct nfs4_layoutget_args args;
struct nfs4_layoutget_res res; struct nfs4_layoutget_res res;
struct rpc_cred *cred; const struct cred *cred;
gfp_t gfp_flags; gfp_t gfp_flags;
}; };
@ -309,7 +309,7 @@ struct nfs4_layoutcommit_data {
struct rpc_task task; struct rpc_task task;
struct nfs_fattr fattr; struct nfs_fattr fattr;
struct list_head lseg_list; struct list_head lseg_list;
struct rpc_cred *cred; const struct cred *cred;
struct inode *inode; struct inode *inode;
struct nfs4_layoutcommit_args args; struct nfs4_layoutcommit_args args;
struct nfs4_layoutcommit_res res; struct nfs4_layoutcommit_res res;
@ -334,7 +334,7 @@ struct nfs4_layoutreturn_res {
struct nfs4_layoutreturn { struct nfs4_layoutreturn {
struct nfs4_layoutreturn_args args; struct nfs4_layoutreturn_args args;
struct nfs4_layoutreturn_res res; struct nfs4_layoutreturn_res res;
struct rpc_cred *cred; const struct cred *cred;
struct nfs_client *clp; struct nfs_client *clp;
struct inode *inode; struct inode *inode;
int rpc_status; int rpc_status;
@ -1469,7 +1469,7 @@ enum {
struct nfs_io_completion; struct nfs_io_completion;
struct nfs_pgio_header { struct nfs_pgio_header {
struct inode *inode; struct inode *inode;
struct rpc_cred *cred; const struct cred *cred;
struct list_head pages; struct list_head pages;
struct nfs_page *req; struct nfs_page *req;
struct nfs_writeverf verf; /* Used for writes */ struct nfs_writeverf verf; /* Used for writes */
@ -1529,7 +1529,7 @@ struct nfs_commit_info {
struct nfs_commit_data { struct nfs_commit_data {
struct rpc_task task; struct rpc_task task;
struct inode *inode; struct inode *inode;
struct rpc_cred *cred; const struct cred *cred;
struct nfs_fattr fattr; struct nfs_fattr fattr;
struct nfs_writeverf verf; struct nfs_writeverf verf;
struct list_head pages; /* Coalesced requests we wish to flush */ struct list_head pages; /* Coalesced requests we wish to flush */
@ -1560,7 +1560,7 @@ struct nfs_unlinkdata {
struct nfs_removeres res; struct nfs_removeres res;
struct dentry *dentry; struct dentry *dentry;
wait_queue_head_t wq; wait_queue_head_t wq;
struct rpc_cred *cred; const struct cred *cred;
struct nfs_fattr dir_attr; struct nfs_fattr dir_attr;
long timeout; long timeout;
}; };
@ -1568,7 +1568,7 @@ struct nfs_unlinkdata {
struct nfs_renamedata { struct nfs_renamedata {
struct nfs_renameargs args; struct nfs_renameargs args;
struct nfs_renameres res; struct nfs_renameres res;
struct rpc_cred *cred; const struct cred *cred;
struct inode *old_dir; struct inode *old_dir;
struct dentry *old_dentry; struct dentry *old_dentry;
struct nfs_fattr old_fattr; struct nfs_fattr old_fattr;

18
include/linux/sunrpc/auth.h
View File

@ -67,7 +67,7 @@ struct rpc_cred {
#define RPCAUTH_CRED_HASHED 2 #define RPCAUTH_CRED_HASHED 2
#define RPCAUTH_CRED_NEGATIVE 3 #define RPCAUTH_CRED_NEGATIVE 3
struct rpc_cred *rpc_machine_cred(void); const struct cred *rpc_machine_cred(void);
/* /*
* Client authentication handle * Client authentication handle
@ -196,21 +196,5 @@ struct rpc_cred *get_rpccred(struct rpc_cred *cred)
return NULL; return NULL;
} }
/**
* get_rpccred_rcu - get a reference to a cred using rcu-protected pointer
* @cred: cred of which to take a reference
*
* In some cases, we may have a pointer to a credential to which we
* want to take a reference, but don't already have one. Because these
* objects are freed using RCU, we can access the cr_count while its
* on its way to destruction and only take a reference if it's not already
* zero.
*/
static inline struct rpc_cred *
get_rpccred_rcu(struct rpc_cred *cred)
{
return get_rpccred(cred);
}
#endif /* __KERNEL__ */ #endif /* __KERNEL__ */
#endif /* _LINUX_SUNRPC_AUTH_H */ #endif /* _LINUX_SUNRPC_AUTH_H */

2
include/linux/sunrpc/sched.h
View File

@ -26,7 +26,7 @@ struct rpc_message {
const struct rpc_procinfo *rpc_proc; /* Procedure information */ const struct rpc_procinfo *rpc_proc; /* Procedure information */
void * rpc_argp; /* Arguments */ void * rpc_argp; /* Arguments */
void * rpc_resp; /* Result */ void * rpc_resp; /* Result */
struct rpc_cred * rpc_cred; /* Credentials */ const struct cred * rpc_cred; /* Credentials */
}; };
struct rpc_call_ops; struct rpc_call_ops;

14
net/sunrpc/auth.c
View File

@ -39,15 +39,15 @@ static const struct rpc_authops __rcu *auth_flavors[RPC_AUTH_MAXFLAVOR] = {
static LIST_HEAD(cred_unused); static LIST_HEAD(cred_unused);
static unsigned long number_cred_unused; static unsigned long number_cred_unused;
static struct rpc_cred machine_cred = { static struct cred machine_cred = {
.cr_count = REFCOUNT_INIT(1), .usage = ATOMIC_INIT(1),
}; };
/* /*
* Return the machine_cred pointer to be used whenever * Return the machine_cred pointer to be used whenever
* the a generic machine credential is needed. * the a generic machine credential is needed.
*/ */
struct rpc_cred *rpc_machine_cred(void) const struct cred *rpc_machine_cred(void)
{ {
return &machine_cred; return &machine_cred;
} }
@ -720,11 +720,15 @@ rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags)
} }
static int static int
rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags) rpcauth_bindcred(struct rpc_task *task, const struct cred *cred, int flags)
{ {
struct rpc_rqst *req = task->tk_rqstp; struct rpc_rqst *req = task->tk_rqstp;
struct rpc_cred *new = NULL; struct rpc_cred *new = NULL;
int lookupflags = 0; int lookupflags = 0;
struct rpc_auth *auth = task->tk_client->cl_auth;
struct auth_cred acred = {
.cred = cred,
};
if (flags & RPC_TASK_ASYNC) if (flags & RPC_TASK_ASYNC)
lookupflags |= RPCAUTH_LOOKUP_NEW; lookupflags |= RPCAUTH_LOOKUP_NEW;
@ -733,7 +737,7 @@ rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags)
new = task->tk_op_cred->cr_ops->crbind(task, task->tk_op_cred, new = task->tk_op_cred->cr_ops->crbind(task, task->tk_op_cred,
lookupflags); lookupflags);
else if (cred != NULL && cred != &machine_cred) else if (cred != NULL && cred != &machine_cred)
new = cred->cr_ops->crbind(task, cred, lookupflags); new = auth->au_ops->lookup_cred(auth, &acred, lookupflags);
else if (cred == &machine_cred) else if (cred == &machine_cred)
new = rpcauth_bind_machine_cred(task, lookupflags); new = rpcauth_bind_machine_cred(task, lookupflags);

4
net/sunrpc/clnt.c
View File

@ -1030,7 +1030,7 @@ rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
task->tk_msg.rpc_argp = msg->rpc_argp; task->tk_msg.rpc_argp = msg->rpc_argp;
task->tk_msg.rpc_resp = msg->rpc_resp; task->tk_msg.rpc_resp = msg->rpc_resp;
if (msg->rpc_cred != NULL) if (msg->rpc_cred != NULL)
task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred); task->tk_msg.rpc_cred = get_cred(msg->rpc_cred);
} }
} }
@ -2542,7 +2542,7 @@ struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt,
.rpc_op_cred = cred, .rpc_op_cred = cred,
.callback_ops = (ops != NULL) ? ops : &rpc_default_ops, .callback_ops = (ops != NULL) ? ops : &rpc_default_ops,
.callback_data = data, .callback_data = data,
.flags = flags, .flags = flags | RPC_TASK_NULLCREDS,
}; };
return rpc_run_task(&task_setup_data); return rpc_run_task(&task_setup_data);

2
net/sunrpc/sched.c
View File

@ -1074,7 +1074,7 @@ static void rpc_release_resources_task(struct rpc_task *task)
{ {
xprt_release(task); xprt_release(task);
if (task->tk_msg.rpc_cred) { if (task->tk_msg.rpc_cred) {
put_rpccred(task->tk_msg.rpc_cred); put_cred(task->tk_msg.rpc_cred);
task->tk_msg.rpc_cred = NULL; task->tk_msg.rpc_cred = NULL;
} }
rpc_task_release_client(task); rpc_task_release_client(task);