Re: Attempted summary of suspend-blockers LKML thread

[Matthew Garrett <mjg59@srcf.ucam.org>]

On Wed, Aug 04, 2010 at 12:29:36PM -0700, david@lang.hm wrote:

> why would you trust it to take a wakelock, but not trust it the rest of  
> the time?

Because I trust that when the application author says "I explicitly need 
the machine to stay awake" that they mean it, whereas I don't trust the 
application author to write an application that avoids consuming 
background CPU. The distinction is pretty important.

> in my proposal I'm saying that if you would trust the application to take 
> a wakelock, you instead trust it to be sane in the rest of it's power  
> activity (avoiding polling, etc) and so you consider it for sleep  
> decisions.

When we say "trust", we're not using the same meaning as we do with 
security. Yes, it's possible that an application that can block suspend 
will do so at inopportune times. But given that blocking suspend is an 
explicit act it's much more likely that the developer will only use it 
in reasonable ways, while it's still entirely plausible that the 
application will generate unnecessary wakeups. Pretending otherwise is 
unrealistic. I recently had to fix the fact that the kernel IPMI layer 
would generate a constant 1000 wakeups a second even if it had an 
interrupt-driven controller or was entirely idle.

>> The second is that the incoming network packet causes
>> the kernel to take a wakelock that will be released once userspace has
>> processed the network packet. This ensures that at least one wakelock is
>> held for the entire relevant period of time.
>
> how do you determine that userspace has processed the network packet so  
> that the kernel can release the wakelock (or is this one of the cases  
> where there is a timer related to the wakelock)

The current implementation uses a timer, but Rafael's implementation 
should allow userspace to explicitly acknowledge it.

> two things here,
>
> on the dirty networks that I see as common, refusing to sleep if network  
> packets are arriving will mean that you never go to sleep.

Cell networks typically have no background traffic, for obvious reasons.

> secondly, nothing stops the code doing the idle/suspend decision from  
> considering network activity. I would be surprised if there weren't  
> already options to support this today.

If you proxy every potential wakeup event through some central server 
then this becomes much easier, but it's also a performance hit. The 
alternative is that you poll for network activity, but that's a power 
hit.

-- 
Matthew Garrett | mjg59@srcf.ucam.org