On Sat, 5 Sep 2015, Steven Rostedt wrote:

On Sat, 5 Sep 2015 08:18:36 -0400
Steven Rostedt [off-list ref] wrote:

quoted

On Sat, 5 Sep 2015 12:30:59 +0200 (CEST)
Thomas Gleixner [off-list ref] wrote:

quoted

So instead of doing that proposed magic boost, we can do something
more straight forward:

retry:
	lock(B);
	if (!try_lock(A)) {
		lock_and_drop(A, B);
		unlock(A);
		goto retry;
	}

lock_and_drop() queues the task as a waiter on A, drops B and then
does the PI adjustment on A. 

That was my original solution, and I believe I added patches to do
exactly that to the networking code in the past. I remember writing
that helper function such that on non PREEMPT_RT it was a nop.

Just to point out again that I misread what you wrote. That's what I
get for responding to email 10 minutes after I get out of bed ;-)


You need to be careful about adding the waiter on A. If the owner of A
is blocked on B, the pi inheritance may detect that as a deadlock.

That's exactly why I wrote:

quoted

quoted

lock_and_drop() queues the task as a waiter on A, drops B and then
does the PI adjustment on A. 

because the PI adjustment would detect the deadlock.

Now the real question is whether we need that complexity at all. We
need to analyze the life time rules. If we have something like this:

     lock(y->lock);
     x = y->x;
     ...

and x cannot go away under us, then we can simply do

     lock(y->lock);
     x = y->x;
     if (!trylock(x->lock)) {
     	unlock(y->lock);
	lock(x->lock);
	unlock(x->lock);
	goto retry;
     }

Thanks,

	tglx