evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

locks: skip deadlock detection on FL_FILE_PVT locks

Browse source 
It's not really feasible to do deadlock detection with FL_FILE_PVT
locks since they aren't owned by a single task, per-se. Deadlock
detection also tends to be rather expensive so just skip it for
these sorts of locks.

Also, add a FIXME comment about adding more limited deadlock detection
that just applies to ro -> rw upgrades, per Andy's request.

Cc: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
This commit is contained in:
Jeff Layton 2014-02-03 12:13:09 -05:00
parent c1e62b8fc3
commit 57b65325fe
1 changed files with 17 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
fs/locks.c
View file

@ -564,7 +564,7 @@ static void __locks_insert_block(struct file_lock *blocker,
BUG_ON(!list_empty(&waiter->fl_block)); BUG_ON(!list_empty(&waiter->fl_block));
waiter->fl_next = blocker; waiter->fl_next = blocker;
list_add_tail(&waiter->fl_block, &blocker->fl_block); list_add_tail(&waiter->fl_block, &blocker->fl_block);
if (IS_POSIX(blocker)) if (IS_POSIX(blocker) && !IS_FILE_PVT(blocker))
locks_insert_global_blocked(waiter); locks_insert_global_blocked(waiter);
} }
@ -757,8 +757,16 @@ EXPORT_SYMBOL(posix_test_lock);
* Note: the above assumption may not be true when handling lock * Note: the above assumption may not be true when handling lock
* requests from a broken NFS client. It may also fail in the presence * requests from a broken NFS client. It may also fail in the presence
* of tasks (such as posix threads) sharing the same open file table. * of tasks (such as posix threads) sharing the same open file table.
*
* To handle those cases, we just bail out after a few iterations. * To handle those cases, we just bail out after a few iterations.
*
* For FL_FILE_PVT locks, the owner is the filp, not the files_struct.
* Because the owner is not even nominally tied to a thread of
* execution, the deadlock detection below can't reasonably work well. Just
* skip it for those.
*
* In principle, we could do a more limited deadlock detection on FL_FILE_PVT
* locks that just checks for the case where two tasks are attempting to
* upgrade from read to write locks on the same inode.
*/ */
#define MAX_DEADLK_ITERATIONS 10 #define MAX_DEADLK_ITERATIONS 10
@ -781,6 +789,13 @@ static int posix_locks_deadlock(struct file_lock *caller_fl,
{ {
int i = 0; int i = 0;
/*
* This deadlock detector can't reasonably detect deadlocks with
* FL_FILE_PVT locks, since they aren't owned by a process, per-se.
*/
if (IS_FILE_PVT(caller_fl))
return 0;
while ((block_fl = what_owner_is_waiting_for(block_fl))) { while ((block_fl = what_owner_is_waiting_for(block_fl))) {
if (i++ > MAX_DEADLK_ITERATIONS) if (i++ > MAX_DEADLK_ITERATIONS)
return 0; return 0;