Skip to contentSkip to conversation

nfsd: fix error handling in nfs4_set_delegation()

PATCH In review Andrew Elble 2 participants 5 messages May 9, 2018 – May 23, 2018

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 nfsd: fix error handling in nfs4_set_delegation()

I noticed a memory corruption crash in nfsd in
4.17-rc1. This patch corrects the issue.

Fix to return error if the delegation couldn't be hashed or there was a recall in progress. Use the existing error path instead of destroy_unhashed_delegation() for readability. Set the fields of the delegation to indicate that it does not need to be recalled.

Fixes 353601e7d323c ("nfsd: create a separate lease for each delegation")

---
v2: typo in changelog, set delegation recall-suppression

 fs/nfsd/nfs4state.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)
fs/nfsd/nfs4state.c +15 -1
index 71b87738c015..20463944cd61 100644
@@ -4372,12 +4372,26 @@ static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp,
 		status = -EAGAIN;
 	else
 		status = hash_delegation_locked(dp, fp);
+	/*
+	 * This delegation is doomed, tell the recall logic
+	 * that it's being destroyed here.
+	 */
+
+	if (status) {
+		dp->dl_time++;
+		list_del_init(&dp->dl_recall_lru);
+		dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
+	}
 	spin_unlock(&fp->fi_lock);
 	spin_unlock(&state_lock);
 
 	if (status)
-		destroy_unhashed_deleg(dp);
+		goto out_unlock;
+
 	return dp;
+
+out_unlock:
+	vfs_setlease(fp->fi_deleg_file, F_UNLCK, NULL, (void **)&dp);
 out_clnt_odstate:
 	put_clnt_odstate(dp->dl_clnt_odstate);
 out_stid:
Signature · 1 line
1.8.3.1
#1 lore raw
Quoted 23 lines · Andrew Elble

I noticed a memory corruption crash in nfsd in
4.17-rc1. This patch corrects the issue.

Fix to return error if the delegation couldn't be hashed or there was a recall in progress. Use the existing error path instead of destroy_unhashed_delegation() for readability. Set the fields of the delegation to indicate that it does not need to be recalled.

Fixes 353601e7d323c ("nfsd: create a separate lease for each delegation")

---
v2: typo in changelog, set delegation recall-suppression

 fs/nfsd/nfs4state.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)
fs/nfsd/nfs4state.c +0 -0
index 71b87738c015..20463944cd61 100644
@@ -4372,12 +4372,26 @@ static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp,
 		status = -EAGAIN;
 	else
 		status = hash_delegation_locked(dp, fp);

fs/nfsd/nfs4state.c static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, · line 4384

Quoted 10 lines
fs/nfsd/nfs4state.c +10 -0
+	/*
+	 * This delegation is doomed, tell the recall logic
+	 * that it's being destroyed here.
+	 */
+
+	if (status) {
+		dp->dl_time++;
+		list_del_init(&dp->dl_recall_lru);
+		dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
+	}

I'm trying to figure out if this fixes an actual bug. The code should be able to deal with a callback on an already unhashed delegation, so I think you're right it would at worst just be an unnecessary recall. This won't catch every such case (could be that nfsd4_cb_recall_prepare already ran and we're too late), so I wonder if this is worth it.

More interesting to me is what exactly it would take to hit this case.... Another thread would have to have succesfully hashed a delegation for this client and file to make our hash_delegation_locked fail. So there would be two leases for the same file and client, but with different delegation pointers as the fl_owner. I *think* we handle that OK. But it was likely problematic previously when we were still using the file pointer as the fl_owner.

--b.

Quoted 16 lines
fs/nfsd/nfs4state.c +5 -1
 	spin_unlock(&fp->fi_lock);
 	spin_unlock(&state_lock);
 
 	if (status)
-		destroy_unhashed_deleg(dp);
+		goto out_unlock;
+
 	return dp;
+
+out_unlock:
+	vfs_setlease(fp->fi_deleg_file, F_UNLCK, NULL, (void **)&dp);
 out_clnt_odstate:
 	put_clnt_odstate(dp->dl_clnt_odstate);
 out_stid:
Signature · 1 line
1.8.3.1
#2 lore raw
Quoted 15 lines

fs/nfsd/nfs4state.c static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, · line 4384

Quoted 11 lines
fs/nfsd/nfs4state.c +10 -0
+	/*
+	 * This delegation is doomed, tell the recall logic
+	 * that it's being destroyed here.
+	 */
+
+	if (status) {
+		dp->dl_time++;
+		list_del_init(&dp->dl_recall_lru);
+		dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
+	}

I'm trying to figure out if this fixes an actual bug. The code should be able to deal with a callback on an already unhashed delegation, so I think you're right it would at worst just be an unnecessary recall.

But an 'normal' unhashed delegation would have a persistent refcount, this one would not. If the recall code gets a hold of it, it will place it on nn->del_recall_lru, and then free it in nfsd4_cb_recall_release()?

Quoted 10 lines

This won't catch every such case (could be that nfsd4_cb_recall_prepare already ran and we're too late), so I wonder if this is worth it.

More interesting to me is what exactly it would take to hit this case.... Another thread would have to have succesfully hashed a delegation for this client and file to make our hash_delegation_locked fail. So there would be two leases for the same file and client, but with different delegation pointers as the fl_owner. I *think* we handle that OK. But it was likely problematic previously when we were still using the file pointer as the fl_owner.

I'm thinking this is more easily hit via fp->fi_had_conflict, if a lease break comes in at the right time?

Thanks,

Andy

Signature · 5 lines
Andrew W. Elble
[email protected]
Infrastructure Engineer, Communications Technical Lead
Rochester Institute of Technology
PGP: BFAD 8461 4CCF DC95 DA2C B0EB 965B 082E 863E C912
#3 lore raw
Quoted 16 lines · Andrew W Elble
Quoted 15 lines

fs/nfsd/nfs4state.c static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, · line 4384

Quoted 11 lines
fs/nfsd/nfs4state.c +10 -0
+	/*
+	 * This delegation is doomed, tell the recall logic
+	 * that it's being destroyed here.
+	 */
+
+	if (status) {
+		dp->dl_time++;
+		list_del_init(&dp->dl_recall_lru);
+		dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
+	}

I'm trying to figure out if this fixes an actual bug. The code should be able to deal with a callback on an already unhashed delegation, so I think you're right it would at worst just be an unnecessary recall.

Quoted 3 lines

But an 'normal' unhashed delegation would have a persistent refcount, this one would not. If the recall code gets a hold of it, it will place it on nn->del_recall_lru, and then free it in nfsd4_cb_recall_release()?

Sounds right. Do you see any bug there?

Quoted 11 lines
Quoted 10 lines

This won't catch every such case (could be that nfsd4_cb_recall_prepare already ran and we're too late), so I wonder if this is worth it.

More interesting to me is what exactly it would take to hit this case.... Another thread would have to have succesfully hashed a delegation for this client and file to make our hash_delegation_locked fail. So there would be two leases for the same file and client, but with different delegation pointers as the fl_owner. I *think* we handle that OK. But it was likely problematic previously when we were still using the file pointer as the fl_owner.

Quoted 2 lines

I'm thinking this is more easily hit via fp->fi_had_conflict, if a lease break comes in at the right time?

Could be.

--b.

#4 lore raw
Quoted 6 lines
Quoted 4 lines

But an 'normal' unhashed delegation would have a persistent refcount, this one would not. If the recall code gets a hold of it, it will place it on nn->del_recall_lru, and then free it in nfsd4_cb_recall_release()?

Sounds right. Do you see any bug there?

I'd expect it to crash in the laundromat. Unfortunately the larger test rig that I'd normally use to try to hit this is occupied doing other things
- I may have to come back to this later.

Thanks,

Andy