wait: fix false timeouts when using wait_event_timeout()
Hello,
Just noticed this commit...
commit 4c663cfc523a88d97a8309b04a089c27dc57fd7e
Author: Imre Deak <[email protected]> Date: Fri May 24 15:55:09 2013 -0700
Many callers of the wait_event_timeout() and wait_event_interruptible_timeout() expect that the return value will be positive if the specified condition becomes true before the timeout elapses. However, at the moment this isn't guaranteed. If the wake-up handler is delayed enough, the time remaining until timeout will be calculated as 0 - and passed back as a return value - even if the condition became true before the timeout has passed.
OK, agreed.
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -217,6 +217,8 @@ do { \
if (!ret) \
break; \
} \
+ if (!ret && (condition)) \
+ ret = 1; \
finish_wait(&wq, &__wait); \
} while (0)Well, this evaluates "condition" twice, perhaps it would be more clean to do, say,
#define __wait_event_timeout(wq, condition, ret) \
do { \
DEFINE_WAIT(__wait); \
\
for (;;) { \
prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \
if (condition) { \
if (!ret) \
ret = 1; \
break; \
} else if (!ret) \
break; \
ret = schedule_timeout(ret); \
} \
finish_wait(&wq, &__wait); \
} while (0)but this is minor.
@@ -233,8 +235,9 @@ do { \
* wake_up() has to be called after changing any variable that could
* change the result of the wait condition.
*
- * The function returns 0 if the @timeout elapsed, and the remaining
- * jiffies if the condition evaluated to true before the timeout elapsed.
+ * The function returns 0 if the @timeout elapsed, or the remaining
+ * jiffies (at least 1) if the @condition evaluated to %true before
+ * the @timeout elapsed.
This is still not true if timeout == 0.
Shouldn't we also change wait_event_timeout() ? Say,
#define wait_event_timeout(wq, condition, timeout) \
({ \
long __ret = timeout; \
if (!(condition)) \
__wait_event_timeout(wq, condition, __ret); \
else if (!__ret) \
__ret = 1; \
__ret; \
})Or wait_event_timeout(timeout => 0) is not legal in a non-void context?
To me the code like
long wait_for_something(bool nonblock)
{
timeout = nonblock ? 0 : DEFAULT_TIMEOUT;
return wait_event_timeout(..., timeout);
}looks reasonable and correct. But it is not?
Oleg.
Quoted 79 lines · Oleg Nesterov
Hello,
Just noticed this commit...
commit
4c663cfc523a88d97a8309b04a089c27dc57fd7eAuthor: Imre Deak <[email protected]> Date: Fri May 24 15:55:09 2013 -0700Many callers of the
wait_event_timeout()andwait_event_interruptible_timeout()expect that the return value will be positive if the specified condition becomes true before the timeout elapses. However, at the moment this isn't guaranteed. If the wake-up handler is delayed enough, the time remaining until timeout will be calculated as 0 - and passed back as a return value - even if the condition became true before the timeout has passed.OK, agreed.
--- a/include/linux/wait.h +++ b/include/linux/wait.h @@ -217,6 +217,8 @@ do { \ if (!ret) \ break; \ } \ + if (!ret && (condition)) \ + ret = 1; \ finish_wait(&wq, &__wait); \ } while (0)Well, this evaluates "condition" twice, perhaps it would be more clean to do, say,
#define __wait_event_timeout(wq, condition, ret) \ do { \ DEFINE_WAIT(__wait); \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ if (condition) { \ if (!ret) \ ret = 1; \ break; \ } else if (!ret) \ break; \ ret = schedule_timeout(ret); \ } \ finish_wait(&wq, &__wait); \ } while (0)but this is minor.
@@ -233,8 +235,9 @@ do { \
*wake_up()has to be called after changing any variable that could
* change the result of the wait condition.
*
- * The function returns 0 if the @timeout elapsed, and the remaining
- * jiffies if the condition evaluated to true before the timeout elapsed.
+ * The function returns 0 if the @timeout elapsed, or the remaining
+ * jiffies (at least 1) if the @condition evaluated to %true before
+ * the @timeout elapsed.This is still not true if timeout == 0.
Shouldn't we also change
wait_event_timeout()? Say,#define wait_event_timeout(wq, condition, timeout) \ ({ \ long __ret = timeout; \ if (!(condition)) \ __wait_event_timeout(wq, condition, __ret); \ else if (!__ret) \ __ret = 1; \ __ret; \ })Or
wait_event_timeout(timeout => 0)is not legal in a non-void context?To me the code like
Quoted 7 lines
long wait_for_something(bool nonblock) { timeout = nonblock ? 0 : DEFAULT_TIMEOUT; return wait_event_timeout(..., timeout); }looks reasonable and correct. But it is not?
I don't see why it would be not legal. Note though that in the above form wait_event_timeout(cond, 0) would still schedule() if cond is false, which is not what I'd expect from a non-blocking function.
--Imre
Quoted 86 lines · Imre Deak
Quoted 85 lines · Oleg Nesterov
Hello,
Just noticed this commit...
commit
4c663cfc523a88d97a8309b04a089c27dc57fd7eAuthor: Imre Deak <[email protected]> Date: Fri May 24 15:55:09 2013 -0700Many callers of the
wait_event_timeout()andwait_event_interruptible_timeout()expect that the return value will be positive if the specified condition becomes true before the timeout elapses. However, at the moment this isn't guaranteed. If the wake-up handler is delayed enough, the time remaining until timeout will be calculated as 0 - and passed back as a return value - even if the condition became true before the timeout has passed.OK, agreed.
--- a/include/linux/wait.h +++ b/include/linux/wait.h @@ -217,6 +217,8 @@ do { \ if (!ret) \ break; \ } \ + if (!ret && (condition)) \ + ret = 1; \ finish_wait(&wq, &__wait); \ } while (0)Well, this evaluates "condition" twice, perhaps it would be more clean to do, say,
#define __wait_event_timeout(wq, condition, ret) \ do { \ DEFINE_WAIT(__wait); \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ if (condition) { \ if (!ret) \ ret = 1; \ break; \ } else if (!ret) \ break; \ ret = schedule_timeout(ret); \ } \ finish_wait(&wq, &__wait); \ } while (0)but this is minor.
@@ -233,8 +235,9 @@ do { \
*wake_up()has to be called after changing any variable that could
* change the result of the wait condition.
*
- * The function returns 0 if the @timeout elapsed, and the remaining
- * jiffies if the condition evaluated to true before the timeout elapsed.
+ * The function returns 0 if the @timeout elapsed, or the remaining
+ * jiffies (at least 1) if the @condition evaluated to %true before
+ * the @timeout elapsed.This is still not true if timeout == 0.
Shouldn't we also change
wait_event_timeout()? Say,#define wait_event_timeout(wq, condition, timeout) \ ({ \ long __ret = timeout; \ if (!(condition)) \ __wait_event_timeout(wq, condition, __ret); \ else if (!__ret) \ __ret = 1; \ __ret; \ })Or
wait_event_timeout(timeout => 0)is not legal in a non-void context?To me the code like
long wait_for_something(bool nonblock) { timeout = nonblock ? 0 : DEFAULT_TIMEOUT; return wait_event_timeout(..., timeout); }
Quoted 5 lines
Quoted 1 line
looks reasonable and correct. But it is not?
I don't see why it would be not legal. Note though that in the above form
wait_event_timeout(cond, 0)would stillschedule()if cond is false, which is not what I'd expect from a non-blocking function.
Ah sorry, if you also rewrite __wait_event_timeout() then timeout=>0 wouldn't schedule(), so things would work as expected.
--Imre
Quoted 26 lines · Imre Deak
Quoted 24 lines · Imre Deak
Quoted 23 lines · Oleg Nesterov
Shouldn't we also change
wait_event_timeout()? Say,#define wait_event_timeout(wq, condition, timeout) \ ({ \ long __ret = timeout; \ if (!(condition)) \ __wait_event_timeout(wq, condition, __ret); \ else if (!__ret) \ __ret = 1; \ __ret; \ })Or
wait_event_timeout(timeout => 0)is not legal in a non-void context?To me the code like
long wait_for_something(bool nonblock) { timeout = nonblock ? 0 : DEFAULT_TIMEOUT; return wait_event_timeout(..., timeout); }
Quoted 5 lines
Quoted 5 lines
Quoted 1 line
looks reasonable and correct. But it is not?
I don't see why it would be not legal. Note though that in the above form
wait_event_timeout(cond, 0)would stillschedule()if cond is false, which is not what I'd expect from a non-blocking function.
Yes, if false. But what if it is true?
Quoted 2 lines
Ah sorry, if you also rewrite
__wait_event_timeout()then timeout=>0 wouldn'tschedule(), so things would work as expected.
Can't understand... probably you missed my point. Let me try again.
I think that wait_eveint_timeout(wq, COND, 0) should return !!(COND). But it doesn't, for example wait_event_timeout(wq, true, 0) == 0, this doesn'tlook right to me.
And, this is off-topic, but wait_eveint_timeout/__wait_eveint_timeout do not match wait_event/__wait_event. IOW, you can't use __wait_eveint_timeout() if you do not need the fast-path check.
So. How about
#define __wait_event_timeout(wq, condition, timeout) \
({ \
DEFINE_WAIT(__wait); \
long __ret = 0, __to = timeout; \
\
for (;;) { \
prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \
if (condition) { \
__ret = __to ?: 1; \
break; \
} \
if (!__to) \
break; \
__to = schedule_timeout(__to); \
} \
finish_wait(&wq, &__wait); \
__ret; \
})
#define wait_event_timeout(wq, condition, timeout) \
({ \
long __ret; \
if (condition) \
__ret = (timeout) ?: 1; \
else \
__ret = __wait_event_timeout(wq, condition, timeout); \
__ret; \
})?
Othwerwise we should document the fact that the caller should alvays verify timeout != 0 if it checks the result of wait_event_timeout().
Quoted 40 lines · Oleg Nesterov
I think that
wait_eveint_timeout(wq, COND, 0)should return !!(COND). But it doesn't, for examplewait_event_timeout(wq, true, 0)== 0, this doesn'tlook right to me.And, this is off-topic, but wait_eveint_timeout/__wait_eveint_timeout do not match wait_event/__wait_event. IOW, you can't use
__wait_eveint_timeout()if you do not need the fast-path check.So. How about
#define __wait_event_timeout(wq, condition, timeout) \ ({ \ DEFINE_WAIT(__wait); \ long __ret = 0, __to = timeout; \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ if (condition) { \ __ret = __to ?: 1; \ break; \ } \ if (!__to) \ break; \ __to = schedule_timeout(__to); \ } \ finish_wait(&wq, &__wait); \ __ret; \ }) #define wait_event_timeout(wq, condition, timeout) \ ({ \ long __ret; \ if (condition) \ __ret = (timeout) ?: 1; \ else \ __ret = __wait_event_timeout(wq, condition, timeout); \ __ret; \ })
Quoted 4 lines
?
Othwerwise we should document the fact that the caller should alvays verify timeout != 0 if it checks the result of
wait_event_timeout().
And in fact, perhaps we can implement wait_event_common() and avoid the code duplications?
#define __wait_no_timeout(timeout) \
(__builtin_constant_p(timeout) && (timeout) == MAX_SCHEDULE_TIMEOUT)
/* uglified signal_pending_state() */
#define __wait_signal_pending(state) \
((state == TASK_INTERRUPTIBLE) ? signal_pending(current) : \
(state == TASK_KILLABLE) ? fatal_signal_pending(current) : \
0)
#define __wait_event_common(wq, condition, state, tout) \
({ \
DEFINE_WAIT(__wait); \
long __ret = 0, __tout = tout; \
\
for (;;) { \
prepare_to_wait(&wq, &__wait, state); \
if (condition) { \
__ret = __wait_no_timeout(tout) ?: __tout ?: 1; \
break; \
} \
\
if (__wait_signal_pending(state)) { \
__ret = -ERESTARTSYS; \
break; \
} \
\
if (__wait_no_timeout(tout)) \
schedule(); \
else if (__tout) \
__tout = schedule_timeout(__tout); \
else \
break; \
} \
finish_wait(&wq, &__wait); \
__ret; \
})
#define wait_event_common(wq, condition, state, tout) \
({ \
long __ret; \
if (condition) \
__ret = __wait_no_timeout(tout) ?: (tout) ?: 1; \
else \
__ret = __wait_event_common(wq, condition, state, tout);\
__ret; \
})Then, for example, wait_event() becomes
#define wait_event(wq, condition) \ wait_event_common(wq, condition, \ TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT) \
Hmm. I compiled the kernel with the patch below,
$ size vmlinux text data bss dec hex filename - 4978601 2935080 10104832 18018513 112f0d1 vmlinux + 4977769 2930984 10104832 18013585 112dd91 vmlinux
looks good...
Oleg.
include/linux/wait.h +70 -111
@@ -173,18 +173,52 @@ wait_queue_head_t *bit_waitqueue(void *, int);#define wake_up_interruptible_sync_poll (x, m) \ __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m)) -#define __wait_event (wq, condition) \ -do { \ +#define __wait_no_timeout (timeout) \ + (__builtin_constant_p(timeout) && (timeout) == MAX_SCHEDULE_TIMEOUT) + +/* uglified signal_pending_state() */ +#define __wait_signal_pending (state) \ + ((state == TASK_INTERRUPTIBLE) ? signal_pending(current) : \ + (state == TASK_KILLABLE) ? fatal_signal_pending(current) : \ + 0) + +#define __wait_event_common (wq, condition, state, tout) \ +({ \ DEFINE_WAIT(__wait); \ + long __ret = 0, __tout = tout; \ \ for (;;) { \ - prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ - if (condition) \ + prepare_to_wait(&wq, &__wait, state); \ + if (condition) { \ + __ret = __wait_no_timeout(tout) ?: __tout ?: 1; \ + break; \ + } \ + \ + if (__wait_signal_pending(state)) { \ + __ret = -ERESTARTSYS; \ + break; \ + } \ + \ + if (__wait_no_timeout(tout)) \ + schedule(); \ + else if (__tout) \ + __tout = schedule_timeout(__tout); \ + else \ break; \ - schedule(); \ } \ finish_wait(&wq, &__wait); \ -} while (0) + __ret; \ +}) + +#define wait_event_common (wq, condition, state, tout) \ +({ \ + long __ret; \ + if (condition) \ + __ret = __wait_no_timeout(tout) ?: (tout) ?: 1; \ + else \ + __ret = __wait_event_common(wq, condition, state, tout);\ + __ret; \ +})/** * wait_event - sleep until a condition gets true
@@ -198,29 +232,13 @@ do { \* wake_up() has to be called after changing any variable that could * change the result of the wait condition. */ -#define wait_event (wq, condition) \ -do { \ - if (condition) \ - break; \ - __wait_event(wq, condition); \ -} while (0) +#define __wait_event (wq, condition) \ + __wait_event_common(wq, condition, \ + TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT) \ -#define __wait_event_timeout (wq, condition, ret) \ -do { \ - DEFINE_WAIT(__wait); \ - \ - for (;;) { \ - prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ - if (condition) \ - break; \ - ret = schedule_timeout(ret); \ - if (!ret) \ - break; \ - } \ - if (!ret && (condition)) \ - ret = 1; \ - finish_wait(&wq, &__wait); \ -} while (0) +#define wait_event (wq, condition) \ + wait_event_common(wq, condition, \ + TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT) \/** * wait_event_timeout - sleep until a condition gets true or a timeout elapses
@@ -239,31 +257,13 @@ do { \* jiffies (at least 1) if the @condition evaluated to %true before * the @timeout elapsed. */ -#define wait_event_timeout (wq, condition, timeout) \ -({ \ - long __ret = timeout; \ - if (!(condition)) \ - __wait_event_timeout(wq, condition, __ret); \ - __ret; \ -}) +#define __wait_event_timeout (wq, condition, timeout) \ + __wait_event_common(wq, condition, \ + TASK_UNINTERRUPTIBLE, timeout) -#define __wait_event_interruptible (wq, condition, ret) \ -do { \ - DEFINE_WAIT(__wait); \ - \ - for (;;) { \ - prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); \ - if (condition) \ - break; \ - if (!signal_pending(current)) { \ - schedule(); \ - continue; \ - } \ - ret = -ERESTARTSYS; \ - break; \ - } \ - finish_wait(&wq, &__wait); \ -} while (0) +#define wait_event_timeout (wq, condition, timeout) \ + wait_event_common(wq, condition, \ + TASK_UNINTERRUPTIBLE, timeout)/** * wait_event_interruptible - sleep until a condition gets true
@@ -280,35 +280,13 @@ do { \* The function will return -ERESTARTSYS if it was interrupted by a * signal and 0 if @condition evaluated to true. */ -#define wait_event_interruptible (wq, condition) \ -({ \ - int __ret = 0; \ - if (!(condition)) \ - __wait_event_interruptible(wq, condition, __ret); \ - __ret; \ -}) +#define __wait_event_interruptible (wq, condition) \ + __wait_event_common(wq, condition, \ + TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT) -#define __wait_event_interruptible_timeout (wq, condition, ret) \ -do { \ - DEFINE_WAIT(__wait); \ - \ - for (;;) { \ - prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); \ - if (condition) \ - break; \ - if (!signal_pending(current)) { \ - ret = schedule_timeout(ret); \ - if (!ret) \ - break; \ - continue; \ - } \ - ret = -ERESTARTSYS; \ - break; \ - } \ - if (!ret && (condition)) \ - ret = 1; \ - finish_wait(&wq, &__wait); \ -} while (0) +#define wait_event_interruptible (wq, condition) \ + wait_event_common(wq, condition, \ + TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT)/** * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
@@ -328,13 +306,13 @@ do { \* a signal, or the remaining jiffies (at least 1) if the @condition * evaluated to %true before the @timeout elapsed. */ +#define __wait_event_interruptible_timeout (wq, condition, timeout) \ + __wait_event_common(wq, condition, \ + TASK_INTERRUPTIBLE, timeout) +#define wait_event_interruptible_timeout (wq, condition, timeout) \ -({ \ - long __ret = timeout; \ - if (!(condition)) \ - __wait_event_interruptible_timeout(wq, condition, __ret); \ - __ret; \ -}) + wait_event_common(wq, condition, \ + TASK_INTERRUPTIBLE, timeout)#define __wait_event_hrtimeout (wq, condition, timeout, state) \ ({ \
@@ -601,24 +579,6 @@ do { \ -#define __wait_event_killable (wq, condition, ret) \ -do { \ - DEFINE_WAIT(__wait); \ - \ - for (;;) { \ - prepare_to_wait(&wq, &__wait, TASK_KILLABLE); \ - if (condition) \ - break; \ - if (!fatal_signal_pending(current)) { \ - schedule(); \ - continue; \ - } \ - ret = -ERESTARTSYS; \ - break; \ - } \ - finish_wait(&wq, &__wait); \ -} while (0) -/** * wait_event_killable - sleep until a condition gets true * @wq: the waitqueue to wait on
@@ -634,14 +594,13 @@ do { \* The function will return -ERESTARTSYS if it was interrupted by a * signal and 0 if @condition evaluated to true. */ -#define wait_event_killable (wq, condition) \ -({ \ - int __ret = 0; \ - if (!(condition)) \ - __wait_event_killable(wq, condition, __ret); \ - __ret; \ -}) +#define __wait_event_killable (wq, condition) \ + __wait_event_common(wq, condition, \ + TASK_KILLABLE, MAX_SCHEDULE_TIMEOUT) +#define wait_event_killable (wq, condition) \ + wait_event_common(wq, condition, \ + TASK_KILLABLE, MAX_SCHEDULE_TIMEOUT)#define __wait_event_lock_irq (wq, condition, lock, cmd) \ do { \
Tejun Heo
Reviewed-byHello, Oleg.
Quoted 31 lines · Oleg Nesterov
And in fact, perhaps we can implement
wait_event_common()and avoid the code duplications?#define __wait_no_timeout(timeout) \ (__builtin_constant_p(timeout) && (timeout) == MAX_SCHEDULE_TIMEOUT) /* uglified signal_pending_state() */ #define __wait_signal_pending(state) \ ((state == TASK_INTERRUPTIBLE) ? signal_pending(current) : \ (state == TASK_KILLABLE) ? fatal_signal_pending(current) : \ 0) #define __wait_event_common(wq, condition, state, tout) \ ({ \ DEFINE_WAIT(__wait); \ long __ret = 0, __tout = tout; \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, state); \ if (condition) { \ __ret = __wait_no_timeout(tout) ?: __tout ?: 1; \ break; \ } \ \ if (__wait_signal_pending(state)) { \ __ret = -ERESTARTSYS; \ break; \ } \ \ if (__wait_no_timeout(tout)) \ schedule(); \
Quoted 8 lines
else if (__tout) \ __tout = schedule_timeout(__tout); \ else \ break; \ } \ finish_wait(&wq, &__wait); \ __ret; \ })
Heh, yeah, this looks good to me and a lot better than trying to do the same thing over and over again and ending up with subtle differences.
Quoted 6 lines
Hmm. I compiled the kernel with the patch below,
$ size vmlinux text data bss dec hex filename - 4978601 2935080 10104832 18018513 112f0d1 vmlinux + 4977769 2930984 10104832 18013585 112dd91 vmlinux
Nice. Provided you went over assembly outputs of at least some combinations, please feel free to add
Thanks.
Signature · 1 line
tejun
Hi Tejun,
Quoted 4 lines · Tejun Heo
Heh, yeah, this looks good to me and a lot better than trying to do the same thing over and over again and ending up with subtle differences.
Yes, this is the goal. Of course we could fix wait_event_timout() and wait_event_interruptible_timeout() without unification, but this would add more copy-and-paste.
Quoted 9 lines
Quoted 6 lines
Hmm. I compiled the kernel with the patch below,
$ size vmlinux text data bss dec hex filename - 4978601 2935080 10104832 18018513 112f0d1 vmlinux + 4977769 2930984 10104832 18013585 112dd91 vmlinuxNice. Provided you went over assembly outputs of at least some combinations,
I did, and that is why I am surprized by the numbers above.
Yes, gcc optimizes out the unwanted checks but the generated code differs, of course. And sometimes the difference looks "random" to me.
Simplest example:
extern wait_queue_head_t WQ;
extern int COND;
void we(void)
{
wait_event(WQ, COND);
}before:
we: pushq %rbp # movq %rsp, %rbp #, pushq %rbx # subq $56, %rsp #, call mcount movl COND(%rip), %edx # COND, testl %edx, %edx # jne .L5 #, leaq -64(%rbp), %rbx #, tmp66 movq $0, -64(%rbp) #, __wait movq $autoremove_wake_function, -48(%rbp) #, __wait.func #APP # 14 "/home/tmp/K/misc/arch/x86/include/asm/current.h" 1 movq %gs:current_task,%rax #, pfo_ret__ # 0 "" 2 #NO_APP movq %rax, -56(%rbp) # pfo_ret__, __wait.private leaq 24(%rbx), %rax #, tmp61 movq %rax, -40(%rbp) # tmp61, __wait.task_list.next movq %rax, -32(%rbp) # tmp61, __wait.task_list.prev .p2align 4,,10 .p2align 3 .L4: movl $2, %edx #, movq %rbx, %rsi # tmp66, movq $WQ, %rdi #, call prepare_to_wait # movl COND(%rip), %eax # COND, testl %eax, %eax # jne .L3 #, call schedule # jmp .L4 # .p2align 4,,10 .p2align 3 .L3: movq %rbx, %rsi # tmp66, movq $WQ, %rdi #, call finish_wait # .L5: addq $56, %rsp #, popq %rbx # leave ret
after:
we: pushq %rbp # movq %rsp, %rbp #, pushq %rbx # subq $56, %rsp #, call mcount movl COND(%rip), %edx # COND, testl %edx, %edx # jne .L5 #, leaq -64(%rbp), %rbx #, tmp66 movq $0, -64(%rbp) #, __wait movq $autoremove_wake_function, -48(%rbp) #, __wait.func #APP # 14 "/home/tmp/K/misc/arch/x86/include/asm/current.h" 1 movq %gs:current_task,%rax #, pfo_ret__ # 0 "" 2 #NO_APP movq %rax, -56(%rbp) # pfo_ret__, __wait.private leaq 24(%rbx), %rax #, tmp61 movq %rax, -40(%rbp) # tmp61, __wait.task_list.next movq %rax, -32(%rbp) # tmp61, __wait.task_list.prev .p2align 4,,10 .p2align 3 .L4: movl $2, %edx #, movq %rbx, %rsi # tmp66, movq $WQ, %rdi #, call prepare_to_wait # movl COND(%rip), %eax # COND, testl %eax, %eax # je .L3 #, movq %rbx, %rsi # tmp66, movq $WQ, %rdi #, call finish_wait # jmp .L5 # .p2align 4,,10 .p2align 3 .L3: call schedule # .p2align 4,,8 .p2align 3 jmp .L4 # .p2align 4,,10 .p2align 3 .L5: addq $56, %rsp #, popq %rbx # leave .p2align 4,,4 .p2align 3 ret
As you can see, with this patch gcc generates a bit more code. But only because reorderes finish_wait() and inserts the additional nops, otherwise code the same. I think this difference is not "reliable" and can be ignored.
But, the code like "return wait_even_timeout(true, non_const_timeout)" really generates more code and this is correct: the patch tries to fix the bug (at least I think this is a bug) and the additional code ensures that __ret != 0.
Quoted 1 line
Reviewed-by Tejun Heo <[email protected]>
Thanks! I'll send this patch soon.
Oleg.