Date:   Wed, 5 Apr 2023 09:15:02 +0530
From:   Pavankumar Kondeti <quic_pkondeti@...cinc.com>
To:     "Rafael J . Wysocki" <rafael@...nel.org>,
        Pavel Machek <pavel@....cz>
CC:     Len Brown <len.brown@...el.com>, Ye Bin <yebin10@...wei.com>,
        Chen Yu <yu.c.chen@...el.com>,
        Nikhil V <quic_nprakash@...cinc.com>,
        <linux-pm@...r.kernel.org>, <linux-kernel@...r.kernel.org>,
        "Pavankumar Kondeti" <quic_pkondeti@...cinc.com>
Subject: [PATCH] PM: hibernate: Get test_resume hibernation mode working again

Commit 39fbef4b0f77 ("PM: hibernate: Get block device exclusively in
swsusp_check()") changed the opening mode of the block device to
(FMODE_READ | FMODE_EXCL) during resume. This breaks the test_resume
hibernation mode as the block device is not available for exclusive
open. Because the block device is configured as swap during hibernation.

Fix this issue by opening the device in FMODE_READ only in test_resume
restore path. Cache the flags used in opening the block device so that
callers of swsusp_close() does not need to worry about test_resume vs
normal restore.

Fixes: 39fbef4b0f77 ("PM: hibernate: Get block device exclusively in swsusp_check()")
Signed-off-by: Pavankumar Kondeti <quic_pkondeti@...cinc.com>
---
 kernel/power/hibernate.c | 21 +++++++++++-----
 kernel/power/power.h     |  4 +--
 kernel/power/swap.c      | 53 +++++++++++++++++++++++-----------------
 3 files changed, 48 insertions(+), 30 deletions(-)

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index 793c55a2becb..d78edf32a45c 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -693,12 +693,12 @@ static int load_image_and_restore(void)
 	lock_device_hotplug();
 	error = create_basic_memory_bitmaps();
 	if (error) {
-		swsusp_close(FMODE_READ | FMODE_EXCL);
+		swsusp_close();
 		goto Unlock;
 	}
 
 	error = swsusp_read(&flags);
-	swsusp_close(FMODE_READ | FMODE_EXCL);
+	swsusp_close();
 	if (!error)
 		error = hibernation_restore(flags & SF_PLATFORM_MODE);
 
@@ -785,7 +785,12 @@ int hibernate(void)
 	unlock_device_hotplug();
 	if (snapshot_test) {
 		pm_pr_dbg("Checking hibernation image\n");
-		error = swsusp_check();
+		/*
+		 * Block device assigned for storing hibernation image
+		 * is already configured as swap. So exclusive mode
+		 * is not needed. see comments in software_resume().
+		 */
+		error = swsusp_check(FMODE_READ);
 		if (!error)
 			error = load_image_and_restore();
 	}
@@ -983,14 +988,18 @@ static int software_resume(void)
 		MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
 
 	pm_pr_dbg("Looking for hibernation image.\n");
-	error = swsusp_check();
+	/*
+	 * Exclusively get the block device that contains the hibernation
+	 * image so that we can bail out if the block device is mounted.
+	 */
+	error = swsusp_check(FMODE_READ | FMODE_EXCL);
 	if (error)
 		goto Unlock;
 
 	/* The snapshot device should not be opened while we're running */
 	if (!hibernate_acquire()) {
 		error = -EBUSY;
-		swsusp_close(FMODE_READ | FMODE_EXCL);
+		swsusp_close();
 		goto Unlock;
 	}
 
@@ -1025,7 +1034,7 @@ static int software_resume(void)
 	pm_pr_dbg("Hibernation image not present or could not be loaded.\n");
 	return error;
  Close_Finish:
-	swsusp_close(FMODE_READ | FMODE_EXCL);
+	swsusp_close();
 	goto Finish;
 }
 
diff --git a/kernel/power/power.h b/kernel/power/power.h
index b4f433943209..9877f33cc966 100644
--- a/kernel/power/power.h
+++ b/kernel/power/power.h
@@ -173,11 +173,11 @@ extern int swsusp_swap_in_use(void);
 #define SF_HW_SIG		8
 
 /* kernel/power/hibernate.c */
-extern int swsusp_check(void);
+extern int swsusp_check(fmode_t mode);
 extern void swsusp_free(void);
 extern int swsusp_read(unsigned int *flags_p);
 extern int swsusp_write(unsigned int flags);
-extern void swsusp_close(fmode_t);
+extern void swsusp_close(void);
 #ifdef CONFIG_SUSPEND
 extern int swsusp_unmark(void);
 #endif
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 277434b6c0bf..005c0cfe116a 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -338,6 +338,28 @@ static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
 	return error;
 }
 
+static fmode_t hib_resume_bdev_mode;
+static int swsusp_setup_bdev(fmode_t mode)
+{
+	struct block_device *bdev;
+	void *holder;
+	int error;
+
+	bdev = blkdev_get_by_dev(swsusp_resume_device, mode, &holder);
+	if (IS_ERR(bdev))
+		return PTR_ERR(bdev);
+
+	error = set_blocksize(bdev, PAGE_SIZE);
+	if (error) {
+		blkdev_put(bdev, mode);
+		return error;
+	}
+
+	hib_resume_bdev = bdev;
+	hib_resume_bdev_mode = mode;
+	return 0;
+}
+
 /**
  *	swsusp_swap_check - check if the resume device is a swap device
  *	and get its index (if so)
@@ -356,15 +378,7 @@ static int swsusp_swap_check(void)
 		return res;
 	root_swap = res;
 
-	hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device, FMODE_WRITE,
-			NULL);
-	if (IS_ERR(hib_resume_bdev))
-		return PTR_ERR(hib_resume_bdev);
-
-	res = set_blocksize(hib_resume_bdev, PAGE_SIZE);
-	if (res < 0)
-		blkdev_put(hib_resume_bdev, FMODE_WRITE);
-
+	res = swsusp_setup_bdev(FMODE_WRITE);
 	return res;
 }
 
@@ -443,7 +457,7 @@ static int get_swap_writer(struct swap_map_handle *handle)
 err_rel:
 	release_swap_writer(handle);
 err_close:
-	swsusp_close(FMODE_WRITE);
+	swsusp_close();
 	return ret;
 }
 
@@ -508,7 +522,7 @@ static int swap_writer_finish(struct swap_map_handle *handle,
 	if (error)
 		free_all_swap_pages(root_swap);
 	release_swap_writer(handle);
-	swsusp_close(FMODE_WRITE);
+	swsusp_close();
 
 	return error;
 }
@@ -1514,15 +1528,12 @@ int swsusp_read(unsigned int *flags_p)
  *      swsusp_check - Check for swsusp signature in the resume device
  */
 
-int swsusp_check(void)
+int swsusp_check(fmode_t mode)
 {
 	int error;
-	void *holder;
 
-	hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device,
-					    FMODE_READ | FMODE_EXCL, &holder);
-	if (!IS_ERR(hib_resume_bdev)) {
-		set_blocksize(hib_resume_bdev, PAGE_SIZE);
+	error = swsusp_setup_bdev(mode);
+	if (!error) {
 		clear_page(swsusp_header);
 		error = hib_submit_io(REQ_OP_READ, swsusp_resume_block,
 					swsusp_header, NULL);
@@ -1547,11 +1558,9 @@ int swsusp_check(void)
 
 put:
 		if (error)
-			blkdev_put(hib_resume_bdev, FMODE_READ | FMODE_EXCL);
+			blkdev_put(hib_resume_bdev, mode);
 		else
 			pr_debug("Image signature found, resuming\n");
-	} else {
-		error = PTR_ERR(hib_resume_bdev);
 	}
 
 	if (error)
@@ -1564,14 +1573,14 @@ int swsusp_check(void)
  *	swsusp_close - close swap device.
  */
 
-void swsusp_close(fmode_t mode)
+void swsusp_close(void)
 {
 	if (IS_ERR(hib_resume_bdev)) {
 		pr_debug("Image device not initialised\n");
 		return;
 	}
 
-	blkdev_put(hib_resume_bdev, mode);
+	blkdev_put(hib_resume_bdev, hib_resume_bdev_mode);
 }
 
 /**
-- 
2.25.1

Powered by blists - more mailing lists