PM: sleep: Allow pm_restrict_gfp_mask() stacking

Allow pm_restrict_gfp_mask() to be called many times in a row to avoid
issues with calling dpm_suspend_start() when the GFP mask has been
already restricted.

Only the first invocation of pm_restrict_gfp_mask() will actually
restrict the GFP mask and the subsequent calls will warn if there is
a mismatch between the expected allowed GFP mask and the actual one.

Moreover, if pm_restrict_gfp_mask() is called many times in a row,
pm_restore_gfp_mask() needs to be called matching number of times in
a row to actually restore the GFP mask.  Calling it when the GFP mask
has not been restricted will cause it to warn.

This is necessary for the GFP mask restriction starting in
hibernation_snapshot() to continue throughout the entire hibernation
flow until it completes or it is aborted (either by a wakeup event or
by an error).

Fixes: 449c9c02537a1 ("PM: hibernate: Restrict GFP mask in hibernation_snapshot()")
Fixes: 469d80a3712c ("PM: hibernate: Fix hybrid-sleep")
Reported-by: Askar Safin <safinaskar@gmail.com>
Closes: https://lore.kernel.org/linux-pm/20251025050812.421905-1-safinaskar@gmail.com/
Link: https://lore.kernel.org/linux-pm/20251028111730.2261404-1-safinaskar@gmail.com/
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Mario Limonciello (AMD) <superm1@kernel.org>
Tested-by: Mario Limonciello (AMD) <superm1@kernel.org>
Cc: 6.16+ <stable@vger.kernel.org> # 6.16+
Link: https://patch.msgid.link/5935682.DvuYhMxLoT@rafael.j.wysocki

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index 14e85ff235512343be317d028c8dcb9d7b336ce4..53166ef86ba4687fea6f00db1ab910c0f98c9391 100644 (file)
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -706,7 +706,6 @@ static void power_down(void)
 
 #ifdef CONFIG_SUSPEND
        if (hibernation_mode == HIBERNATION_SUSPEND) {
-               pm_restore_gfp_mask();
                error = suspend_devices_and_enter(mem_sleep_current);
                if (!error)
                        goto exit;
@@ -746,9 +745,6 @@ static void power_down(void)
                cpu_relax();
 
 exit:
-       /* Match the pm_restore_gfp_mask() call in hibernate(). */
-       pm_restrict_gfp_mask();
-
        /* Restore swap signature. */
        error = swsusp_unmark();
        if (error)

diff --git a/kernel/power/main.c b/kernel/power/main.c
index 3cf2d7e72567ecbea2cd80acd3c7f6da85f5bef4..549f51ca3a1e6df12632db31394a6f0bb62312e0 100644 (file)
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -31,23 +31,35 @@
  * held, unless the suspend/hibernate code is guaranteed not to run in parallel
  * with that modification).
  */
+static unsigned int saved_gfp_count;
 static gfp_t saved_gfp_mask;
 
 void pm_restore_gfp_mask(void)
 {
        WARN_ON(!mutex_is_locked(&system_transition_mutex));
-       if (saved_gfp_mask) {
-               gfp_allowed_mask = saved_gfp_mask;
-               saved_gfp_mask = 0;
-       }
+
+       if (WARN_ON(!saved_gfp_count) || --saved_gfp_count)
+               return;
+
+       gfp_allowed_mask = saved_gfp_mask;
+       saved_gfp_mask = 0;
+
+       pm_pr_dbg("GFP mask restored\n");
 }
 
 void pm_restrict_gfp_mask(void)
 {
        WARN_ON(!mutex_is_locked(&system_transition_mutex));
-       WARN_ON(saved_gfp_mask);
+
+       if (saved_gfp_count++) {
+               WARN_ON((saved_gfp_mask & ~(__GFP_IO | __GFP_FS)) != gfp_allowed_mask);
+               return;
+       }
+
        saved_gfp_mask = gfp_allowed_mask;
        gfp_allowed_mask &= ~(__GFP_IO | __GFP_FS);
+
+       pm_pr_dbg("GFP mask restricted\n");
 }
 
 unsigned int lock_system_sleep(void)