Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
6d80e53f AD |
2 | #include <linux/bootmem.h> |
3 | #include <linux/compiler.h> | |
4 | #include <linux/fs.h> | |
5 | #include <linux/init.h> | |
9a840895 | 6 | #include <linux/ksm.h> |
6d80e53f AD |
7 | #include <linux/mm.h> |
8 | #include <linux/mmzone.h> | |
56873f43 | 9 | #include <linux/huge_mm.h> |
6d80e53f AD |
10 | #include <linux/proc_fs.h> |
11 | #include <linux/seq_file.h> | |
20a0307c | 12 | #include <linux/hugetlb.h> |
80ae2fdc | 13 | #include <linux/memcontrol.h> |
33c3fc71 VD |
14 | #include <linux/mmu_notifier.h> |
15 | #include <linux/page_idle.h> | |
1a9b5b7f | 16 | #include <linux/kernel-page-flags.h> |
7c0f6ba6 | 17 | #include <linux/uaccess.h> |
6d80e53f AD |
18 | #include "internal.h" |
19 | ||
20 | #define KPMSIZE sizeof(u64) | |
21 | #define KPMMASK (KPMSIZE - 1) | |
33c3fc71 | 22 | #define KPMBITS (KPMSIZE * BITS_PER_BYTE) |
ed7ce0f1 | 23 | |
6d80e53f AD |
24 | /* /proc/kpagecount - an array exposing page counts |
25 | * | |
26 | * Each entry is a u64 representing the corresponding | |
27 | * physical page count. | |
28 | */ | |
29 | static ssize_t kpagecount_read(struct file *file, char __user *buf, | |
30 | size_t count, loff_t *ppos) | |
31 | { | |
32 | u64 __user *out = (u64 __user *)buf; | |
33 | struct page *ppage; | |
34 | unsigned long src = *ppos; | |
35 | unsigned long pfn; | |
36 | ssize_t ret = 0; | |
37 | u64 pcount; | |
38 | ||
39 | pfn = src / KPMSIZE; | |
40 | count = min_t(size_t, count, (max_pfn * KPMSIZE) - src); | |
41 | if (src & KPMMASK || count & KPMMASK) | |
42 | return -EINVAL; | |
43 | ||
44 | while (count > 0) { | |
6d80e53f AD |
45 | if (pfn_valid(pfn)) |
46 | ppage = pfn_to_page(pfn); | |
ed7ce0f1 WF |
47 | else |
48 | ppage = NULL; | |
a6fc86d2 | 49 | if (!ppage || PageSlab(ppage)) |
6d80e53f AD |
50 | pcount = 0; |
51 | else | |
52 | pcount = page_mapcount(ppage); | |
53 | ||
ed7ce0f1 | 54 | if (put_user(pcount, out)) { |
6d80e53f AD |
55 | ret = -EFAULT; |
56 | break; | |
57 | } | |
58 | ||
ed7ce0f1 WF |
59 | pfn++; |
60 | out++; | |
6d80e53f | 61 | count -= KPMSIZE; |
d3691d2c VD |
62 | |
63 | cond_resched(); | |
6d80e53f AD |
64 | } |
65 | ||
66 | *ppos += (char __user *)out - buf; | |
67 | if (!ret) | |
68 | ret = (char __user *)out - buf; | |
69 | return ret; | |
70 | } | |
71 | ||
72 | static const struct file_operations proc_kpagecount_operations = { | |
73 | .llseek = mem_lseek, | |
74 | .read = kpagecount_read, | |
75 | }; | |
76 | ||
77 | /* /proc/kpageflags - an array exposing page flags | |
78 | * | |
79 | * Each entry is a u64 representing the corresponding | |
80 | * physical page flags. | |
81 | */ | |
82 | ||
17797549 WF |
83 | static inline u64 kpf_copy_bit(u64 kflags, int ubit, int kbit) |
84 | { | |
85 | return ((kflags >> kbit) & 1) << ubit; | |
86 | } | |
87 | ||
1a9b5b7f | 88 | u64 stable_page_flags(struct page *page) |
17797549 WF |
89 | { |
90 | u64 k; | |
91 | u64 u; | |
92 | ||
93 | /* | |
94 | * pseudo flag: KPF_NOPAGE | |
95 | * it differentiates a memory hole from a page with no flags | |
96 | */ | |
97 | if (!page) | |
98 | return 1 << KPF_NOPAGE; | |
99 | ||
100 | k = page->flags; | |
101 | u = 0; | |
102 | ||
103 | /* | |
104 | * pseudo flags for the well known (anonymous) memory mapped pages | |
105 | * | |
106 | * Note that page->_mapcount is overloaded in SLOB/SLUB/SLQB, so the | |
832fc1de | 107 | * simple test in page_mapped() is not enough. |
17797549 | 108 | */ |
832fc1de | 109 | if (!PageSlab(page) && page_mapped(page)) |
17797549 WF |
110 | u |= 1 << KPF_MMAP; |
111 | if (PageAnon(page)) | |
112 | u |= 1 << KPF_ANON; | |
9a840895 HD |
113 | if (PageKsm(page)) |
114 | u |= 1 << KPF_KSM; | |
17797549 WF |
115 | |
116 | /* | |
117 | * compound pages: export both head/tail info | |
118 | * they together define a compound page's start/end pos and order | |
119 | */ | |
120 | if (PageHead(page)) | |
121 | u |= 1 << KPF_COMPOUND_HEAD; | |
122 | if (PageTail(page)) | |
123 | u |= 1 << KPF_COMPOUND_TAIL; | |
124 | if (PageHuge(page)) | |
125 | u |= 1 << KPF_HUGE; | |
7a71932d NH |
126 | /* |
127 | * PageTransCompound can be true for non-huge compound pages (slab | |
128 | * pages or pages allocated by drivers with __GFP_COMP) because it | |
e3bba3c3 NH |
129 | * just checks PG_head/PG_tail, so we need to check PageLRU/PageAnon |
130 | * to make sure a given page is a thp, not a non-huge compound page. | |
7a71932d | 131 | */ |
56873f43 WY |
132 | else if (PageTransCompound(page)) { |
133 | struct page *head = compound_head(page); | |
134 | ||
135 | if (PageLRU(head) || PageAnon(head)) | |
136 | u |= 1 << KPF_THP; | |
137 | else if (is_huge_zero_page(head)) { | |
138 | u |= 1 << KPF_ZERO_PAGE; | |
139 | u |= 1 << KPF_THP; | |
140 | } | |
141 | } else if (is_zero_pfn(page_to_pfn(page))) | |
142 | u |= 1 << KPF_ZERO_PAGE; | |
143 | ||
17797549 | 144 | |
17797549 | 145 | /* |
0139aa7b | 146 | * Caveats on high order pages: page->_refcount will only be set |
5f24ce5f AA |
147 | * -1 on the head page; SLUB/SLQB do the same for PG_slab; |
148 | * SLOB won't set PG_slab at all on compound pages. | |
17797549 | 149 | */ |
5f24ce5f AA |
150 | if (PageBuddy(page)) |
151 | u |= 1 << KPF_BUDDY; | |
832fc1de NH |
152 | else if (page_count(page) == 0 && is_free_buddy_page(page)) |
153 | u |= 1 << KPF_BUDDY; | |
5f24ce5f | 154 | |
09316c09 KK |
155 | if (PageBalloon(page)) |
156 | u |= 1 << KPF_BALLOON; | |
157 | ||
f074a8f4 VD |
158 | if (page_is_idle(page)) |
159 | u |= 1 << KPF_IDLE; | |
160 | ||
5f24ce5f AA |
161 | u |= kpf_copy_bit(k, KPF_LOCKED, PG_locked); |
162 | ||
17797549 | 163 | u |= kpf_copy_bit(k, KPF_SLAB, PG_slab); |
0a71649c NH |
164 | if (PageTail(page) && PageSlab(compound_head(page))) |
165 | u |= 1 << KPF_SLAB; | |
17797549 WF |
166 | |
167 | u |= kpf_copy_bit(k, KPF_ERROR, PG_error); | |
168 | u |= kpf_copy_bit(k, KPF_DIRTY, PG_dirty); | |
169 | u |= kpf_copy_bit(k, KPF_UPTODATE, PG_uptodate); | |
170 | u |= kpf_copy_bit(k, KPF_WRITEBACK, PG_writeback); | |
171 | ||
172 | u |= kpf_copy_bit(k, KPF_LRU, PG_lru); | |
173 | u |= kpf_copy_bit(k, KPF_REFERENCED, PG_referenced); | |
174 | u |= kpf_copy_bit(k, KPF_ACTIVE, PG_active); | |
175 | u |= kpf_copy_bit(k, KPF_RECLAIM, PG_reclaim); | |
176 | ||
b6789123 HD |
177 | if (PageSwapCache(page)) |
178 | u |= 1 << KPF_SWAPCACHE; | |
17797549 WF |
179 | u |= kpf_copy_bit(k, KPF_SWAPBACKED, PG_swapbacked); |
180 | ||
17797549 WF |
181 | u |= kpf_copy_bit(k, KPF_UNEVICTABLE, PG_unevictable); |
182 | u |= kpf_copy_bit(k, KPF_MLOCKED, PG_mlocked); | |
17797549 | 183 | |
253fb02d WF |
184 | #ifdef CONFIG_MEMORY_FAILURE |
185 | u |= kpf_copy_bit(k, KPF_HWPOISON, PG_hwpoison); | |
186 | #endif | |
187 | ||
ed430fec | 188 | #ifdef CONFIG_ARCH_USES_PG_UNCACHED |
17797549 WF |
189 | u |= kpf_copy_bit(k, KPF_UNCACHED, PG_uncached); |
190 | #endif | |
191 | ||
192 | u |= kpf_copy_bit(k, KPF_RESERVED, PG_reserved); | |
193 | u |= kpf_copy_bit(k, KPF_MAPPEDTODISK, PG_mappedtodisk); | |
194 | u |= kpf_copy_bit(k, KPF_PRIVATE, PG_private); | |
195 | u |= kpf_copy_bit(k, KPF_PRIVATE_2, PG_private_2); | |
196 | u |= kpf_copy_bit(k, KPF_OWNER_PRIVATE, PG_owner_priv_1); | |
197 | u |= kpf_copy_bit(k, KPF_ARCH, PG_arch_1); | |
198 | ||
199 | return u; | |
200 | }; | |
6d80e53f AD |
201 | |
202 | static ssize_t kpageflags_read(struct file *file, char __user *buf, | |
203 | size_t count, loff_t *ppos) | |
204 | { | |
205 | u64 __user *out = (u64 __user *)buf; | |
206 | struct page *ppage; | |
207 | unsigned long src = *ppos; | |
208 | unsigned long pfn; | |
209 | ssize_t ret = 0; | |
6d80e53f AD |
210 | |
211 | pfn = src / KPMSIZE; | |
212 | count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src); | |
213 | if (src & KPMMASK || count & KPMMASK) | |
214 | return -EINVAL; | |
215 | ||
216 | while (count > 0) { | |
6d80e53f AD |
217 | if (pfn_valid(pfn)) |
218 | ppage = pfn_to_page(pfn); | |
ed7ce0f1 WF |
219 | else |
220 | ppage = NULL; | |
17797549 | 221 | |
1a9b5b7f | 222 | if (put_user(stable_page_flags(ppage), out)) { |
6d80e53f AD |
223 | ret = -EFAULT; |
224 | break; | |
225 | } | |
226 | ||
ed7ce0f1 WF |
227 | pfn++; |
228 | out++; | |
6d80e53f | 229 | count -= KPMSIZE; |
d3691d2c VD |
230 | |
231 | cond_resched(); | |
6d80e53f AD |
232 | } |
233 | ||
234 | *ppos += (char __user *)out - buf; | |
235 | if (!ret) | |
236 | ret = (char __user *)out - buf; | |
237 | return ret; | |
238 | } | |
239 | ||
240 | static const struct file_operations proc_kpageflags_operations = { | |
241 | .llseek = mem_lseek, | |
242 | .read = kpageflags_read, | |
243 | }; | |
244 | ||
80ae2fdc VD |
245 | #ifdef CONFIG_MEMCG |
246 | static ssize_t kpagecgroup_read(struct file *file, char __user *buf, | |
247 | size_t count, loff_t *ppos) | |
248 | { | |
249 | u64 __user *out = (u64 __user *)buf; | |
250 | struct page *ppage; | |
251 | unsigned long src = *ppos; | |
252 | unsigned long pfn; | |
253 | ssize_t ret = 0; | |
254 | u64 ino; | |
255 | ||
256 | pfn = src / KPMSIZE; | |
257 | count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src); | |
258 | if (src & KPMMASK || count & KPMMASK) | |
259 | return -EINVAL; | |
260 | ||
261 | while (count > 0) { | |
262 | if (pfn_valid(pfn)) | |
263 | ppage = pfn_to_page(pfn); | |
264 | else | |
265 | ppage = NULL; | |
266 | ||
267 | if (ppage) | |
268 | ino = page_cgroup_ino(ppage); | |
269 | else | |
270 | ino = 0; | |
271 | ||
272 | if (put_user(ino, out)) { | |
273 | ret = -EFAULT; | |
274 | break; | |
275 | } | |
276 | ||
277 | pfn++; | |
278 | out++; | |
279 | count -= KPMSIZE; | |
d3691d2c VD |
280 | |
281 | cond_resched(); | |
80ae2fdc VD |
282 | } |
283 | ||
284 | *ppos += (char __user *)out - buf; | |
285 | if (!ret) | |
286 | ret = (char __user *)out - buf; | |
287 | return ret; | |
288 | } | |
289 | ||
290 | static const struct file_operations proc_kpagecgroup_operations = { | |
291 | .llseek = mem_lseek, | |
292 | .read = kpagecgroup_read, | |
293 | }; | |
294 | #endif /* CONFIG_MEMCG */ | |
295 | ||
6d80e53f AD |
296 | static int __init proc_page_init(void) |
297 | { | |
298 | proc_create("kpagecount", S_IRUSR, NULL, &proc_kpagecount_operations); | |
299 | proc_create("kpageflags", S_IRUSR, NULL, &proc_kpageflags_operations); | |
80ae2fdc VD |
300 | #ifdef CONFIG_MEMCG |
301 | proc_create("kpagecgroup", S_IRUSR, NULL, &proc_kpagecgroup_operations); | |
302 | #endif | |
6d80e53f AD |
303 | return 0; |
304 | } | |
abaf3787 | 305 | fs_initcall(proc_page_init); |