rfkill: persistent device suspend/resume

rfkill: persistent device suspend/resume

[Henrique de Moraes Holschuh]

On Thu, 18 Jun 2009, Henrique de Moraes Holschuh wrote:
> > The setting of the "persistent" flag is also made more explicit using
> > a new rfkill_init_sw_state() function, instead of special-casing
> > rfkill_set_sw_state() when it is called before registration.
> > 
> > Suspend is a bit of a corner case so we try to get away without adding
> > another hack to rfkill-input - it's going to be removed soon.
> > If the state does change over suspend, users will simply have to prod
> > rfkill-input twice in order to toggle the state.

Well, I acked it, but I didn't do my job properly and didn't notice the
above.

Suspend/resume is not much of a corner case at all:  unless overriden by
some weird policy that doesn't even exist right now (the only one that comes
to mind is to have it always off upon resume in highly-critical
environments), we really want to restore the hardware to the previous soft
state, subject to any changes on any hard state that happened while the
machine was sleeping.

And any "weird policy" we might implement would have to come through the
core anyway.  So, we really should be taking advantage of the fact that the
rfkill class will resume *after* the device, and let the core call the
backend (unconditionally, so it is also a way to make sure the
firmware/hardware is in sync with the core) to set the proper state after a
resume.

The backend will be able to update any hard states before the rfkill class
resume code runs, so this will always work fine.   It also allows the
backend driver to ask the platform to resume with radios disabled, so that
if we _ever_ decide to change the core to have a different policy to what
should be done to radios on resume (e.g. leave them off and wait for
userspace to tell us what to do :) ), that will need no change to drivers
(and radios won't get turned on just to be turned off, etc).

It will also let us remove a few LOC from eeepc-laptop and avoid adding a
few LOC to thinkpad-acpi (which has a regression since 2.6.30 because failed
to notice I would have to handle resume).

What do you guys think?   I will cook up a patch to implement the above, but
if there are any objections to the idea, I'd like to hear it ASAP, as I do
have a regression to fix :)

Note: eeepc-laptop and thinkpad-acpi are the only rfkill persistent devices
in-tree.

-- 
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh

Re: rfkill: persistent device suspend/resume

[Johannes Berg]

[-- Attachment #1: Type: text/plain, Size: 586 bytes --]

On Sat, 2009-11-28 at 10:41 -0200, Henrique de Moraes Holschuh wrote:

> What do you guys think?   I will cook up a patch to implement the above, but
> if there are any objections to the idea, I'd like to hear it ASAP, as I do
> have a regression to fix :)

What part of that don't we do?

static int rfkill_resume(struct device *dev)
{
        struct rfkill *rfkill = to_rfkill(dev);
        bool cur;

        if (!rfkill->persistent) {
                cur = !!(rfkill->state & RFKILL_BLOCK_SW);
                rfkill_set_block(rfkill, cur);
        }


johannes

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 801 bytes --]

Re: rfkill: persistent device suspend/resume

[Henrique de Moraes Holschuh]

On Sat, 28 Nov 2009, Johannes Berg wrote:
> On Sat, 2009-11-28 at 10:41 -0200, Henrique de Moraes Holschuh wrote:
> > What do you guys think?   I will cook up a patch to implement the above, but
> > if there are any objections to the idea, I'd like to hear it ASAP, as I do
> > have a regression to fix :)
> 
> What part of that don't we do?
> 
> static int rfkill_resume(struct device *dev)
> {
>         struct rfkill *rfkill = to_rfkill(dev);
>         bool cur;
> 
>         if (!rfkill->persistent) {
>                 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
>                 rfkill_set_block(rfkill, cur);
>         }

The issue I am reporting is _only_ about persistent devices, so it is the
if(!rfkill->persistent) that is the problem.  It works perfectly for the
other devices.

-- 
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh

Re: rfkill: persistent device suspend/resume

[Johannes Berg]

[-- Attachment #1: Type: text/plain, Size: 753 bytes --]

On Sat, 2009-11-28 at 11:27 -0200, Henrique de Moraes Holschuh wrote:

> > static int rfkill_resume(struct device *dev)
> > {
> >         struct rfkill *rfkill = to_rfkill(dev);
> >         bool cur;
> > 
> >         if (!rfkill->persistent) {
> >                 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
> >                 rfkill_set_block(rfkill, cur);
> >         }
> 
> The issue I am reporting is _only_ about persistent devices, so it is the
> if(!rfkill->persistent) that is the problem.  It works perfectly for the
> other devices.

So then I don't understand -- if the device specifically said that it
was persistent, what kind of help does it need, and why does it not just
unset persistent if it needs it?

johannes


[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 801 bytes --]

Re: rfkill: persistent device suspend/resume

[Alan Jenkins]

Henrique de Moraes Holschuh wrote:
> On Thu, 18 Jun 2009, Henrique de Moraes Holschuh wrote:
>   
>>> The setting of the "persistent" flag is also made more explicit using
>>> a new rfkill_init_sw_state() function, instead of special-casing
>>> rfkill_set_sw_state() when it is called before registration.
>>>
>>> Suspend is a bit of a corner case so we try to get away without adding
>>> another hack to rfkill-input - it's going to be removed soon.
>>> If the state does change over suspend, users will simply have to prod
>>> rfkill-input twice in order to toggle the state.
>>>       
>
> Well, I acked it, but I didn't do my job properly and didn't notice the
> above.
>
> Suspend/resume is not much of a corner case at all:  unless overriden by
> some weird policy that doesn't even exist right now (the only one that comes
> to mind is to have it always off upon resume in highly-critical
> environments), we really want to restore the hardware to the previous soft
> state, subject to any changes on any hard state that happened while the
> machine was sleeping.
>
> And any "weird policy" we might implement would have to come through the
> core anyway.  So, we really should be taking advantage of the fact that the
> rfkill class will resume *after* the device, and let the core call the
> backend (unconditionally, so it is also a way to make sure the
> firmware/hardware is in sync with the core) to set the proper state after a
> resume.
>
> The backend will be able to update any hard states before the rfkill class
> resume code runs, so this will always work fine.   It also allows the
> backend driver to ask the platform to resume with radios disabled, so that
> if we _ever_ decide to change the core to have a different policy to what
> should be done to radios on resume (e.g. leave them off and wait for
> userspace to tell us what to do :) ), that will need no change to drivers
> (and radios won't get turned on just to be turned off, etc).
>
> It will also let us remove a few LOC from eeepc-laptop and avoid adding a
> few LOC to thinkpad-acpi (which has a regression since 2.6.30 because failed
> to notice I would have to handle resume).
>
> What do you guys think?   I will cook up a patch to implement the above, but
> if there are any objections to the idea, I'd like to hear it ASAP, as I do
> have a regression to fix :)
>
> Note: eeepc-laptop and thinkpad-acpi are the only rfkill persistent devices
> in-tree

"Suspend/resume is not much of a corner case at all"


Sorry for my naff patch description. The actual corner case is when the 
soft rfkill state changes between when we suspend and resume.


"we really want to restore the hardware to the previous soft state"

Context warning: this only affects "persistent" rfkill devices. We 
currently do this for everything except thinkpad-acpi and eeepc-laptop.

Blame Marcel, the current choice was his suggestion :). I think his 
argument was that restoring the state could impose policy, and that this 
would be bad. I didn't resist too hard because his principle provides a 
marginal feature in eeepc-laptop.

[That said, I later noticed that it speeds up resume from s2ram. 
eeepc-laptop is 'special'; its WLDS method takes a whole second to run.]

To elaborate:

The state in NV-ram may be changed deliberately. On eeepc-laptop, you 
can change it in the BIOS setup screen - and then resume from 
hibernation. Marcel suggests that overriding this change would be a 
policy decision, which userspace should be able to control. The simplest 
way to do so is to simply preserve the state (and emit an event to 
notify userspace of the change).

I thought thinkpad-acpi might also allow such changes. At least for some 
controls, the BIOS defaults to implementing them itself, right? Even if 
this isn't true for rfkill on the thinkpad, it's a possibility we may 
encounter in future. Imagine a system where this happens:

- hibernate
- boot resume kernel
- user presses rfkill key -> BIOS toggles the rfkill state
- load kernel from hibernation image
- rfkill resume now unconditionally overrides the rfkill state

So your suggestion forces users to accept corner case behaviour like 
this. Marcel's position appears to come from writing a userspace daemon 
which provides persistent state for all rfkill devices. That is, if we 
want to keep in-kernel handling of persistent state in the long run, we 
have to justify it by addressing the corner cases which only the kernel 
can solve.

rfkill-input is scheduled for removal in anticipation of rfkilld. If you 
want to schedule removal of persistent rfkill devices in anticipation of 
"rfkilld with persistence", that would seem just as reasonable :-p. I'm 
sure Johannes would then accept the small change to the rfkill core to 
fix this regression.

Alan

Re: rfkill: persistent device suspend/resume

[Henrique de Moraes Holschuh]

On Sat, 28 Nov 2009, Alan Jenkins wrote:
> Sorry for my naff patch description. The actual corner case is when
> the soft rfkill state changes between when we suspend and resume.

Ah, ok.

> "we really want to restore the hardware to the previous soft state"
> 
> Context warning: this only affects "persistent" rfkill devices. We
> currently do this for everything except thinkpad-acpi and
> eeepc-laptop.

Yes.  This is _only_ about persistent rfkill devices, i.e. thinkpads and
eeepc.

> Blame Marcel, the current choice was his suggestion :). I think his
> argument was that restoring the state could impose policy, and that
> this would be bad. I didn't resist too hard because his principle
> provides a marginal feature in eeepc-laptop.

Actually, that is a good argument, and I was not aware of it.

> [That said, I later noticed that it speeds up resume from s2ram.
> eeepc-laptop is 'special'; its WLDS method takes a whole second to
> run.]

Which is another good argument.

I can fix the regression in thinkpad-acpi either way, and I have just
found that I _will_ have to change code in thinkpad-acpi to fix it in
either case.

But I'd rather do it in the best way possible :)

If the current way (no resume for persistent devices) has real
advantages, I will just deal with it in the driver.

> To elaborate:
> 
> The state in NV-ram may be changed deliberately. On eeepc-laptop,
> you can change it in the BIOS setup screen - and then resume from
> hibernation. Marcel suggests that overriding this change would be a
> policy decision, which userspace should be able to control. The
> simplest way to do so is to simply preserve the state (and emit an
> event to notify userspace of the change).

I see.  that's the missing link.  While thinkpads _can_ do that too, it
changes the *hard* kill line, and it (obviously) cannot be overriden at
all... When you disable radios in the ThinkPad BIOS, they _stay_
disabled... at least on the IBM models.

I was aware of the change-in-NVRAM possibility, but dismissed it since
we don't support booting another OS in the middle of a hibernation
cycle.  The idea that the BIOS could be used to change NVRAM didn't
cross my mind.

> I thought thinkpad-acpi might also allow such changes. At least for
> some controls, the BIOS defaults to implementing them itself, right?

Yes, but for the radios, the BIOS goes the way of "disabled is
disabled", and doesn't let you change the NVRAM.  That might have
changed on the newer Lenovo models, but I have not heard of any changes
yet.

> Even if this isn't true for rfkill on the thinkpad, it's a
> possibility we may encounter in future. Imagine a system where this

You told me EEEPC takes good advantage of the current way of doing
things, and I can certainly make it work properly in thinkpad-acpi as
well.

So, as far as I am concerned, you proved to me that there are strong
advantages for the current way of doing things, and until there is a
compelling need to have radios locked on resume, I think it is best to
leave things as is.

> - hibernate
> - boot resume kernel
> - user presses rfkill key -> BIOS toggles the rfkill state
> - load kernel from hibernation image
> - rfkill resume now unconditionally overrides the rfkill state

Yeah, ugly mess.

> rfkill-input is scheduled for removal in anticipation of rfkilld. If
> you want to schedule removal of persistent rfkill devices in
> anticipation of "rfkilld with persistence", that would seem just as
> reasonable :-p. I'm sure Johannes would then accept the small change
> to the rfkill core to fix this regression.

Nah, I think it is best to deal it in the driver, given the data you
just presented.

And I am strongly against foring users to use rfkilld-based persistence
in platforms that can do better (i.e. thinkpad-acpi and eeepc) :-)

-- 
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh

Re: rfkill: persistent device suspend/resume

[Henrique de Moraes Holschuh]

On Sat, 28 Nov 2009, Johannes Berg wrote:
> On Sat, 2009-11-28 at 11:27 -0200, Henrique de Moraes Holschuh wrote:
> > > static int rfkill_resume(struct device *dev)
> > > {
> > >         struct rfkill *rfkill = to_rfkill(dev);
> > >         bool cur;
> > > 
> > >         if (!rfkill->persistent) {
> > >                 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
> > >                 rfkill_set_block(rfkill, cur);
> > >         }
> > 
> > The issue I am reporting is _only_ about persistent devices, so it is the
> > if(!rfkill->persistent) that is the problem.  It works perfectly for the
> > other devices.
> 
> So then I don't understand -- if the device specifically said that it
> was persistent, what kind of help does it need, and why does it not just
> unset persistent if it needs it?

Never mind, Alan gave me various good reasons for the code to remain as is,
and I will fix it in the driver in another way.

-- 
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh