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

Introduce down_killable()

Browse source 
down_killable() is the functional counterpart of mutex_lock_killable.

Signed-off-by: Matthew Wilcox <willy@linux.intel.com>
This commit is contained in:
Matthew Wilcox 2008-03-14 13:19:33 -04:00 committed by Matthew Wilcox
parent 64ac24e738
commit f06d968658
2 changed files with 28 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
include/linux/semaphore.h
View file

@ -61,6 +61,12 @@ extern void down(struct semaphore *sem);
*/
extern int __must_check down_interruptible(struct semaphore *sem);
/*
* As down_interruptible(), except the sleep may only be interrupted by
* signals which are fatal to this process.
*/
extern int __must_check down_killable(struct semaphore *sem);
/*
* As down(), except this function will not sleep. It will return 0 if it
* acquired the semaphore and 1 if the semaphore was contended. This

22
kernel/semaphore.c
View file

@ -34,6 +34,7 @@
static noinline void __down(struct semaphore *sem);
static noinline int __down_interruptible(struct semaphore *sem);
static noinline int __down_killable(struct semaphore *sem);
static noinline void __up(struct semaphore *sem);
void down(struct semaphore *sem)
@ -61,6 +62,20 @@ int down_interruptible(struct semaphore *sem)
}
EXPORT_SYMBOL(down_interruptible);
int down_killable(struct semaphore *sem)
{
unsigned long flags;
int result = 0;
spin_lock_irqsave(&sem->lock, flags);
if (unlikely(sem->count-- <= 0))
result = __down_killable(sem);
spin_unlock_irqrestore(&sem->lock, flags);
return result;
}
EXPORT_SYMBOL(down_killable);
/**
* down_trylock - try to acquire the semaphore, without waiting
* @sem: the semaphore to be acquired
@ -143,6 +158,8 @@ static inline int __sched __down_common(struct semaphore *sem, long state)
for (;;) {
if (state == TASK_INTERRUPTIBLE && signal_pending(task))
goto interrupted;
if (state == TASK_KILLABLE && fatal_signal_pending(task))
goto interrupted;
__set_task_state(task, state);
spin_unlock_irq(&sem->lock);
schedule();
@ -178,6 +195,11 @@ static noinline int __sched __down_interruptible(struct semaphore *sem)
return __down_common(sem, TASK_INTERRUPTIBLE);
}
static noinline int __sched __down_killable(struct semaphore *sem)
{
return __down_common(sem, TASK_KILLABLE);
}
static noinline void __sched __up(struct semaphore *sem)
{
if (unlikely(list_empty(&sem->wait_list)))