locks: ignore same lock in blocked_lock_hash
Subsystems (2)
Jeff Layton
maintainerPATCH 1/1 locks: ignore same lock in blocked_lock_hash
Andreas reported that he was seeing the tdbtorture test fail in some cases with -EDEADLCK when it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.
If posix_locks_deadlock() fails to find a deadlock, the caller_fl will be passed to __locks_insert_block(), and this wakes up all locks that are blocked on caller_fl, clearing the fl_blocker link.
So if posix_locks_deadlock() finds caller_fl while searching for a deadlock, it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.
More details here: https://bugzilla.kernel.org/show_bug.cgi?id=202975
--- fs/locks.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/locks.c +4 -0
@@ -1023,6 +1023,10 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )return 0 ; + +if (caller_fl == block_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; }
Signature · 1 line
2.20.1
Quoted 9 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.
Quoted 5 lines
So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock, it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.More details here: https://bugzilla.kernel.org/show_bug.cgi?id=202975
There is a weak pattern of using
URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Quoted 15 lines
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 4 ++++ 1 file changed, 4 insertions(+)fs/locks.c +0
-0
fs/locks.c static int posix_locks_deadlock(struct file_lock *caller_fl, · line 1029
Quoted 7 lines
fs/locks.c +4
-0@@ -1023,6 +1023,10 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )return 0 ; + +if (caller_fl == block_fl) +return 0 ; +
I would always write this with the value being tested first, and the value it is being tested against second (and yes, I know that equality is mathematically symmetric).
if (block_fl == caller_fl)
return 0;
But .... whatever. At least your ordering matches the posix_same_owner() below, and consistency is a good thing too.
Thanks,
NeilBrown
Quoted 5 lines
fs/locks.c +0
-0if (posix_same_owner (caller_fl, block_fl))return 1 ; }Signature · 1 line
2.20.1
Quoted 11 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock,
I'm feeling dense. Could you step me through the scenario in a little more detail?
Also, how do we know this catches every such case?
And why aren't we unhashing blocks when we wake them up?
--b.
Quoted 31 lines
it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.
More details here: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 4 ++++ 1 file changed, 4 insertions(+)fs/locks.c +4
-0@@ -1023,6 +1023,10 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )return 0 ; + +if (caller_fl == block_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; }Signature · 1 line
2.20.1
Quoted 10 lines · J. Bruce Fields
Quoted 9 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.
Quoted 5 lines
Quoted 2 lines
So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock,I'm feeling dense. Could you step me through the scenario in a little more detail?
Three processes: A, B, C. One byte in one file: X
A gets a read lock on X. Doesn't block, so nothing goes in the hash
table.
B gets a read lock on X. Doesn't block.
C tries to get a write lock on X. It cannot so it can block on either A
or B. It chooses B. It check if this might cause a deadlock, but the hash is empty so it doesn't. It gets added to the hash. "C -> B"
A tries to get a write lock on X. It cannot because B has a read lock,
so it needs to block on B, or some child. C is a child and A's request conflicts with C's request, so A blocks on C.
It first checks: Does A->C cause a loop in the hash-table? No. So it proceeds to block and adds "A->C" to the hash table.
B drops its read lock. This wakes up the first child: C.
C tries (again) to get a write lock on X. It cannot because A still
holds a read lock, so it will have to block on A. First it must check if "C->A" will cause a loop in the hash-table ... Yes it will because "A->C" is already there - error!
This is a false-positive because the very next thing to be done after posix_locks_deadlock() (while still holding all spinlocks), is __locks_insert_block(C->A) which calls __locks_wake_up_blocks(C) which calls __locks_delete_block() for any pending block ??->C and so will remove A->C from the hash.
Maybe we could call __locks_wake_up_block() *before* calling posix_locks_deadlock(). That *might* make more sense.
Quoted 2 lines
Also, how do we know this catches every such case?
The only links in the hash table that are about to be removed are those that record that something is blocked by C (the lock we are trying to get). So these are the only ones that it is reasonable to special-case in posix_locks_deadlock().
Quoted 2 lines
And why aren't we unhashing blocks when we wake them up?
We do - that is exactly when we unhash them. The problem is they we wake them up *after* we check for errors, rather than before.
Thanks,
NeilBrown
Quoted 34 lines
--b.
Quoted 31 lines
it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.
More details here: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 4 ++++ 1 file changed, 4 insertions(+)fs/locks.c +4
-0@@ -1023,6 +1023,10 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )return 0 ; + +if (caller_fl == block_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; }Signature · 1 line
2.20.1
Quoted 61 lines · NeilBrown
Quoted 10 lines · J. Bruce Fields
Quoted 9 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.Quoted 5 lines
Quoted 2 lines
So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock,I'm feeling dense. Could you step me through the scenario in a little more detail?
Three processes: A, B, C. One byte in one file: X
A gets a read lock on X. Doesn't block, so nothing goes in the hash
table.B gets a read lock on X. Doesn't block.
C tries to get a write lock on X. It cannot so it can block on either A
or B. It chooses B. It check if this might cause a deadlock, but the hash is empty so it doesn't. It gets added to the hash. "C -> B"A tries to get a write lock on X. It cannot because B has a read lock,
so it needs to block on B, or some child. C is a child and A's request conflicts with C's request, so A blocks on C.
It first checks: DoesA->Ccause a loop in the hash-table? No. So it proceeds to block and adds "A->C" to the hash table.B drops its read lock. This wakes up the first child: C.
C tries (again) to get a write lock on X. It cannot because A still
holds a read lock, so it will have to block on A. First it must check if "C->A" will cause a loop in the hash-table ... Yes it will because "A->C" is already there - error!This is a false-positive because the very next thing to be done after
posix_locks_deadlock()(while still holding all spinlocks), is__locks_insert_block(C->A)which calls__locks_wake_up_blocks(C)which calls__locks_delete_block()for any pending block ??->C and so will removeA->Cfrom the hash.Maybe we could call
__locks_wake_up_block()*before* callingposix_locks_deadlock(). That *might* make more sense.Quoted 2 lines
Also, how do we know this catches every such case?
The only links in the hash table that are about to be removed are those that record that something is blocked by C (the lock we are trying to get). So these are the only ones that it is reasonable to special-case in
posix_locks_deadlock().Quoted 1 line
Quoted 4 lines
Quoted 1 line
And why aren't we unhashing blocks when we wake them up?
We do - that is exactly when we unhash them. The problem is they we wake them up *after* we check for errors, rather than before.
Thanks!
OK, somehow I overlooked __locks_wake_up_blocks->__locks_delete_block->locks_delete_global_block.
And I missed that all this was happening while still under the blocked_lock_lock, so we don't have to worry about other tasks leaving locks in this state.
It's possible I'm still being a little dense, but the new check could really use a careful comment (maybe even as detailed as the above).
--b.
Jeff Layton
maintainerPATCH v2 1/1 locks: ignore same lock in blocked_lock_hash
Andreas reported that he was seeing the tdbtorture test fail in some cases with -EDEADLCK when it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.
If posix_locks_deadlock() fails to find a deadlock, the caller_fl will be passed to __locks_insert_block(), and this wakes up all locks that are blocked on caller_fl, clearing the fl_blocker link.
So if posix_locks_deadlock() finds caller_fl while searching for a deadlock, it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.
URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
--- fs/locks.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
fs/locks.c +13 -0
@@ -1023,6 +1023,19 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )return 0 ; + +/* +* It's possible that we're retrying this lock request after +* another task is has blocked on it. A lock request can't +* block itself, and any locks that are blocked on it will +* also be awoken soon (and have their fl_blocker pointer +* cleared). Any dependency chain that contains the request +* itself is therefore about to be broken, so we can safely +* ignore it. +*/ +if (block_fl == caller_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; }
Signature · 1 line
2.20.1
The patch title
locks: ignore same lock in blocked_lock_hash
is a bit misleading the lock isn't in the hash, but it is linked from something that is. Maybe
locks: ignore same lock in posix_locks_deadlock()
??
Quoted 30 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock, it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)fs/locks.c +0
-0@@ -1023,6 +1023,19 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )
fs/locks.c static int posix_locks_deadlock(struct file_lock *caller_fl, · line 1034
Quoted 10 lines
fs/locks.c +9
-0return 0 ; + +/* +* It's possible that we're retrying this lock request after +* another task is has blocked on it. A lock request can't +* block itself, and any locks that are blocked on it will +* also be awoken soon (and have their fl_blocker pointer +* cleared). Any dependency chain that contains the request +* itself is therefore about to be broken, so we can safely +* ignore it.
That first sentence isn't working for me .... maybe remove the "is" ??
Thanks,
NeilBrown
Quoted 9 lines
fs/locks.c +4
-0+*/ +if (block_fl == caller_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; }Signature · 1 line
2.20.1
Quoted 57 lines · NeilBrown
The patch title
locks: ignore same lock inblocked_lock_hashis a bit misleading the lock isn't in the hash, but it is linked from something that is. Maybe
locks: ignore same lock in
posix_locks_deadlock()??
Quoted 30 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock, it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)fs/locks.c +0
-0@@ -1023,6 +1023,19 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )fs/locks.c static int posix_locks_deadlock(struct file_lock *caller_fl, · line 1034
Quoted 10 lines
fs/locks.c +9
-0return 0 ; + +/* +* It's possible that we're retrying this lock request after +* another task is has blocked on it. A lock request can't +* block itself, and any locks that are blocked on it will +* also be awoken soon (and have their fl_blocker pointer +* cleared). Any dependency chain that contains the request +* itself is therefore about to be broken, so we can safely +* ignore it. That first sentence isn't working for me .... maybe remove the "is" ??
Quoted 13 lines
Thanks,
NeilBrownQuoted 9 lines
fs/locks.c +4
-1+*/ +if (block_fl == caller_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; } --2.20.1
Makes sense. That said, I think I'm starting to like your earlier idea of just waking up any locks blocked on this request prior to the deadlock check. I've tested that and it also fixes this, and may be a bit more efficient. I'll follow up with a v3 patch that does that.
Thanks,
Signature · 1 line
Jeff Layton <[email protected]>
Jeff Layton
maintainerPATCH v3 1/1 locks: wake any locks blocked on request before deadlock check
Andreas reported that he was seeing the tdbtorture test fail in some cases with -EDEADLCK when it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.
While we remove the request from the blocked_lock_hash prior to reattempting to acquire it, any locks that are blocked on that request will still be present in the hash and will still have their fl_blocker pointer set to the current request.
This causes posix_locks_deadlock to find a deadlock dependency chain when it shouldn't, as a lock request cannot block itself.
We are going to end up waking all of those blocked locks anyway when we go to reinsert the request back into the blocked_lock_hash, so just do it prior to checking for deadlocks. This ensures that any lock blocked on the current request will no longer be part of any blocked request chain.
URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
--- fs/locks.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/locks.c +5 -0
@@ -1160,6 +1160,11 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request,*/ error = -EDEADLK ;spin_lock (&blocked_lock_lock); +/* +* Ensure that we don't find any locks blocked on this +* request during deadlock detection. +*/ +__locks_wake_up_blocks (request);if (likely (!posix_locks_deadlock (request, fl))) { error =FILE_LOCK_DEFERRED ; __locks_insert_block(fl, request,
Signature · 1 line
2.20.1
Re: [PATCH v3] locks: wake any locks blocked on request before deadlock check
Quoted 9 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.While we remove the request from the
blocked_lock_hashprior to reattempting to acquire it, any locks that are blocked on that request will still be present in the hash and will still have theirfl_blockerpointer set to the current request.
This description is a lot easier for me to follow, thanks!
Quoted 8 lines
This causes
posix_locks_deadlockto find a deadlock dependency chain when it shouldn't, as a lock request cannot block itself.We are going to end up waking all of those blocked locks anyway when we go to reinsert the request back into the
blocked_lock_hash, so just do it prior to checking for deadlocks. This ensures that any lock blocked on the current request will no longer be part of any blocked request chain.
Looks right to me.
--b.
Quoted 29 lines
URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 5 +++++ 1 file changed, 5 insertions(+)fs/locks.c +5
-0@@ -1160,6 +1160,11 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request,*/ error = -EDEADLK ;spin_lock (&blocked_lock_lock); +/* +* Ensure that we don't find any locks blocked on this +* request during deadlock detection. +*/ +__locks_wake_up_blocks (request);if (likely (!posix_locks_deadlock (request, fl))) { error =FILE_LOCK_DEFERRED ; __locks_insert_block(fl, request,Signature · 1 line
2.20.1
Re: [PATCH v3] locks: wake any locks blocked on request before deadlock check
In reply to Jeff LaytonQuoted 19 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.While we remove the request from the
blocked_lock_hashprior to reattempting to acquire it, any locks that are blocked on that request will still be present in the hash and will still have theirfl_blockerpointer set to the current request.This causes
posix_locks_deadlockto find a deadlock dependency chain when it shouldn't, as a lock request cannot block itself.We are going to end up waking all of those blocked locks anyway when we go to reinsert the request back into the
blocked_lock_hash, so just do it prior to checking for deadlocks. This ensures that any lock blocked on the current request will no longer be part of any blocked request chain.
Quoted 6 lines
URL: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>
Yes, I'm happy with this patch and description. It is more "obviously correct" than the other patch.
Thanks,
NeilBrown
Quoted 22 lines
--- fs/locks.c | 5 +++++ 1 file changed, 5 insertions(+)fs/locks.c +5
-0@@ -1160,6 +1160,11 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request,*/ error = -EDEADLK ;spin_lock (&blocked_lock_lock); +/* +* Ensure that we don't find any locks blocked on this +* request during deadlock detection. +*/ +__locks_wake_up_blocks (request);if (likely (!posix_locks_deadlock (request, fl))) { error =FILE_LOCK_DEFERRED ; __locks_insert_block(fl, request,Signature · 1 line
2.20.1
Quoted 43 lines · NeilBrown
Quoted 10 lines · J. Bruce Fields
Quoted 9 lines · Jeff Layton
Andreas reported that he was seeing the tdbtorture test fail in some cases with
-EDEADLCKwhen it wasn't before. Some debugging showed that deadlock detection was sometimes discovering the caller's lock request itself in a dependency chain.If
posix_locks_deadlock()fails to find a deadlock, thecaller_flwill be passed to__locks_insert_block(), and this wakes up all locks that are blocked oncaller_fl, clearing thefl_blockerlink.Quoted 5 lines
Quoted 2 lines
So if
posix_locks_deadlock()findscaller_flwhile searching for a deadlock,I'm feeling dense. Could you step me through the scenario in a little more detail?
Three processes: A, B, C. One byte in one file: X
A gets a read lock on X. Doesn't block, so nothing goes in the hash
table.B gets a read lock on X. Doesn't block.
C tries to get a write lock on X. It cannot so it can block on either A
or B. It chooses B. It check if this might cause a deadlock, but the hash is empty so it doesn't. It gets added to the hash. "C -> B"A tries to get a write lock on X. It cannot because B has a read lock,
so it needs to block on B, or some child. C is a child and A's request conflicts with C's request, so A blocks on C.
It first checks: DoesA->Ccause a loop in the hash-table? No. So it proceeds to block and adds "A->C" to the hash table.B drops its read lock. This wakes up the first child: C.
C tries (again) to get a write lock on X. It cannot because A still
holds a read lock, so it will have to block on A. First it must check if "C->A" will cause a loop in the hash-table ... Yes it will because "A->C" is already there - error!
Quoted 10 lines
This is a false-positive because the very next thing to be done after
posix_locks_deadlock()(while still holding all spinlocks), is__locks_insert_block(C->A)which calls__locks_wake_up_blocks(C)which calls__locks_delete_block()for any pending block ??->C and so will removeA->Cfrom the hash.Maybe we could call
__locks_wake_up_block()*before* callingposix_locks_deadlock(). That *might* make more sense.
It might. The only downside that I can see to doing that is that waking up blocks earlier might mean that they end up spinning for longer on the spinlocks that the waking task still holds. Maybe the difference is not enough to matter though.
Quoted 52 lines
Quoted 2 lines
Also, how do we know this catches every such case?
The only links in the hash table that are about to be removed are those that record that something is blocked by C (the lock we are trying to get). So these are the only ones that it is reasonable to special-case in
posix_locks_deadlock().Quoted 2 lines
And why aren't we unhashing blocks when we wake them up?
We do - that is exactly when we unhash them. The problem is they we wake them up *after* we check for errors, rather than before.
Thanks,
NeilBrownQuoted 34 lines
--b.
Quoted 31 lines
it can be sure that link in the cycle is about to be broken and it need not treat it as the cause of a deadlock.
More details here: https://bugzilla.kernel.org/show_bug.cgi?id=202975
Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")Reported-by Andreas Schneider <[email protected]>Signed-off-by Neil Brown <[email protected]>Signed-off-by Jeff Layton <[email protected]>--- fs/locks.c | 4 ++++ 1 file changed, 4 insertions(+)fs/locks.c +4
-1@@ -1023,6 +1023,10 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,while ((block_fl =what_owner_is_waiting_for (block_fl))) {if (i++ >MAX_DEADLK_ITERATIONS )return 0 ; + +if (caller_fl == block_fl) +return 0 ; +if (posix_same_owner (caller_fl, block_fl))return 1 ; } --2.20.1
Signature · 1 line
Jeff Layton <[email protected]>