NFSv4: Add helpers for basic copying of stateids
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
parent
1e3987c305
commit
f597c53790
5 changed files with 38 additions and 36 deletions
|
@ -105,7 +105,7 @@ again:
|
||||||
continue;
|
continue;
|
||||||
if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
|
if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
|
||||||
continue;
|
continue;
|
||||||
if (memcmp(state->stateid.data, stateid->data, sizeof(state->stateid.data)) != 0)
|
if (!nfs4_stateid_match(&state->stateid, stateid))
|
||||||
continue;
|
continue;
|
||||||
get_nfs_open_context(ctx);
|
get_nfs_open_context(ctx);
|
||||||
spin_unlock(&inode->i_lock);
|
spin_unlock(&inode->i_lock);
|
||||||
|
@ -139,8 +139,7 @@ void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
|
||||||
if (delegation != NULL) {
|
if (delegation != NULL) {
|
||||||
spin_lock(&delegation->lock);
|
spin_lock(&delegation->lock);
|
||||||
if (delegation->inode != NULL) {
|
if (delegation->inode != NULL) {
|
||||||
memcpy(delegation->stateid.data, res->delegation.data,
|
nfs4_stateid_copy(&delegation->stateid, &res->delegation);
|
||||||
sizeof(delegation->stateid.data));
|
|
||||||
delegation->type = res->delegation_type;
|
delegation->type = res->delegation_type;
|
||||||
delegation->maxsize = res->maxsize;
|
delegation->maxsize = res->maxsize;
|
||||||
oldcred = delegation->cred;
|
oldcred = delegation->cred;
|
||||||
|
@ -236,8 +235,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
|
||||||
delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
|
delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
|
||||||
if (delegation == NULL)
|
if (delegation == NULL)
|
||||||
return -ENOMEM;
|
return -ENOMEM;
|
||||||
memcpy(delegation->stateid.data, res->delegation.data,
|
nfs4_stateid_copy(&delegation->stateid, &res->delegation);
|
||||||
sizeof(delegation->stateid.data));
|
|
||||||
delegation->type = res->delegation_type;
|
delegation->type = res->delegation_type;
|
||||||
delegation->maxsize = res->maxsize;
|
delegation->maxsize = res->maxsize;
|
||||||
delegation->change_attr = inode->i_version;
|
delegation->change_attr = inode->i_version;
|
||||||
|
@ -250,8 +248,8 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
|
||||||
old_delegation = rcu_dereference_protected(nfsi->delegation,
|
old_delegation = rcu_dereference_protected(nfsi->delegation,
|
||||||
lockdep_is_held(&clp->cl_lock));
|
lockdep_is_held(&clp->cl_lock));
|
||||||
if (old_delegation != NULL) {
|
if (old_delegation != NULL) {
|
||||||
if (memcmp(&delegation->stateid, &old_delegation->stateid,
|
if (nfs4_stateid_match(&delegation->stateid,
|
||||||
sizeof(old_delegation->stateid)) == 0 &&
|
&old_delegation->stateid) &&
|
||||||
delegation->type == old_delegation->type) {
|
delegation->type == old_delegation->type) {
|
||||||
goto out;
|
goto out;
|
||||||
}
|
}
|
||||||
|
@ -708,7 +706,7 @@ int nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
|
||||||
rcu_read_lock();
|
rcu_read_lock();
|
||||||
delegation = rcu_dereference(nfsi->delegation);
|
delegation = rcu_dereference(nfsi->delegation);
|
||||||
if (delegation != NULL) {
|
if (delegation != NULL) {
|
||||||
memcpy(dst->data, delegation->stateid.data, sizeof(dst->data));
|
nfs4_stateid_copy(dst, &delegation->stateid);
|
||||||
ret = 1;
|
ret = 1;
|
||||||
}
|
}
|
||||||
rcu_read_unlock();
|
rcu_read_unlock();
|
||||||
|
|
|
@ -349,6 +349,16 @@ struct nfs4_mount_data;
|
||||||
extern struct svc_version nfs4_callback_version1;
|
extern struct svc_version nfs4_callback_version1;
|
||||||
extern struct svc_version nfs4_callback_version4;
|
extern struct svc_version nfs4_callback_version4;
|
||||||
|
|
||||||
|
static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
|
||||||
|
{
|
||||||
|
memcpy(dst->data, src->data, sizeof(dst->data));
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)
|
||||||
|
{
|
||||||
|
return memcmp(dst->data, src->data, sizeof(dst->data)) == 0;
|
||||||
|
}
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
#define nfs4_close_state(a, b) do { } while (0)
|
#define nfs4_close_state(a, b) do { } while (0)
|
||||||
|
|
|
@ -941,8 +941,8 @@ static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
|
||||||
static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
|
static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
|
||||||
{
|
{
|
||||||
if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
|
if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
|
||||||
memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));
|
nfs4_stateid_copy(&state->stateid, stateid);
|
||||||
memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));
|
nfs4_stateid_copy(&state->open_stateid, stateid);
|
||||||
switch (fmode) {
|
switch (fmode) {
|
||||||
case FMODE_READ:
|
case FMODE_READ:
|
||||||
set_bit(NFS_O_RDONLY_STATE, &state->flags);
|
set_bit(NFS_O_RDONLY_STATE, &state->flags);
|
||||||
|
@ -970,7 +970,7 @@ static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_s
|
||||||
*/
|
*/
|
||||||
write_seqlock(&state->seqlock);
|
write_seqlock(&state->seqlock);
|
||||||
if (deleg_stateid != NULL) {
|
if (deleg_stateid != NULL) {
|
||||||
memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));
|
nfs4_stateid_copy(&state->stateid, deleg_stateid);
|
||||||
set_bit(NFS_DELEGATED_STATE, &state->flags);
|
set_bit(NFS_DELEGATED_STATE, &state->flags);
|
||||||
}
|
}
|
||||||
if (open_stateid != NULL)
|
if (open_stateid != NULL)
|
||||||
|
@ -1001,7 +1001,7 @@ static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stat
|
||||||
|
|
||||||
if (delegation == NULL)
|
if (delegation == NULL)
|
||||||
delegation = &deleg_cur->stateid;
|
delegation = &deleg_cur->stateid;
|
||||||
else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0)
|
else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
|
||||||
goto no_delegation_unlock;
|
goto no_delegation_unlock;
|
||||||
|
|
||||||
nfs_mark_delegation_referenced(deleg_cur);
|
nfs_mark_delegation_referenced(deleg_cur);
|
||||||
|
@ -1062,7 +1062,7 @@ static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
/* Save the delegation */
|
/* Save the delegation */
|
||||||
memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));
|
nfs4_stateid_copy(&stateid, &delegation->stateid);
|
||||||
rcu_read_unlock();
|
rcu_read_unlock();
|
||||||
ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
|
ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
|
||||||
if (ret != 0)
|
if (ret != 0)
|
||||||
|
@ -1225,10 +1225,10 @@ static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *
|
||||||
* Check if we need to update the current stateid.
|
* Check if we need to update the current stateid.
|
||||||
*/
|
*/
|
||||||
if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
|
if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
|
||||||
memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {
|
!nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
|
||||||
write_seqlock(&state->seqlock);
|
write_seqlock(&state->seqlock);
|
||||||
if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
|
if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
|
||||||
memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));
|
nfs4_stateid_copy(&state->stateid, &state->open_stateid);
|
||||||
write_sequnlock(&state->seqlock);
|
write_sequnlock(&state->seqlock);
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
|
@ -1297,8 +1297,7 @@ static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs
|
||||||
if (IS_ERR(opendata))
|
if (IS_ERR(opendata))
|
||||||
return PTR_ERR(opendata);
|
return PTR_ERR(opendata);
|
||||||
opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
|
opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
|
||||||
memcpy(opendata->o_arg.u.delegation.data, stateid->data,
|
nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
|
||||||
sizeof(opendata->o_arg.u.delegation.data));
|
|
||||||
ret = nfs4_open_recover(opendata, state);
|
ret = nfs4_open_recover(opendata, state);
|
||||||
nfs4_opendata_put(opendata);
|
nfs4_opendata_put(opendata);
|
||||||
return ret;
|
return ret;
|
||||||
|
@ -1363,8 +1362,7 @@ static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
|
||||||
|
|
||||||
data->rpc_status = task->tk_status;
|
data->rpc_status = task->tk_status;
|
||||||
if (data->rpc_status == 0) {
|
if (data->rpc_status == 0) {
|
||||||
memcpy(data->o_res.stateid.data, data->c_res.stateid.data,
|
nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
|
||||||
sizeof(data->o_res.stateid.data));
|
|
||||||
nfs_confirm_seqid(&data->owner->so_seqid, 0);
|
nfs_confirm_seqid(&data->owner->so_seqid, 0);
|
||||||
renew_lease(data->o_res.server, data->timestamp);
|
renew_lease(data->o_res.server, data->timestamp);
|
||||||
data->rpc_done = 1;
|
data->rpc_done = 1;
|
||||||
|
@ -1924,7 +1922,7 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
|
||||||
} else if (state != NULL) {
|
} else if (state != NULL) {
|
||||||
nfs4_select_rw_stateid(&arg.stateid, state, current->files, current->tgid);
|
nfs4_select_rw_stateid(&arg.stateid, state, current->files, current->tgid);
|
||||||
} else
|
} else
|
||||||
memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
|
nfs4_stateid_copy(&arg.stateid, &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);
|
||||||
if (status == 0 && state != NULL)
|
if (status == 0 && state != NULL)
|
||||||
|
@ -3989,7 +3987,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
|
||||||
data->args.stateid = &data->stateid;
|
data->args.stateid = &data->stateid;
|
||||||
data->args.bitmask = server->attr_bitmask;
|
data->args.bitmask = server->attr_bitmask;
|
||||||
nfs_copy_fh(&data->fh, NFS_FH(inode));
|
nfs_copy_fh(&data->fh, NFS_FH(inode));
|
||||||
memcpy(&data->stateid, stateid, sizeof(data->stateid));
|
nfs4_stateid_copy(&data->stateid, stateid);
|
||||||
data->res.fattr = &data->fattr;
|
data->res.fattr = &data->fattr;
|
||||||
data->res.server = server;
|
data->res.server = server;
|
||||||
nfs_fattr_init(data->res.fattr);
|
nfs_fattr_init(data->res.fattr);
|
||||||
|
@ -4172,9 +4170,8 @@ static void nfs4_locku_done(struct rpc_task *task, void *data)
|
||||||
return;
|
return;
|
||||||
switch (task->tk_status) {
|
switch (task->tk_status) {
|
||||||
case 0:
|
case 0:
|
||||||
memcpy(calldata->lsp->ls_stateid.data,
|
nfs4_stateid_copy(&calldata->lsp->ls_stateid,
|
||||||
calldata->res.stateid.data,
|
&calldata->res.stateid);
|
||||||
sizeof(calldata->lsp->ls_stateid.data));
|
|
||||||
renew_lease(calldata->server, calldata->timestamp);
|
renew_lease(calldata->server, calldata->timestamp);
|
||||||
break;
|
break;
|
||||||
case -NFS4ERR_BAD_STATEID:
|
case -NFS4ERR_BAD_STATEID:
|
||||||
|
@ -4387,8 +4384,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
|
||||||
goto out;
|
goto out;
|
||||||
}
|
}
|
||||||
if (data->rpc_status == 0) {
|
if (data->rpc_status == 0) {
|
||||||
memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
|
nfs4_stateid_copy(&data->lsp->ls_stateid, &data->res.stateid);
|
||||||
sizeof(data->lsp->ls_stateid.data));
|
|
||||||
data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
|
data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
|
||||||
renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
|
renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
|
||||||
}
|
}
|
||||||
|
@ -6292,7 +6288,7 @@ static bool nfs41_match_stateid(const nfs4_stateid *s1,
|
||||||
static bool nfs4_match_stateid(const nfs4_stateid *s1,
|
static bool nfs4_match_stateid(const nfs4_stateid *s1,
|
||||||
const nfs4_stateid *s2)
|
const nfs4_stateid *s2)
|
||||||
{
|
{
|
||||||
return memcmp(s1->data, s2->data, sizeof(s1->data)) == 0;
|
return nfs4_stateid_match(s1, s2);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -895,7 +895,7 @@ void nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owne
|
||||||
|
|
||||||
do {
|
do {
|
||||||
seq = read_seqbegin(&state->seqlock);
|
seq = read_seqbegin(&state->seqlock);
|
||||||
memcpy(dst, &state->stateid, sizeof(*dst));
|
nfs4_stateid_copy(dst, &state->stateid);
|
||||||
} while (read_seqretry(&state->seqlock, seq));
|
} while (read_seqretry(&state->seqlock, seq));
|
||||||
if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
|
if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
|
||||||
return;
|
return;
|
||||||
|
@ -903,7 +903,7 @@ void nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owne
|
||||||
spin_lock(&state->state_lock);
|
spin_lock(&state->state_lock);
|
||||||
lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
|
lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
|
||||||
if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
|
if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
|
||||||
memcpy(dst, &lsp->ls_stateid, sizeof(*dst));
|
nfs4_stateid_copy(dst, &lsp->ls_stateid);
|
||||||
spin_unlock(&state->state_lock);
|
spin_unlock(&state->state_lock);
|
||||||
nfs4_put_lock_state(lsp);
|
nfs4_put_lock_state(lsp);
|
||||||
}
|
}
|
||||||
|
@ -1126,7 +1126,7 @@ void nfs_inode_find_state_and_recover(struct inode *inode,
|
||||||
continue;
|
continue;
|
||||||
if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
|
if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
|
||||||
continue;
|
continue;
|
||||||
if (memcmp(state->stateid.data, stateid->data, sizeof(state->stateid.data)) != 0)
|
if (!nfs4_stateid_match(&state->stateid, stateid))
|
||||||
continue;
|
continue;
|
||||||
nfs4_state_mark_reclaim_nograce(clp, state);
|
nfs4_state_mark_reclaim_nograce(clp, state);
|
||||||
found = true;
|
found = true;
|
||||||
|
|
|
@ -499,7 +499,7 @@ pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new,
|
||||||
oldseq = be32_to_cpu(lo->plh_stateid.stateid.seqid);
|
oldseq = be32_to_cpu(lo->plh_stateid.stateid.seqid);
|
||||||
newseq = be32_to_cpu(new->stateid.seqid);
|
newseq = be32_to_cpu(new->stateid.seqid);
|
||||||
if ((int)(newseq - oldseq) > 0) {
|
if ((int)(newseq - oldseq) > 0) {
|
||||||
memcpy(&lo->plh_stateid, &new->stateid, sizeof(new->stateid));
|
nfs4_stateid_copy(&lo->plh_stateid, new);
|
||||||
if (update_barrier) {
|
if (update_barrier) {
|
||||||
u32 new_barrier = be32_to_cpu(new->stateid.seqid);
|
u32 new_barrier = be32_to_cpu(new->stateid.seqid);
|
||||||
|
|
||||||
|
@ -549,11 +549,10 @@ pnfs_choose_layoutget_stateid(nfs4_stateid *dst, struct pnfs_layout_hdr *lo,
|
||||||
|
|
||||||
do {
|
do {
|
||||||
seq = read_seqbegin(&open_state->seqlock);
|
seq = read_seqbegin(&open_state->seqlock);
|
||||||
memcpy(dst->data, open_state->stateid.data,
|
nfs4_stateid_copy(dst, &open_state->stateid);
|
||||||
sizeof(open_state->stateid.data));
|
|
||||||
} while (read_seqretry(&open_state->seqlock, seq));
|
} while (read_seqretry(&open_state->seqlock, seq));
|
||||||
} else
|
} else
|
||||||
memcpy(dst->data, lo->plh_stateid.data, sizeof(lo->plh_stateid.data));
|
nfs4_stateid_copy(dst, &lo->plh_stateid);
|
||||||
spin_unlock(&lo->plh_inode->i_lock);
|
spin_unlock(&lo->plh_inode->i_lock);
|
||||||
dprintk("<-- %s\n", __func__);
|
dprintk("<-- %s\n", __func__);
|
||||||
return status;
|
return status;
|
||||||
|
@ -1527,8 +1526,7 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
|
||||||
end_pos = nfsi->layout->plh_lwb;
|
end_pos = nfsi->layout->plh_lwb;
|
||||||
nfsi->layout->plh_lwb = 0;
|
nfsi->layout->plh_lwb = 0;
|
||||||
|
|
||||||
memcpy(&data->args.stateid.data, nfsi->layout->plh_stateid.data,
|
nfs4_stateid_copy(&data->args.stateid, &nfsi->layout->plh_stateid);
|
||||||
sizeof(nfsi->layout->plh_stateid.data));
|
|
||||||
spin_unlock(&inode->i_lock);
|
spin_unlock(&inode->i_lock);
|
||||||
|
|
||||||
data->args.inode = inode;
|
data->args.inode = inode;
|
||||||
|
|
Loading…
Reference in a new issue