lkml.org 
[lkml]   [2012]   [Jan]   [10]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[38/42] PM / Sleep: Fix race between CPU hotplug and freezer
    3.1-stable review patch.  If anyone has any objections, please let me know.

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

    From: "Srivatsa S. Bhat" <srivatsa.bhat@linux.vnet.ibm.com>

    commit 79cfbdfa87e84992d509e6c1648a18e1d7e68c20 upstream.

    The CPU hotplug notifications sent out by the _cpu_up() and _cpu_down()
    functions depend on the value of the 'tasks_frozen' argument passed to them
    (which indicates whether tasks have been frozen or not).
    (Examples for such CPU hotplug notifications: CPU_ONLINE, CPU_ONLINE_FROZEN,
    CPU_DEAD, CPU_DEAD_FROZEN).

    Thus, it is essential that while the callbacks for those notifications are
    running, the state of the system with respect to the tasks being frozen or
    not remains unchanged, *throughout that duration*. Hence there is a need for
    synchronizing the CPU hotplug code with the freezer subsystem.

    Since the freezer is involved only in the Suspend/Hibernate call paths, this
    patch hooks the CPU hotplug code to the suspend/hibernate notifiers
    PM_[SUSPEND|HIBERNATE]_PREPARE and PM_POST_[SUSPEND|HIBERNATE] to prevent
    the race between CPU hotplug and freezer, thus ensuring that CPU hotplug
    notifications will always be run with the state of the system really being
    what the notifications indicate, _throughout_ their execution time.

    Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
    Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
    Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

    ---
    kernel/cpu.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    1 file changed, 74 insertions(+)

    --- a/kernel/cpu.c
    +++ b/kernel/cpu.c
    @@ -15,6 +15,7 @@
    #include <linux/stop_machine.h>
    #include <linux/mutex.h>
    #include <linux/gfp.h>
    +#include <linux/suspend.h>

    #ifdef CONFIG_SMP
    /* Serializes the updates to cpu_online_mask, cpu_present_mask */
    @@ -476,6 +477,79 @@ static int alloc_frozen_cpus(void)
    return 0;
    }
    core_initcall(alloc_frozen_cpus);
    +
    +/*
    + * Prevent regular CPU hotplug from racing with the freezer, by disabling CPU
    + * hotplug when tasks are about to be frozen. Also, don't allow the freezer
    + * to continue until any currently running CPU hotplug operation gets
    + * completed.
    + * To modify the 'cpu_hotplug_disabled' flag, we need to acquire the
    + * 'cpu_add_remove_lock'. And this same lock is also taken by the regular
    + * CPU hotplug path and released only after it is complete. Thus, we
    + * (and hence the freezer) will block here until any currently running CPU
    + * hotplug operation gets completed.
    + */
    +void cpu_hotplug_disable_before_freeze(void)
    +{
    + cpu_maps_update_begin();
    + cpu_hotplug_disabled = 1;
    + cpu_maps_update_done();
    +}
    +
    +
    +/*
    + * When tasks have been thawed, re-enable regular CPU hotplug (which had been
    + * disabled while beginning to freeze tasks).
    + */
    +void cpu_hotplug_enable_after_thaw(void)
    +{
    + cpu_maps_update_begin();
    + cpu_hotplug_disabled = 0;
    + cpu_maps_update_done();
    +}
    +
    +/*
    + * When callbacks for CPU hotplug notifications are being executed, we must
    + * ensure that the state of the system with respect to the tasks being frozen
    + * or not, as reported by the notification, remains unchanged *throughout the
    + * duration* of the execution of the callbacks.
    + * Hence we need to prevent the freezer from racing with regular CPU hotplug.
    + *
    + * This synchronization is implemented by mutually excluding regular CPU
    + * hotplug and Suspend/Hibernate call paths by hooking onto the Suspend/
    + * Hibernate notifications.
    + */
    +static int
    +cpu_hotplug_pm_callback(struct notifier_block *nb,
    + unsigned long action, void *ptr)
    +{
    + switch (action) {
    +
    + case PM_SUSPEND_PREPARE:
    + case PM_HIBERNATION_PREPARE:
    + cpu_hotplug_disable_before_freeze();
    + break;
    +
    + case PM_POST_SUSPEND:
    + case PM_POST_HIBERNATION:
    + cpu_hotplug_enable_after_thaw();
    + break;
    +
    + default:
    + return NOTIFY_DONE;
    + }
    +
    + return NOTIFY_OK;
    +}
    +
    +
    +int cpu_hotplug_pm_sync_init(void)
    +{
    + pm_notifier(cpu_hotplug_pm_callback, 0);
    + return 0;
    +}
    +core_initcall(cpu_hotplug_pm_sync_init);
    +
    #endif /* CONFIG_PM_SLEEP_SMP */

    /**



    \
     
     \ /
      Last update: 2012-01-11 00:05    [W:0.024 / U:1.940 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site