Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-10 07:00:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

sched/wait: Make the __wait_event*() interface more friendly

Browse Source 
Change all __wait_event*() implementations to match the corresponding
wait_event*() signature for convenience.

In particular this does away with the weird 'ret' logic. Since there
are __wait_event*() users this requires we update them too.

Reviewed-by: Oleg Nesterov <oleg@redhat.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20131002092529.042563462@infradead.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Peter Zijlstra 2013-10-02 11:22:33 +02:00 committed by Ingo Molnar
parent ebdc195f2e
commit 35a2af94c7
5 changed files with 73 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
arch/mips/kernel/rtlx.c
View File

@ -172,8 +172,9 @@ int rtlx_open(int index, int can_sleep)
if (rtlx == NULL) { if (rtlx == NULL) {
if( (p = vpe_get_shared(tclimit)) == NULL) { if( (p = vpe_get_shared(tclimit)) == NULL) {
if (can_sleep) { if (can_sleep) {
__wait_event_interruptible(channel_wqs[index].lx_queue, ret = __wait_event_interruptible(
(p = vpe_get_shared(tclimit)), ret); channel_wqs[index].lx_queue,
(p = vpe_get_shared(tclimit)));
if (ret) if (ret)
goto out_fail; goto out_fail;
} else { } else {
@ -263,11 +264,10 @@ unsigned int rtlx_read_poll(int index, int can_sleep)
/* data available to read? */ /* data available to read? */
if (chan->lx_read == chan->lx_write) { if (chan->lx_read == chan->lx_write) {
if (can_sleep) { if (can_sleep) {
int ret = 0; int ret = __wait_event_interruptible(
channel_wqs[index].lx_queue,
__wait_event_interruptible(channel_wqs[index].lx_queue,
(chan->lx_read != chan->lx_write) || (chan->lx_read != chan->lx_write) ||
sp_stopping, ret); sp_stopping);
if (ret) if (ret)
return ret; return ret;
@ -440,14 +440,13 @@ static ssize_t file_write(struct file *file, const char __user * buffer,
/* any space left... */ /* any space left... */
if (!rtlx_write_poll(minor)) { if (!rtlx_write_poll(minor)) {
int ret = 0; int ret;
if (file->f_flags & O_NONBLOCK) if (file->f_flags & O_NONBLOCK)
return -EAGAIN; return -EAGAIN;
__wait_event_interruptible(channel_wqs[minor].rt_queue, ret = __wait_event_interruptible(channel_wqs[minor].rt_queue,
rtlx_write_poll(minor), rtlx_write_poll(minor));
ret);
if (ret) if (ret)
return ret; return ret;
} }

10
include/linux/tty.h
View File

@ -672,14 +672,14 @@ static inline void tty_wait_until_sent_from_close(struct tty_struct *tty,
#define wait_event_interruptible_tty(tty, wq, condition) \ #define wait_event_interruptible_tty(tty, wq, condition) \
({ \ ({ \
int __ret = 0; \ int __ret = 0; \
if (!(condition)) { \ if (!(condition)) \
__wait_event_interruptible_tty(tty, wq, condition, __ret); \ __ret = __wait_event_interruptible_tty(tty, wq, \
} \ condition); \
__ret; \ __ret; \
}) })
#define __wait_event_interruptible_tty(tty, wq, condition, ret) \ #define __wait_event_interruptible_tty(tty, wq, condition) \
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, ret, \ ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
tty_unlock(tty); \ tty_unlock(tty); \
schedule(); \ schedule(); \
tty_lock(tty)) tty_lock(tty))

113
include/linux/wait.h
View File

@ -179,24 +179,23 @@ wait_queue_head_t *bit_waitqueue(void *, int);
#define wake_up_interruptible_sync_poll(x, m) \ #define wake_up_interruptible_sync_poll(x, m) \
__wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m)) __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))
#define ___wait_cond_timeout(condition, ret) \ #define ___wait_cond_timeout(condition) \
({ \ ({ \
bool __cond = (condition); \ bool __cond = (condition); \
if (__cond && !ret) \ if (__cond && !__ret) \
ret = 1; \ __ret = 1; \
__cond || !ret; \ __cond || !__ret; \
}) })
#define ___wait_signal_pending(state) \ #define ___wait_signal_pending(state) \
((state == TASK_INTERRUPTIBLE && signal_pending(current)) || \ ((state == TASK_INTERRUPTIBLE && signal_pending(current)) || \
(state == TASK_KILLABLE && fatal_signal_pending(current))) (state == TASK_KILLABLE && fatal_signal_pending(current)))
#define ___wait_nop_ret int ret __always_unused
#define ___wait_event(wq, condition, state, exclusive, ret, cmd) \ #define ___wait_event(wq, condition, state, exclusive, ret, cmd) \
do { \ ({ \
__label__ __out; \ __label__ __out; \
DEFINE_WAIT(__wait); \ DEFINE_WAIT(__wait); \
long __ret = ret; \
\ \
for (;;) { \ for (;;) { \
if (exclusive) \ if (exclusive) \
@ -208,7 +207,7 @@ do { \
break; \ break; \
\ \
if (___wait_signal_pending(state)) { \ if (___wait_signal_pending(state)) { \
ret = -ERESTARTSYS; \ __ret = -ERESTARTSYS; \
if (exclusive) { \ if (exclusive) { \
abort_exclusive_wait(&wq, &__wait, \ abort_exclusive_wait(&wq, &__wait, \
state, NULL); \ state, NULL); \
@ -220,12 +219,12 @@ do { \
cmd; \ cmd; \
} \ } \
finish_wait(&wq, &__wait); \ finish_wait(&wq, &__wait); \
__out: ; \ __out: __ret; \
} while (0) })
#define __wait_event(wq, condition) \ #define __wait_event(wq, condition) \
___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, \ (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
___wait_nop_ret, schedule()) schedule())
/** /**
* wait_event - sleep until a condition gets true * wait_event - sleep until a condition gets true
@ -246,10 +245,10 @@ do { \
__wait_event(wq, condition); \ __wait_event(wq, condition); \
} while (0) } while (0)
#define __wait_event_timeout(wq, condition, ret) \ #define __wait_event_timeout(wq, condition, timeout) \
___wait_event(wq, ___wait_cond_timeout(condition, ret), \ ___wait_event(wq, ___wait_cond_timeout(condition), \
TASK_UNINTERRUPTIBLE, 0, ret, \ TASK_UNINTERRUPTIBLE, 0, timeout, \
ret = schedule_timeout(ret)) __ret = schedule_timeout(__ret))
/** /**
* wait_event_timeout - sleep until a condition gets true or a timeout elapses * wait_event_timeout - sleep until a condition gets true or a timeout elapses
@ -272,12 +271,12 @@ do { \
({ \ ({ \
long __ret = timeout; \ long __ret = timeout; \
if (!(condition)) \ if (!(condition)) \
__wait_event_timeout(wq, condition, __ret); \ __ret = __wait_event_timeout(wq, condition, timeout); \
__ret; \ __ret; \
}) })
#define __wait_event_interruptible(wq, condition, ret) \ #define __wait_event_interruptible(wq, condition) \
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, ret, \ ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
schedule()) schedule())
/** /**
@ -299,14 +298,14 @@ do { \
({ \ ({ \
int __ret = 0; \ int __ret = 0; \
if (!(condition)) \ if (!(condition)) \
__wait_event_interruptible(wq, condition, __ret); \ __ret = __wait_event_interruptible(wq, condition); \
__ret; \ __ret; \
}) })
#define __wait_event_interruptible_timeout(wq, condition, ret) \ #define __wait_event_interruptible_timeout(wq, condition, timeout) \
___wait_event(wq, ___wait_cond_timeout(condition, ret), \ ___wait_event(wq, ___wait_cond_timeout(condition), \
TASK_INTERRUPTIBLE, 0, ret, \ TASK_INTERRUPTIBLE, 0, timeout, \
ret = schedule_timeout(ret)) __ret = schedule_timeout(__ret))
/** /**
* wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
@ -330,7 +329,8 @@ do { \
({ \ ({ \
long __ret = timeout; \ long __ret = timeout; \
if (!(condition)) \ if (!(condition)) \
__wait_event_interruptible_timeout(wq, condition, __ret); \ __ret = __wait_event_interruptible_timeout(wq, \
condition, timeout); \
__ret; \ __ret; \
}) })
@ -347,7 +347,7 @@ do { \
current->timer_slack_ns, \ current->timer_slack_ns, \
HRTIMER_MODE_REL); \ HRTIMER_MODE_REL); \
\ \
___wait_event(wq, condition, state, 0, __ret, \ __ret = ___wait_event(wq, condition, state, 0, 0, \
if (!__t.task) { \ if (!__t.task) { \
__ret = -ETIME; \ __ret = -ETIME; \
break; \ break; \
@ -409,15 +409,15 @@ do { \
__ret; \ __ret; \
}) })
#define __wait_event_interruptible_exclusive(wq, condition, ret) \ #define __wait_event_interruptible_exclusive(wq, condition) \
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, ret, \ ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0, \
schedule()) schedule())
#define wait_event_interruptible_exclusive(wq, condition) \ #define wait_event_interruptible_exclusive(wq, condition) \
({ \ ({ \
int __ret = 0; \ int __ret = 0; \
if (!(condition)) \ if (!(condition)) \
__wait_event_interruptible_exclusive(wq, condition, __ret);\ __ret = __wait_event_interruptible_exclusive(wq, condition);\
__ret; \ __ret; \
}) })
@ -570,8 +570,8 @@ do { \
#define __wait_event_killable(wq, condition, ret) \ #define __wait_event_killable(wq, condition) \
___wait_event(wq, condition, TASK_KILLABLE, 0, ret, schedule()) ___wait_event(wq, condition, TASK_KILLABLE, 0, 0, schedule())
/** /**
* wait_event_killable - sleep until a condition gets true * wait_event_killable - sleep until a condition gets true
@ -592,18 +592,17 @@ do { \
({ \ ({ \
int __ret = 0; \ int __ret = 0; \
if (!(condition)) \ if (!(condition)) \
__wait_event_killable(wq, condition, __ret); \ __ret = __wait_event_killable(wq, condition); \
__ret; \ __ret; \
}) })
#define __wait_event_lock_irq(wq, condition, lock, cmd) \ #define __wait_event_lock_irq(wq, condition, lock, cmd) \
___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, \ (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
___wait_nop_ret, \ spin_unlock_irq(&lock); \
spin_unlock_irq(&lock); \ cmd; \
cmd; \ schedule(); \
schedule(); \ spin_lock_irq(&lock))
spin_lock_irq(&lock))
/** /**
* wait_event_lock_irq_cmd - sleep until a condition gets true. The * wait_event_lock_irq_cmd - sleep until a condition gets true. The
@ -663,11 +662,11 @@ do { \
} while (0) } while (0)
#define __wait_event_interruptible_lock_irq(wq, condition, lock, ret, cmd) \ #define __wait_event_interruptible_lock_irq(wq, condition, lock, cmd) \
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, ret, \ ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0, \
spin_unlock_irq(&lock); \ spin_unlock_irq(&lock); \
cmd; \ cmd; \
schedule(); \ schedule(); \
spin_lock_irq(&lock)) spin_lock_irq(&lock))
/** /**
@ -698,10 +697,9 @@ do { \
#define wait_event_interruptible_lock_irq_cmd(wq, condition, lock, cmd) \ #define wait_event_interruptible_lock_irq_cmd(wq, condition, lock, cmd) \
({ \ ({ \
int __ret = 0; \ int __ret = 0; \
\
if (!(condition)) \ if (!(condition)) \
__wait_event_interruptible_lock_irq(wq, condition, \ __ret = __wait_event_interruptible_lock_irq(wq, \
lock, __ret, cmd); \ condition, lock, cmd); \
__ret; \ __ret; \
}) })
@ -730,18 +728,18 @@ do { \
#define wait_event_interruptible_lock_irq(wq, condition, lock) \ #define wait_event_interruptible_lock_irq(wq, condition, lock) \
({ \ ({ \
int __ret = 0; \ int __ret = 0; \
\
if (!(condition)) \ if (!(condition)) \
__wait_event_interruptible_lock_irq(wq, condition, \ __ret = __wait_event_interruptible_lock_irq(wq, \
lock, __ret, ); \ condition, lock,) \
__ret; \ __ret; \
}) })
#define __wait_event_interruptible_lock_irq_timeout(wq, condition, lock, ret) \ #define __wait_event_interruptible_lock_irq_timeout(wq, condition, \
___wait_event(wq, ___wait_cond_timeout(condition, ret), \ lock, timeout) \
TASK_INTERRUPTIBLE, 0, ret, \ ___wait_event(wq, ___wait_cond_timeout(condition), \
spin_unlock_irq(&lock); \ TASK_INTERRUPTIBLE, 0, ret, \
ret = schedule_timeout(ret); \ spin_unlock_irq(&lock); \
__ret = schedule_timeout(__ret); \
spin_lock_irq(&lock)); spin_lock_irq(&lock));
/** /**
@ -771,11 +769,10 @@ do { \
#define wait_event_interruptible_lock_irq_timeout(wq, condition, lock, \ #define wait_event_interruptible_lock_irq_timeout(wq, condition, lock, \
timeout) \ timeout) \
({ \ ({ \
int __ret = timeout; \ long __ret = timeout; \
\
if (!(condition)) \ if (!(condition)) \
__wait_event_interruptible_lock_irq_timeout( \ __ret = __wait_event_interruptible_lock_irq_timeout( \
wq, condition, lock, __ret); \ wq, condition, lock, timeout); \
__ret; \ __ret; \
}) })

5
net/irda/af_irda.c
View File

@ -2563,9 +2563,8 @@ bed:
jiffies + msecs_to_jiffies(val)); jiffies + msecs_to_jiffies(val));
/* Wait for IR-LMP to call us back */ /* Wait for IR-LMP to call us back */
__wait_event_interruptible(self->query_wait, err = __wait_event_interruptible(self->query_wait,
(self->cachedaddr != 0 || self->errno == -ETIME), (self->cachedaddr != 0 || self->errno == -ETIME));
err);
/* If watchdog is still activated, kill it! */ /* If watchdog is still activated, kill it! */
del_timer(&(self->watchdog)); del_timer(&(self->watchdog));

7
net/netfilter/ipvs/ip_vs_sync.c
View File

@ -1637,12 +1637,9 @@ static int sync_thread_master(void *data)
continue; continue;
} }
while (ip_vs_send_sync_msg(tinfo->sock, sb->mesg) < 0) { while (ip_vs_send_sync_msg(tinfo->sock, sb->mesg) < 0) {
int ret = 0; int ret = __wait_event_interruptible(*sk_sleep(sk),
__wait_event_interruptible(*sk_sleep(sk),
sock_writeable(sk) || sock_writeable(sk) ||
kthread_should_stop(), kthread_should_stop());
ret);
if (unlikely(kthread_should_stop())) if (unlikely(kthread_should_stop()))
goto done; goto done;
} }