On Mon, Sep 30, 2013 at 07:40:54PM +0200, Oleg Nesterov wrote:
> Once again, of course I do not blame this series, but
> wait_event_timeout(wq, true, 0) still returns 0.


So we have:


#define ___wait_cond_timeout(condition)                                 \
({                                                                      \
        bool __cond = (condition);                                      \
        if (__cond && !__ret)                                           \
                __ret = 1;                                              \
        __cond || !__ret;                                               \
})

#define ___wait_event(wq, condition, state, exclusive, ret, cmd)        \
({                                                                      \
        __label__ __out;                                                \
        DEFINE_WAIT(__wait);                                            \
        long __ret = ret;                                               \
                                                                        \
        for (;;) {                                                      \
                if (exclusive)                                          \
                        prepare_to_wait_exclusive(&wq, &__wait, state); \
                else                                                    \
                        prepare_to_wait(&wq, &__wait, state);           \
                                                                        \
                if (condition)                                          \
                        break;                                          \
                                                                        \
                if (___wait_signal_pending(state)) {                    \
                        __ret = -ERESTARTSYS;                           \
                        if (exclusive) {                                \
                                abort_exclusive_wait(&wq, &__wait,      \
                                                     state, NULL);      \
                                goto __out;                             \
                        }                                               \
                        break;                                          \
                }                                                       \
                                                                        \
                cmd;                                                    \
        }                                                               \
        finish_wait(&wq, &__wait);                                      \
__out:  __ret;                                                          \
})

So wait_event_timeout(wq, true, 0) turns into:

({
        DEFINE_WAIT(__wait);
        long __ret = 0;

        for (;;) {
                prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);

                if (({
                        bool __cond = (true);
                        if (__cond && !__ret)
                                __ret = 1;
                        __cond || !__ret;
                     }))
                        break;

                schedule();
        }
        finish_wait(&wq, &__wait);
        __ret;
})

Which; afaict, returns 1, not 0.

> +#define ___wait_schedule_timeout(tout)                                       
> \
> +     if (!tout)                                                      \
> +             break;                                                  \
> +     tout = schedule_timeout(tout)
> +

>       ___wait_event(wq, ___wait_cond_timeout(condition),              \
>                     TASK_INTERRUPTIBLE, 0, ret,                       \
>                     spin_unlock_irq(&lock);                           \
> -                   __ret = schedule_timeout(__ret);                  \
> +                   ___wait_schedule_timeout(__ret);                  \
>                     spin_lock_irq(&lock));

You can't do that; you'll break/return without the lock held.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

Reply via email to