lkml.org 
[lkml]   [2014]   [Jan]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    SubjectRe: [PATCH V2 0/2] time/cpuidle: Support in tick broadcast framework in absence of external clock device
    Hi Thomas,

    I realized that the below patch is also required for this patchset.

    This patch apart, I noticed that there is also one corner case which we will
    need to handle. The BROADCAST_ON notifications in periodic mode
    (oneshot mode is a nop).
    We will need to fail the BROADCAST_ON notification too in this case if the
    CPU in question is made the stand by CPU.

    Thanks

    Regards
    Preeti U Murthy

    ---------------------------------------------------------------------------------

    time/cpuidle:Handle failed call to BROADCAST_ENTER on archs with CPUIDLE_FLAG_TIMER_STOP set

    From: Preeti U Murthy <preeti@linux.vnet.ibm.com>

    Some archs set the CPUIDLE_FLAG_TIMER_STOP flag for idle states in which the
    local timers stop. The cpuidle_idle_call() currently handles such idle states
    by calling into the broadcast framework so as to wakeup CPUs at their next
    wakeup event. With the hrtimer mode of broadcast, the BROADCAST_ENTER call
    into the broadcast frameowork can fail for archs that do not have an external
    clock device to handle wakeups and the CPU in question has to thus be made
    the stand by CPU. This patch handles such cases by failing the call into
    cpuidle so that the arch can take some default action. The arch will certainly
    not enter a similar idle state because a failed cpuidle call will also implicitly
    indicate that the broadcast framework has not registered this CPU to be woken up.
    Hence we are safe if we fail the cpuidle call.

    In the process move the functions that trace idle statistics just before and
    after the entry and exit into idle states respectively. In other
    scenarios where the call to cpuidle fails, we end up not tracing idle
    entry and exit since a decision on an idle state could not be taken. Similarly
    when the call to broadcast framework fails, we skip tracing idle statistics
    because we are in no further position to take a decision on an alternative
    idle state to enter into.

    Signed-off-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
    ---
    drivers/cpuidle/cpuidle.c | 38 +++++++++++++++++++++++---------------
    1 file changed, 23 insertions(+), 15 deletions(-)

    diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
    index a55e68f..8f42033 100644
    --- a/drivers/cpuidle/cpuidle.c
    +++ b/drivers/cpuidle/cpuidle.c
    @@ -117,15 +117,19 @@ int cpuidle_idle_call(void)
    {
    struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices);
    struct cpuidle_driver *drv;
    - int next_state, entered_state;
    - bool broadcast;
    + int next_state, entered_state, ret = 0;
    + bool broadcast = false;

    - if (off || !initialized)
    - return -ENODEV;
    + if (off || !initialized) {
    + ret = -ENODEV;
    + goto out;
    + }

    /* check if the device is ready */
    - if (!dev || !dev->enabled)
    - return -EBUSY;
    + if (!dev || !dev->enabled) {
    + ret = -EBUSY;
    + goto out;
    + }

    drv = cpuidle_get_cpu_driver(dev);

    @@ -137,15 +141,18 @@ int cpuidle_idle_call(void)
    if (cpuidle_curr_governor->reflect)
    cpuidle_curr_governor->reflect(dev, next_state);
    local_irq_enable();
    - return 0;
    + goto out;
    }

    - trace_cpu_idle_rcuidle(next_state, dev->cpu);
    -
    broadcast = !!(drv->states[next_state].flags & CPUIDLE_FLAG_TIMER_STOP);

    - if (broadcast)
    - clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
    + if (broadcast) {
    + ret = clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu);
    + if (ret)
    + goto out;
    + }
    +
    + trace_cpu_idle_rcuidle(next_state, dev->cpu);

    if (cpuidle_state_is_coupled(dev, drv, next_state))
    entered_state = cpuidle_enter_state_coupled(dev, drv,
    @@ -153,16 +160,17 @@ int cpuidle_idle_call(void)
    else
    entered_state = cpuidle_enter_state(dev, drv, next_state);

    - if (broadcast)
    - clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
    -
    trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, dev->cpu);

    /* give the governor an opportunity to reflect on the outcome */
    if (cpuidle_curr_governor->reflect)
    cpuidle_curr_governor->reflect(dev, entered_state);

    - return 0;
    +out: if (broadcast)
    + clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
    +
    +
    + return ret;
    }

    /**


    \
     
     \ /
      Last update: 2014-01-28 12:41    [W:2.333 / U:0.072 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site