From: Anna Schumaker <[email protected]>
Moving all of this into a new function removes the need for cramped
indentation, making the code overall easier to look at. I also take
this chance to switch copy recovery over to using
nfs4_stateid_match_other()
Signed-off-by: Anna Schumaker <[email protected]>
---
fs/nfs/nfs4state.c | 83 ++++++++++++++++++++++++++--------------------
1 file changed, 47 insertions(+), 36 deletions(-)
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 3df0eb52da1c..aa46a3216d60 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1547,10 +1547,51 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_
return status;
}
+static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
+ const struct nfs4_state_recovery_ops *ops)
+{
+ struct nfs4_lock_state *lock;
+ int status;
+
+ status = ops->recover_open(sp, state);
+ if (status < 0)
+ return status;
+
+ status = nfs4_reclaim_locks(state, ops);
+ if (status < 0)
+ return status;
+
+ if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
+ spin_lock(&state->state_lock);
+ list_for_each_entry(lock, &state->lock_states, ls_locks) {
+ if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
+ pr_warn_ratelimited("NFS: %s: Lock reclaim failed!\n", __func__);
+ }
+ spin_unlock(&state->state_lock);
+ }
+
+#ifdef CONFIG_NFS_V4_2
+ if (test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags)) {
+ struct nfs4_copy_state *copy;
+ spin_lock(&sp->so_server->nfs_client->cl_lock);
+ list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
+ if (nfs4_stateid_match_other(&state->stateid, ©->parent_state->stateid))
+ continue;
+ copy->flags = 1;
+ complete(©->completion);
+ break;
+ }
+ spin_unlock(&sp->so_server->nfs_client->cl_lock);
+ }
+#endif /* CONFIG_NFS_V4_2 */
+
+ clear_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
+ return status;
+}
+
static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
{
struct nfs4_state *state;
- struct nfs4_lock_state *lock;
int status = 0;
/* Note: we rely on the sp->so_states list being ordered
@@ -1573,43 +1614,13 @@ static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs
continue;
atomic_inc(&state->count);
spin_unlock(&sp->so_lock);
- status = ops->recover_open(sp, state);
+ status = __nfs4_reclaim_open_state(sp, state, ops);
if (status >= 0) {
- status = nfs4_reclaim_locks(state, ops);
- if (status >= 0) {
- if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
- spin_lock(&state->state_lock);
- list_for_each_entry(lock, &state->lock_states, ls_locks) {
- if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
- pr_warn_ratelimited("NFS: "
- "%s: Lock reclaim "
- "failed!\n", __func__);
- }
- spin_unlock(&state->state_lock);
- }
- clear_bit(NFS_STATE_RECLAIM_NOGRACE,
- &state->flags);
-#ifdef CONFIG_NFS_V4_2
- if (test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags)) {
- struct nfs4_copy_state *copy;
-
- spin_lock(&sp->so_server->nfs_client->cl_lock);
- list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
- if (memcmp(&state->stateid.other, ©->parent_state->stateid.other, NFS4_STATEID_SIZE))
- continue;
- copy->flags = 1;
- complete(©->completion);
- printk("AGLO: server rebooted waking up the copy\n");
- break;
- }
- spin_unlock(&sp->so_server->nfs_client->cl_lock);
- }
-#endif /* CONFIG_NFS_V4_2 */
- nfs4_put_open_state(state);
- spin_lock(&sp->so_lock);
- goto restart;
- }
+ nfs4_put_open_state(state);
+ spin_lock(&sp->so_lock);
+ goto restart;
}
+
switch (status) {
default:
printk(KERN_ERR "NFS: %s: unhandled error %d\n",
--
2.18.0
From: Anna Schumaker <[email protected]>
Most places in the kernel tend to line up cases with the switch to
reduce indentation, so move this over to match that style.
Additionally, I handle the (status >= 0) case in the switch so that we
only "goto restart" from a single place after error handling.
Signed-off-by: Anna Schumaker <[email protected]>
---
fs/nfs/nfs4state.c | 70 ++++++++++++++++++++++------------------------
1 file changed, 33 insertions(+), 37 deletions(-)
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index aa46a3216d60..8a399dc17e19 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1615,46 +1615,42 @@ static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs
atomic_inc(&state->count);
spin_unlock(&sp->so_lock);
status = __nfs4_reclaim_open_state(sp, state, ops);
- if (status >= 0) {
- nfs4_put_open_state(state);
- spin_lock(&sp->so_lock);
- goto restart;
- }
switch (status) {
- default:
- printk(KERN_ERR "NFS: %s: unhandled error %d\n",
- __func__, status);
- /* Fall through */
- case -ENOENT:
- case -ENOMEM:
- case -EACCES:
- case -EROFS:
- case -EIO:
- case -ESTALE:
- /* Open state on this file cannot be recovered */
- nfs4_state_mark_recovery_failed(state, status);
- break;
- case -EAGAIN:
- ssleep(1);
- /* Fall through */
- case -NFS4ERR_ADMIN_REVOKED:
- case -NFS4ERR_STALE_STATEID:
- case -NFS4ERR_OLD_STATEID:
- case -NFS4ERR_BAD_STATEID:
- case -NFS4ERR_RECLAIM_BAD:
- case -NFS4ERR_RECLAIM_CONFLICT:
- nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
+ default:
+ if (status >= 0)
break;
- case -NFS4ERR_EXPIRED:
- case -NFS4ERR_NO_GRACE:
- nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
- case -NFS4ERR_STALE_CLIENTID:
- case -NFS4ERR_BADSESSION:
- case -NFS4ERR_BADSLOT:
- case -NFS4ERR_BAD_HIGH_SLOT:
- case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
- goto out_err;
+ printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
+ /* Fall through */
+ case -ENOENT:
+ case -ENOMEM:
+ case -EACCES:
+ case -EROFS:
+ case -EIO:
+ case -ESTALE:
+ /* Open state on this file cannot be recovered */
+ nfs4_state_mark_recovery_failed(state, status);
+ break;
+ case -EAGAIN:
+ ssleep(1);
+ /* Fall through */
+ case -NFS4ERR_ADMIN_REVOKED:
+ case -NFS4ERR_STALE_STATEID:
+ case -NFS4ERR_OLD_STATEID:
+ case -NFS4ERR_BAD_STATEID:
+ case -NFS4ERR_RECLAIM_BAD:
+ case -NFS4ERR_RECLAIM_CONFLICT:
+ nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
+ break;
+ case -NFS4ERR_EXPIRED:
+ case -NFS4ERR_NO_GRACE:
+ nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
+ case -NFS4ERR_STALE_CLIENTID:
+ case -NFS4ERR_BADSESSION:
+ case -NFS4ERR_BADSLOT:
+ case -NFS4ERR_BAD_HIGH_SLOT:
+ case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
+ goto out_err;
}
nfs4_put_open_state(state);
spin_lock(&sp->so_lock);
--
2.18.0
From: Anna Schumaker <[email protected]>
This is to match kernel coding style for switch statements.
Signed-off-by: Anna Schumaker <[email protected]>
---
fs/nfs/nfs4state.c | 64 +++++++++++++++++++++++-----------------------
1 file changed, 32 insertions(+), 32 deletions(-)
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 8a399dc17e19..816f526bbcb3 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1800,38 +1800,38 @@ static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
{
switch (error) {
- case 0:
- break;
- case -NFS4ERR_CB_PATH_DOWN:
- nfs40_handle_cb_pathdown(clp);
- break;
- case -NFS4ERR_NO_GRACE:
- nfs4_state_end_reclaim_reboot(clp);
- break;
- case -NFS4ERR_STALE_CLIENTID:
- set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
- nfs4_state_start_reclaim_reboot(clp);
- break;
- case -NFS4ERR_EXPIRED:
- set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
- nfs4_state_start_reclaim_nograce(clp);
- break;
- case -NFS4ERR_BADSESSION:
- case -NFS4ERR_BADSLOT:
- case -NFS4ERR_BAD_HIGH_SLOT:
- case -NFS4ERR_DEADSESSION:
- case -NFS4ERR_SEQ_FALSE_RETRY:
- case -NFS4ERR_SEQ_MISORDERED:
- set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
- /* Zero session reset errors */
- break;
- case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
- set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
- break;
- default:
- dprintk("%s: failed to handle error %d for server %s\n",
- __func__, error, clp->cl_hostname);
- return error;
+ case 0:
+ break;
+ case -NFS4ERR_CB_PATH_DOWN:
+ nfs40_handle_cb_pathdown(clp);
+ break;
+ case -NFS4ERR_NO_GRACE:
+ nfs4_state_end_reclaim_reboot(clp);
+ break;
+ case -NFS4ERR_STALE_CLIENTID:
+ set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
+ nfs4_state_start_reclaim_reboot(clp);
+ break;
+ case -NFS4ERR_EXPIRED:
+ set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
+ nfs4_state_start_reclaim_nograce(clp);
+ break;
+ case -NFS4ERR_BADSESSION:
+ case -NFS4ERR_BADSLOT:
+ case -NFS4ERR_BAD_HIGH_SLOT:
+ case -NFS4ERR_DEADSESSION:
+ case -NFS4ERR_SEQ_FALSE_RETRY:
+ case -NFS4ERR_SEQ_MISORDERED:
+ set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
+ /* Zero session reset errors */
+ break;
+ case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
+ set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
+ break;
+ default:
+ dprintk("%s: failed to handle error %d for server %s\n",
+ __func__, error, clp->cl_hostname);
+ return error;
}
dprintk("%s: handled error %d for server %s\n", __func__, error,
clp->cl_hostname);
--
2.18.0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