Skip to contentSkip to conversation

locks: ignore same lock in blocked_lock_hash

PATCH Superseded Jeff Layton 4 participants 12 messages Mar 21, 2019 – Mar 25, 2019

Subsystems (2)
lore
Share & tools
lore

Jeff Layton

author maintainer
#0 lore raw

PATCH 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

Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")
---
 fs/locks.c | 4 ++++
 1 file changed, 4 insertions(+)
fs/locks.c +4 -0
index eaa1cfaf73b0..b074f6d7fd2d 100644
@@ -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
#1 lore raw
Quoted 9 lines · Jeff Layton

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.

Quoted 5 lines

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

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.")
---
 fs/locks.c | 4 ++++
 1 file changed, 4 insertions(+)
fs/locks.c +0 -0
index eaa1cfaf73b0..b074f6d7fd2d 100644

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 -0
 		if (posix_same_owner(caller_fl, block_fl))
 			return 1;
 	}
Signature · 1 line
2.20.1
#2 lore raw
In reply to Jeff Layton
Quoted 11 lines · Jeff Layton

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,

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.")
---
 fs/locks.c | 4 ++++
 1 file changed, 4 insertions(+)
fs/locks.c +4 -0
index eaa1cfaf73b0..b074f6d7fd2d 100644
@@ -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
#3 lore raw
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 -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.

Quoted 5 lines
Quoted 2 lines

So if posix_locks_deadlock() finds caller_fl while 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.")
---
 fs/locks.c | 4 ++++
 1 file changed, 4 insertions(+)
fs/locks.c +4 -0
index eaa1cfaf73b0..b074f6d7fd2d 100644
@@ -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
#4 lore raw
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 -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.

Quoted 5 lines
Quoted 2 lines

So if posix_locks_deadlock() finds caller_fl while 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 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.

#11 lore raw
In reply to NeilBrown
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 -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.

Quoted 5 lines
Quoted 2 lines

So if posix_locks_deadlock() finds caller_fl while 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!

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 remove A->C from the hash.

Maybe we could call __locks_wake_up_block() *before* calling posix_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,
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.")
---
 fs/locks.c | 4 ++++
 1 file changed, 4 insertions(+)
fs/locks.c +4 -1
index eaa1cfaf73b0..b074f6d7fd2d 100644
@@ -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]>
author maintainer
#5 lore raw

PATCH v2 1/1 locks: ignore same lock in blocked_lock_hash

In reply to J. Bruce Fields

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

Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")
---
 fs/locks.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)
fs/locks.c +13 -0
index eaa1cfaf73b0..a939a274dc71 100644
@@ -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
#6 lore raw

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 -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

Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")
---
 fs/locks.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)
fs/locks.c +0 -0
index eaa1cfaf73b0..a939a274dc71 100644
@@ -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 -0
 			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.

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
#7 lore raw
Quoted 57 lines · NeilBrown

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 -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

Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")
---
 fs/locks.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)
fs/locks.c +0 -0
index eaa1cfaf73b0..a939a274dc71 100644
@@ -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 -0
                      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.

That first sentence isn't working for me .... maybe remove the "is" ??

Quoted 13 lines

Thanks,
NeilBrown

Quoted 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]>
author maintainer
#8 lore raw

PATCH 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

Fixes 5946c4319ebb ("fs/locks: allow a lock request to block other requests.")
---
 fs/locks.c | 5 +++++
 1 file changed, 5 insertions(+)
fs/locks.c +5 -0
index eaa1cfaf73b0..71d0c6c2aac5 100644
@@ -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
#9 lore raw

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 -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 description is a lot easier for me to follow, thanks!

Quoted 8 lines

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.

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.")
---
 fs/locks.c | 5 +++++
 1 file changed, 5 insertions(+)
fs/locks.c +5 -0
index eaa1cfaf73b0..71d0c6c2aac5 100644
@@ -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
#10 lore raw

Re: [PATCH v3] locks: wake any locks blocked on request before deadlock check

In reply to Jeff Layton
Quoted 19 lines · Jeff Layton

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.

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.")

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
index eaa1cfaf73b0..71d0c6c2aac5 100644
@@ -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