adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 11:46:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

file locks: Use wait_event_interruptible_timeout()

Browse source 
interruptible_sleep_on_locked() is just an open-coded
wait_event_interruptible_timeout(), with the one difference that
interruptible_sleep_on_locked() doesn't bother to check the condition on
which it is waiting, depending instead on the BKL to avoid the case
where it blocks after the wakeup has already been called.

locks_block_on_timeout() is only used in one place, so it's actually
simpler to inline it into its caller.

Signed-off-by: Matthew Wilcox <willy@linux.intel.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
This commit is contained in:
Matthew Wilcox 2008-01-14 21:28:30 -07:00 committed by J. Bruce Fields
parent b533184fc3
commit 4321e01e7d
1 changed files with 4 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
fs/locks.c
View file

@ -634,33 +634,6 @@ static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *s
return (locks_conflict(caller_fl, sys_fl));
}
static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, int timeout)
{
int result = 0;
DECLARE_WAITQUEUE(wait, current);
__set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(fl_wait, &wait);
if (timeout == 0)
schedule();
else
result = schedule_timeout(timeout);
if (signal_pending(current))
result = -ERESTARTSYS;
remove_wait_queue(fl_wait, &wait);
__set_current_state(TASK_RUNNING);
return result;
}
static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *waiter, int time)
{
int result;
locks_insert_block(blocker, waiter);
result = interruptible_sleep_on_locked(&waiter->fl_wait, time);
__locks_delete_block(waiter);
return result;
}
void
posix_test_lock(struct file *filp, struct file_lock *fl)
{
@ -1266,7 +1239,10 @@ restart:
if (break_time == 0)
break_time++;
}
error = locks_block_on_timeout(flock, new_fl, break_time);
locks_insert_block(flock, new_fl);
error = wait_event_interruptible_timeout(new_fl->fl_wait,
!new_fl->fl_next, break_time);
__locks_delete_block(new_fl);
if (error >= 0) {
if (error == 0)
time_out_leases(inode);