PM / reboot: Eliminate race between reboot and suspend

Yes, there are.

First of all, grabbing the 'pm_mutex' lock to mutually exclude a piece of code

First of all, grabbing the 'system_transition_mutex' lock to mutually exclude a piece of code

from system-wide sleep such as suspend/hibernation is not encouraged.

If possible, that piece of code must instead hook onto the suspend/hibernation

notifiers to achieve mutual exclusion. Look at the CPU-Hotplug code

(kernel/cpu.c) for an example.

However, if that is not feasible, and grabbing 'pm_mutex' is deemed necessary,

it is strongly discouraged to directly call mutex_[un]lock(&pm_mutex) since

However, if that is not feasible, and grabbing 'system_transition_mutex' is deemed necessary,

it is strongly discouraged to directly call mutex_[un]lock(&system_transition_mutex) since

that could lead to freezing failures, because if the suspend/hibernate code

successfully acquired the 'pm_mutex' lock, and hence that other entity failed

successfully acquired the 'system_transition_mutex' lock, and hence that other entity failed

to acquire the lock, then that task would get blocked in TASK_UNINTERRUPTIBLE

state. As a consequence, the freezer would not be able to freeze that task,

leading to freezing failure.

However, the [un]lock_system_sleep() APIs are safe to use in this scenario,

since they ask the freezer to skip freezing this task, since it is anyway

"frozen enough" as it is blocked on 'pm_mutex', which will be released

"frozen enough" as it is blocked on 'system_transition_mutex', which will be released

only after the entire suspend/hibernation sequence is complete.

So, to summarize, use [un]lock_system_sleep() instead of directly using

mutex_[un]lock(&pm_mutex). That would prevent freezing failures.

mutex_[un]lock(&system_transition_mutex). That would prevent freezing failures.

V. Miscellaneous

/sys/power/pm_freeze_timeout controls how long it will cost at most to freeze

                                    sysfs file

                                        |

                                        v

                               Acquire pm_mutex lock

                               Acquire system_transition_mutex lock

                                        |

                                        v

                             Send PM_SUSPEND_PREPARE

* thaw tasks

* send PM_POST_SUSPEND notifications

* Release pm_mutex lock.

* Release system_transition_mutex lock.

It is to be noted here that the pm_mutex lock is acquired at the very

It is to be noted here that the system_transition_mutex lock is acquired at the very

beginning, when we are just starting out to suspend, and then released only

after the entire cycle is complete (i.e., suspend + resume).

#define PM_RESTORE_PREPARE	0x0005 /* Going to restore a saved image */

#define PM_POST_RESTORE		0x0006 /* Restore failed */

extern struct mutex pm_mutex;

extern struct mutex system_transition_mutex;

#ifdef CONFIG_PM_SLEEP

void save_processor_state(void);

atomic_t system_freezing_cnt = ATOMIC_INIT(0);

EXPORT_SYMBOL(system_freezing_cnt);

/* indicate whether PM freezing is in effect, protected by pm_mutex */

/* indicate whether PM freezing is in effect, protected by

 * system_transition_mutex

 */

bool pm_freezing;

bool pm_nosig_freezing;

 * hibernation_snapshot - Quiesce devices and create a hibernation image.

 * @platform_mode: If set, use platform driver to prepare for the transition.

 *

 * This routine must be called with pm_mutex held.

 * This routine must be called with system_transition_mutex held.

 */

int hibernation_snapshot(int platform_mode)

{

 * hibernation_restore - Quiesce devices and restore from a hibernation image.

 * @platform_mode: If set, use platform driver to prepare for the transition.

 *

 * This routine must be called with pm_mutex held.  If it is successful, control

 * reappears in the restored target kernel in hibernation_snapshot().

 * This routine must be called with system_transition_mutex held.  If it is

 * successful, control reappears in the restored target kernel in

 * hibernation_snapshot().

 */

int hibernation_restore(int platform_mode)

{

	 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs

	 * is configured into the kernel. Since the regular hibernate

	 * trigger path is via sysfs which takes a buffer mutex before

	 * calling hibernate functions (which take pm_mutex) this can

	 * cause lockdep to complain about a possible ABBA deadlock

	 * calling hibernate functions (which take system_transition_mutex)

	 * this can cause lockdep to complain about a possible ABBA deadlock

	 * which cannot happen since we're in the boot code here and

	 * sysfs can't be invoked yet. Therefore, we use a subclass

	 * here to avoid lockdep complaining.

	 */

	mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);

	mutex_lock_nested(&system_transition_mutex, SINGLE_DEPTH_NESTING);

	if (swsusp_resume_device)

		goto Check_image;

	atomic_inc(&snapshot_device_available);

	/* For success case, the suspend path will release the lock */

 Unlock:

	mutex_unlock(&pm_mutex);

	mutex_unlock(&system_transition_mutex);

	pm_pr_dbg("Hibernation image not present or could not be loaded.\n");

	return error;

 Close_Finish: