write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/include/linux/page_idle.h
..
..
@@ -6,7 +6,7 @@
6
6
 #include <linux/page-flags.h>
7
7
 #include <linux/page_ext.h>
8
8
 
9
-#ifdef CONFIG_IDLE_PAGE_TRACKING
9
+#ifdef CONFIG_PAGE_IDLE_FLAG
10
10
 
11
11
 #ifdef CONFIG_64BIT
12
12
 static inline bool page_is_young(struct page *page)
..
..
@@ -47,66 +47,81 @@
47
47
 
48
48
 static inline bool page_is_young(struct page *page)
49
49
 {
50
-	struct page_ext *page_ext = lookup_page_ext(page);
50
+	struct page_ext *page_ext = page_ext_get(page);
51
+	bool page_young;
51
52
 
52
53
 	if (unlikely(!page_ext))
53
54
 		return false;
54
55
 
55
-	return test_bit(PAGE_EXT_YOUNG, &page_ext->flags);
56
+	page_young = test_bit(PAGE_EXT_YOUNG, &page_ext->flags);
57
+	page_ext_put(page_ext);
58
+
59
+	return page_young;
56
60
 }
57
61
 
58
62
 static inline void set_page_young(struct page *page)
59
63
 {
60
-	struct page_ext *page_ext = lookup_page_ext(page);
64
+	struct page_ext *page_ext = page_ext_get(page);
61
65
 
62
66
 	if (unlikely(!page_ext))
63
67
 		return;
64
68
 
65
69
 	set_bit(PAGE_EXT_YOUNG, &page_ext->flags);
70
+	page_ext_put(page_ext);
66
71
 }
67
72
 
68
73
 static inline bool test_and_clear_page_young(struct page *page)
69
74
 {
70
-	struct page_ext *page_ext = lookup_page_ext(page);
75
+	struct page_ext *page_ext = page_ext_get(page);
76
+	bool page_young;
71
77
 
72
78
 	if (unlikely(!page_ext))
73
79
 		return false;
74
80
 
75
-	return test_and_clear_bit(PAGE_EXT_YOUNG, &page_ext->flags);
81
+	page_young = test_and_clear_bit(PAGE_EXT_YOUNG, &page_ext->flags);
82
+	page_ext_put(page_ext);
83
+
84
+	return page_young;
76
85
 }
77
86
 
78
87
 static inline bool page_is_idle(struct page *page)
79
88
 {
80
-	struct page_ext *page_ext = lookup_page_ext(page);
89
+	struct page_ext *page_ext = page_ext_get(page);
90
+	bool page_idle;
81
91
 
82
92
 	if (unlikely(!page_ext))
83
93
 		return false;
84
94
 
85
-	return test_bit(PAGE_EXT_IDLE, &page_ext->flags);
95
+	page_idle =  test_bit(PAGE_EXT_IDLE, &page_ext->flags);
96
+	page_ext_put(page_ext);
97
+
98
+	return page_idle;
86
99
 }
87
100
 
88
101
 static inline void set_page_idle(struct page *page)
89
102
 {
90
-	struct page_ext *page_ext = lookup_page_ext(page);
103
+	struct page_ext *page_ext = page_ext_get(page);
91
104
 
92
105
 	if (unlikely(!page_ext))
93
106
 		return;
94
107
 
95
108
 	set_bit(PAGE_EXT_IDLE, &page_ext->flags);
109
+	page_ext_put(page_ext);
96
110
 }
97
111
 
98
112
 static inline void clear_page_idle(struct page *page)
99
113
 {
100
-	struct page_ext *page_ext = lookup_page_ext(page);
114
+	struct page_ext *page_ext = page_ext_get(page);
101
115
 
102
116
 	if (unlikely(!page_ext))
103
117
 		return;
104
118
 
105
119
 	clear_bit(PAGE_EXT_IDLE, &page_ext->flags);
120
+	page_ext_put(page_ext);
106
121
 }
107
122
 #endif /* CONFIG_64BIT */
108
123
 
109
-#else /* !CONFIG_IDLE_PAGE_TRACKING */
124
+#else /* !CONFIG_PAGE_IDLE_FLAG */
110
125
 
111
126
 static inline bool page_is_young(struct page *page)
112
127
 {
..
..
@@ -135,6 +150,6 @@
135
150
 {
136
151
 }
137
152
 
138
-#endif /* CONFIG_IDLE_PAGE_TRACKING */
153
+#endif /* CONFIG_PAGE_IDLE_FLAG */
139
154
 
140
155
 #endif /* _LINUX_MM_PAGE_IDLE_H */