On 06/05, Imre Deak wrote:
>
> On Wed, 2013-06-05 at 00:35 +0300, Imre Deak wrote:
> > On Tue, 2013-06-04 at 21:28 +0200, Oleg Nesterov wrote:
> > >
> > > 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?
> >
> > 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.

Yes, if false. But what if it is true?

> Ah sorry, if you also rewrite __wait_event_timeout() then timeout=>0
> wouldn't schedule(), 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().

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to [email protected]
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