swsusp: use inline functions for changing page flags

Replace direct invocations of SetPageNosave(), SetPageNosaveFree() etc. with calls to inline functions that can be changed in subsequent patches without modifying the code calling them. Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> Acked-by: Pavel Machek <pavel@ucw.cz> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

swsusp: use inline functions for changing page flags
Replace direct invocations of SetPageNosave(), SetPageNosaveFree() etc. with calls to inline functions that can be changed in subsequent patches without modifying the code calling them. Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> Acked-by: Pavel Machek <pavel@ucw.cz> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Rafael J. Wysocki · Linus Torvalds
1 parent 433ecb4ab3
Showing 3 changed files with 61 additions and 26 deletions Side-by-side Diff
include/linux/suspend.h
kernel/power/snapshot.c
mm/page_alloc.c
@@ -8,6 +8,7 @@
 #include <linux/notifier.h>
 #include <linux/init.h>
 #include <linux/pm.h>
+#include <linux/mm.h>
  
 /* struct pbe is used for creating lists of pages that should be restored
  * atomically during the resume from disk, because the page frames they have
@@ -48,6 +49,38 @@
 void __save_processor_state(struct saved_context *ctxt);
 void __restore_processor_state(struct saved_context *ctxt);
 unsigned long get_safe_page(gfp_t gfp_mask);
+
+/* Page management functions for the software suspend (swsusp) */
+
+static inline void swsusp_set_page_forbidden(struct page *page)
+{
+	SetPageNosave(page);
+}
+
+static inline int swsusp_page_is_forbidden(struct page *page)
+{
+	return PageNosave(page);
+}
+
+static inline void swsusp_unset_page_forbidden(struct page *page)
+{
+	ClearPageNosave(page);
+}
+
+static inline void swsusp_set_page_free(struct page *page)
+{
+	SetPageNosaveFree(page);
+}
+
+static inline int swsusp_page_is_free(struct page *page)
+{
+	return PageNosaveFree(page);
+}
+
+static inline void swsusp_unset_page_free(struct page *page)
+{
+	ClearPageNosaveFree(page);
+}
  
 /*
  * XXX: We try to keep some more pages free so that I/O operations succeed
@@ -67,15 +67,15 @@
  
 	res = (void *)get_zeroed_page(gfp_mask);
 	if (safe_needed)
-		while (res && PageNosaveFree(virt_to_page(res))) {
+		while (res && swsusp_page_is_free(virt_to_page(res))) {
 			/* The page is unsafe, mark it for swsusp_free() */
-			SetPageNosave(virt_to_page(res));
+			swsusp_set_page_forbidden(virt_to_page(res));
 			allocated_unsafe_pages++;
 			res = (void *)get_zeroed_page(gfp_mask);
 		}
 	if (res) {
-		SetPageNosave(virt_to_page(res));
-		SetPageNosaveFree(virt_to_page(res));
+		swsusp_set_page_forbidden(virt_to_page(res));
+		swsusp_set_page_free(virt_to_page(res));
 	}
 	return res;
 }
@@ -91,8 +91,8 @@
  
 	page = alloc_page(gfp_mask);
 	if (page) {
-		SetPageNosave(page);
-		SetPageNosaveFree(page);
+		swsusp_set_page_forbidden(page);
+		swsusp_set_page_free(page);
 	}
 	return page;
 }
  
@@ -110,9 +110,9 @@
  
 	page = virt_to_page(addr);
  
-	ClearPageNosave(page);
+	swsusp_unset_page_forbidden(page);
 	if (clear_nosave_free)
-		ClearPageNosaveFree(page);
+		swsusp_unset_page_free(page);
  
 	__free_page(page);
 }
@@ -615,7 +615,8 @@
  
 	BUG_ON(!PageHighMem(page));
  
-	if (PageNosave(page) || PageReserved(page) || PageNosaveFree(page))
+	if (swsusp_page_is_forbidden(page) ||  swsusp_page_is_free(page) ||
+	    PageReserved(page))
 		return NULL;
  
 	return page;
@@ -670,7 +671,7 @@
  
 	BUG_ON(PageHighMem(page));
  
-	if (PageNosave(page) || PageNosaveFree(page))
+	if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page))
 		return NULL;
  
 	if (PageReserved(page) && pfn_is_nosave(pfn))
@@ -810,9 +811,10 @@
 			if (pfn_valid(pfn)) {
 				struct page *page = pfn_to_page(pfn);
  
-				if (PageNosave(page) && PageNosaveFree(page)) {
-					ClearPageNosave(page);
-					ClearPageNosaveFree(page);
+				if (swsusp_page_is_forbidden(page) &&
+				    swsusp_page_is_free(page)) {
+					swsusp_unset_page_forbidden(page);
+					swsusp_unset_page_free(page);
 					__free_page(page);
 				}
 			}
@@ -1135,7 +1137,7 @@
 		max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
 		for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
 			if (pfn_valid(pfn))
-				ClearPageNosaveFree(pfn_to_page(pfn));
+				swsusp_unset_page_free(pfn_to_page(pfn));
 	}
  
 	/* Mark pages that correspond to the "original" pfns as "unsafe" */
@@ -1144,7 +1146,7 @@
 		pfn = memory_bm_next_pfn(bm);
 		if (likely(pfn != BM_END_OF_MAP)) {
 			if (likely(pfn_valid(pfn)))
-				SetPageNosaveFree(pfn_to_page(pfn));
+				swsusp_set_page_free(pfn_to_page(pfn));
 			else
 				return -EFAULT;
 		}
  
@@ -1310,14 +1312,14 @@
 		struct page *page;
  
 		page = alloc_page(__GFP_HIGHMEM);
-		if (!PageNosaveFree(page)) {
+		if (!swsusp_page_is_free(page)) {
 			/* The page is "safe", set its bit the bitmap */
 			memory_bm_set_bit(bm, page_to_pfn(page));
 			safe_highmem_pages++;
 		}
 		/* Mark the page as allocated */
-		SetPageNosave(page);
-		SetPageNosaveFree(page);
+		swsusp_set_page_forbidden(page);
+		swsusp_set_page_free(page);
 	}
 	memory_bm_position_reset(bm);
 	safe_highmem_bm = bm;
@@ -1349,7 +1351,7 @@
 	struct highmem_pbe *pbe;
 	void *kaddr;
  
-	if (PageNosave(page) && PageNosaveFree(page)) {
+	if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page)) {
 		/* We have allocated the "original" page frame and we can
 		 * use it directly to store the loaded page.
 		 */
  
@@ -1511,14 +1513,14 @@
 			error = -ENOMEM;
 			goto Free;
 		}
-		if (!PageNosaveFree(virt_to_page(lp))) {
+		if (!swsusp_page_is_free(virt_to_page(lp))) {
 			/* The page is "safe", add it to the list */
 			lp->next = safe_pages_list;
 			safe_pages_list = lp;
 		}
 		/* Mark the page as allocated */
-		SetPageNosave(virt_to_page(lp));
-		SetPageNosaveFree(virt_to_page(lp));
+		swsusp_set_page_forbidden(virt_to_page(lp));
+		swsusp_set_page_free(virt_to_page(lp));
 		nr_pages--;
 	}
 	/* Free the reserved safe pages so that chain_alloc() can use them */
@@ -1547,7 +1549,7 @@
 	if (PageHighMem(page))
 		return get_highmem_page_buffer(page, ca);
  
-	if (PageNosave(page) && PageNosaveFree(page))
+	if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page))
 		/* We have allocated the "original" page frame and we can
 		 * use it directly to store the loaded page.
 		 */
@@ -775,8 +775,8 @@
 		if (pfn_valid(pfn)) {
 			struct page *page = pfn_to_page(pfn);
  
-			if (!PageNosave(page))
-				ClearPageNosaveFree(page);
+			if (!swsusp_page_is_forbidden(page))
+				swsusp_unset_page_free(page);
 		}
  
 	for (order = MAX_ORDER - 1; order >= 0; --order)
@@ -785,7 +785,7 @@
  
 			pfn = page_to_pfn(list_entry(curr, struct page, lru));
 			for (i = 0; i < (1UL << order); i++)
-				SetPageNosaveFree(pfn_to_page(pfn + i));
+				swsusp_set_page_free(pfn_to_page(pfn + i));
 		}
  
 	spin_unlock_irqrestore(&zone->lock, flags);
...	...	@@ -8,6 +8,7 @@
8	8	#include <linux/notifier.h>
9	9	#include <linux/init.h>
10	10	#include <linux/pm.h>
	11	+#include <linux/mm.h>
11	12
12	13	/* struct pbe is used for creating lists of pages that should be restored
13	14	* atomically during the resume from disk, because the page frames they have
...	...	@@ -48,6 +49,38 @@
48	49	void __save_processor_state(struct saved_context *ctxt);
49	50	void __restore_processor_state(struct saved_context *ctxt);
50	51	unsigned long get_safe_page(gfp_t gfp_mask);
	52	+
	53	+/* Page management functions for the software suspend (swsusp) */
	54	+
	55	+static inline void swsusp_set_page_forbidden(struct page *page)
	56	+{
	57	+ SetPageNosave(page);
	58	+}
	59	+
	60	+static inline int swsusp_page_is_forbidden(struct page *page)
	61	+{
	62	+ return PageNosave(page);
	63	+}
	64	+
	65	+static inline void swsusp_unset_page_forbidden(struct page *page)
	66	+{
	67	+ ClearPageNosave(page);
	68	+}
	69	+
	70	+static inline void swsusp_set_page_free(struct page *page)
	71	+{
	72	+ SetPageNosaveFree(page);
	73	+}
	74	+
	75	+static inline int swsusp_page_is_free(struct page *page)
	76	+{
	77	+ return PageNosaveFree(page);
	78	+}
	79	+
	80	+static inline void swsusp_unset_page_free(struct page *page)
	81	+{
	82	+ ClearPageNosaveFree(page);
	83	+}
51	84
52	85	/*
53	86	* XXX: We try to keep some more pages free so that I/O operations succeed
...	...	@@ -67,15 +67,15 @@
67	67
68	68	res = (void *)get_zeroed_page(gfp_mask);
69	69	if (safe_needed)
70		- while (res && PageNosaveFree(virt_to_page(res))) {
	70	+ while (res && swsusp_page_is_free(virt_to_page(res))) {
71	71	/* The page is unsafe, mark it for swsusp_free() */
72		- SetPageNosave(virt_to_page(res));
	72	+ swsusp_set_page_forbidden(virt_to_page(res));
73	73	allocated_unsafe_pages++;
74	74	res = (void *)get_zeroed_page(gfp_mask);
75	75	}
76	76	if (res) {
77		- SetPageNosave(virt_to_page(res));
78		- SetPageNosaveFree(virt_to_page(res));
	77	+ swsusp_set_page_forbidden(virt_to_page(res));
	78	+ swsusp_set_page_free(virt_to_page(res));
79	79	}
80	80	return res;
81	81	}
...	...	@@ -91,8 +91,8 @@
91	91
92	92	page = alloc_page(gfp_mask);
93	93	if (page) {
94		- SetPageNosave(page);
95		- SetPageNosaveFree(page);
	94	+ swsusp_set_page_forbidden(page);
	95	+ swsusp_set_page_free(page);
96	96	}
97	97	return page;
98	98	}
99	99
...	...	@@ -110,9 +110,9 @@
110	110
111	111	page = virt_to_page(addr);
112	112
113		- ClearPageNosave(page);
	113	+ swsusp_unset_page_forbidden(page);
114	114	if (clear_nosave_free)
115		- ClearPageNosaveFree(page);
	115	+ swsusp_unset_page_free(page);
116	116
117	117	__free_page(page);
118	118	}
...	...	@@ -615,7 +615,8 @@
615	615
616	616	BUG_ON(!PageHighMem(page));
617	617
618		- if (PageNosave(page) \|\| PageReserved(page) \|\| PageNosaveFree(page))
	618	+ if (swsusp_page_is_forbidden(page) \|\| swsusp_page_is_free(page) \|\|
	619	+ PageReserved(page))
619	620	return NULL;
620	621
621	622	return page;
...	...	@@ -670,7 +671,7 @@
670	671
671	672	BUG_ON(PageHighMem(page));
672	673
673		- if (PageNosave(page) \|\| PageNosaveFree(page))
	674	+ if (swsusp_page_is_forbidden(page) \|\| swsusp_page_is_free(page))
674	675	return NULL;
675	676
676	677	if (PageReserved(page) && pfn_is_nosave(pfn))
...	...	@@ -810,9 +811,10 @@
810	811	if (pfn_valid(pfn)) {
811	812	struct page *page = pfn_to_page(pfn);
812	813
813		- if (PageNosave(page) && PageNosaveFree(page)) {
814		- ClearPageNosave(page);
815		- ClearPageNosaveFree(page);
	814	+ if (swsusp_page_is_forbidden(page) &&
	815	+ swsusp_page_is_free(page)) {
	816	+ swsusp_unset_page_forbidden(page);
	817	+ swsusp_unset_page_free(page);
816	818	__free_page(page);
817	819	}
818	820	}
...	...	@@ -1135,7 +1137,7 @@
1135	1137	max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
1136	1138	for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
1137	1139	if (pfn_valid(pfn))
1138		- ClearPageNosaveFree(pfn_to_page(pfn));
	1140	+ swsusp_unset_page_free(pfn_to_page(pfn));
1139	1141	}
1140	1142
1141	1143	/* Mark pages that correspond to the "original" pfns as "unsafe" */
...	...	@@ -1144,7 +1146,7 @@
1144	1146	pfn = memory_bm_next_pfn(bm);
1145	1147	if (likely(pfn != BM_END_OF_MAP)) {
1146	1148	if (likely(pfn_valid(pfn)))
1147		- SetPageNosaveFree(pfn_to_page(pfn));
	1149	+ swsusp_set_page_free(pfn_to_page(pfn));
1148	1150	else
1149	1151	return -EFAULT;
1150	1152	}
1151	1153
...	...	@@ -1310,14 +1312,14 @@
1310	1312	struct page *page;
1311	1313
1312	1314	page = alloc_page(__GFP_HIGHMEM);
1313		- if (!PageNosaveFree(page)) {
	1315	+ if (!swsusp_page_is_free(page)) {
1314	1316	/* The page is "safe", set its bit the bitmap */
1315	1317	memory_bm_set_bit(bm, page_to_pfn(page));
1316	1318	safe_highmem_pages++;
1317	1319	}
1318	1320	/* Mark the page as allocated */
1319		- SetPageNosave(page);
1320		- SetPageNosaveFree(page);
	1321	+ swsusp_set_page_forbidden(page);
	1322	+ swsusp_set_page_free(page);
1321	1323	}
1322	1324	memory_bm_position_reset(bm);
1323	1325	safe_highmem_bm = bm;
...	...	@@ -1349,7 +1351,7 @@
1349	1351	struct highmem_pbe *pbe;
1350	1352	void *kaddr;
1351	1353
1352		- if (PageNosave(page) && PageNosaveFree(page)) {
	1354	+ if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page)) {
1353	1355	/* We have allocated the "original" page frame and we can
1354	1356	* use it directly to store the loaded page.
1355	1357	*/
1356	1358
...	...	@@ -1511,14 +1513,14 @@
1511	1513	error = -ENOMEM;
1512	1514	goto Free;
1513	1515	}
1514		- if (!PageNosaveFree(virt_to_page(lp))) {
	1516	+ if (!swsusp_page_is_free(virt_to_page(lp))) {
1515	1517	/* The page is "safe", add it to the list */
1516	1518	lp->next = safe_pages_list;
1517	1519	safe_pages_list = lp;
1518	1520	}
1519	1521	/* Mark the page as allocated */
1520		- SetPageNosave(virt_to_page(lp));
1521		- SetPageNosaveFree(virt_to_page(lp));
	1522	+ swsusp_set_page_forbidden(virt_to_page(lp));
	1523	+ swsusp_set_page_free(virt_to_page(lp));
1522	1524	nr_pages--;
1523	1525	}
1524	1526	/* Free the reserved safe pages so that chain_alloc() can use them */
...	...	@@ -1547,7 +1549,7 @@
1547	1549	if (PageHighMem(page))
1548	1550	return get_highmem_page_buffer(page, ca);
1549	1551
1550		- if (PageNosave(page) && PageNosaveFree(page))
	1552	+ if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page))
1551	1553	/* We have allocated the "original" page frame and we can
1552	1554	* use it directly to store the loaded page.
1553	1555	*/
...	...	@@ -775,8 +775,8 @@
775	775	if (pfn_valid(pfn)) {
776	776	struct page *page = pfn_to_page(pfn);
777	777
778		- if (!PageNosave(page))
779		- ClearPageNosaveFree(page);
	778	+ if (!swsusp_page_is_forbidden(page))
	779	+ swsusp_unset_page_free(page);
780	780	}
781	781
782	782	for (order = MAX_ORDER - 1; order >= 0; --order)
...	...	@@ -785,7 +785,7 @@
785	785
786	786	pfn = page_to_pfn(list_entry(curr, struct page, lru));
787	787	for (i = 0; i < (1UL << order); i++)
788		- SetPageNosaveFree(pfn_to_page(pfn + i));
	788	+ swsusp_set_page_free(pfn_to_page(pfn + i));
789	789	}
790	790
791	791	spin_unlock_irqrestore(&zone->lock, flags);