Branch data Line data Source code
1 : : #include <linux/bootmem.h>
2 : : #include <linux/compiler.h>
3 : : #include <linux/fs.h>
4 : : #include <linux/init.h>
5 : : #include <linux/ksm.h>
6 : : #include <linux/mm.h>
7 : : #include <linux/mmzone.h>
8 : : #include <linux/proc_fs.h>
9 : : #include <linux/seq_file.h>
10 : : #include <linux/hugetlb.h>
11 : : #include <linux/kernel-page-flags.h>
12 : : #include <asm/uaccess.h>
13 : : #include "internal.h"
14 : :
15 : : #define KPMSIZE sizeof(u64)
16 : : #define KPMMASK (KPMSIZE - 1)
17 : :
18 : : /* /proc/kpagecount - an array exposing page counts
19 : : *
20 : : * Each entry is a u64 representing the corresponding
21 : : * physical page count.
22 : : */
23 : 0 : static ssize_t kpagecount_read(struct file *file, char __user *buf,
24 : : size_t count, loff_t *ppos)
25 : : {
26 : : u64 __user *out = (u64 __user *)buf;
27 : : struct page *ppage;
28 : 8193 : unsigned long src = *ppos;
29 : : unsigned long pfn;
30 : : ssize_t ret = 0;
31 : : u64 pcount;
32 : :
33 : 8193 : pfn = src / KPMSIZE;
34 : 8193 : count = min_t(size_t, count, (max_pfn * KPMSIZE) - src);
35 [ + - ][ + ]: 8193 : if (src & KPMMASK || count & KPMMASK)
36 : : return -EINVAL;
37 : :
38 [ + + ]: 1056768 : while (count > 0) {
39 [ + + ]: 1048575 : if (pfn_valid(pfn))
40 : 520192 : ppage = pfn_to_page(pfn);
41 : : else
42 : : ppage = NULL;
43 [ + + ][ + + ]: 1048575 : if (!ppage || PageSlab(ppage))
44 : : pcount = 0;
45 : : else
46 : 512725 : pcount = page_mapcount(ppage);
47 : :
48 [ + - ]: 1048575 : if (put_user(pcount, out)) {
49 : : ret = -EFAULT;
50 : : break;
51 : : }
52 : :
53 : 1048575 : pfn++;
54 : 1048575 : out++;
55 : 1048575 : count -= KPMSIZE;
56 : : }
57 : :
58 : 8193 : *ppos += (char __user *)out - buf;
59 [ + - ]: 8193 : if (!ret)
60 : : ret = (char __user *)out - buf;
61 : 8193 : return ret;
62 : : }
63 : :
64 : : static const struct file_operations proc_kpagecount_operations = {
65 : : .llseek = mem_lseek,
66 : : .read = kpagecount_read,
67 : : };
68 : :
69 : : /* /proc/kpageflags - an array exposing page flags
70 : : *
71 : : * Each entry is a u64 representing the corresponding
72 : : * physical page flags.
73 : : */
74 : :
75 : : static inline u64 kpf_copy_bit(u64 kflags, int ubit, int kbit)
76 : : {
77 : 10403840 : return ((kflags >> kbit) & 1) << ubit;
78 : : }
79 : :
80 : 0 : u64 stable_page_flags(struct page *page)
81 : : {
82 : : u64 k;
83 : : u64 u;
84 : :
85 : : /*
86 : : * pseudo flag: KPF_NOPAGE
87 : : * it differentiates a memory hole from a page with no flags
88 : : */
89 [ + ]: 1048575 : if (!page)
90 : : return 1 << KPF_NOPAGE;
91 : :
92 : 1568767 : k = page->flags;
93 : : u = 0;
94 : :
95 : : /*
96 : : * pseudo flags for the well known (anonymous) memory mapped pages
97 : : *
98 : : * Note that page->_mapcount is overloaded in SLOB/SLUB/SLQB, so the
99 : : * simple test in page_mapped() is not enough.
100 : : */
101 [ + + ][ + + ]: 1568767 : if (!PageSlab(page) && page_mapped(page))
102 : : u |= 1 << KPF_MMAP;
103 [ + + ]: 1568767 : if (PageAnon(page))
104 : 2296 : u |= 1 << KPF_ANON;
105 : : if (PageKsm(page))
106 : : u |= 1 << KPF_KSM;
107 : :
108 : : /*
109 : : * compound pages: export both head/tail info
110 : : * they together define a compound page's start/end pos and order
111 : : */
112 [ + + ]: 1568767 : if (PageHead(page))
113 : 102 : u |= 1 << KPF_COMPOUND_HEAD;
114 [ + + ]: 520192 : if (PageTail(page))
115 : 256 : u |= 1 << KPF_COMPOUND_TAIL;
116 : : if (PageHuge(page))
117 : : u |= 1 << KPF_HUGE;
118 : : /*
119 : : * PageTransCompound can be true for non-huge compound pages (slab
120 : : * pages or pages allocated by drivers with __GFP_COMP) because it
121 : : * just checks PG_head/PG_tail, so we need to check PageLRU to make
122 : : * sure a given page is a thp, not a non-huge compound page.
123 : : */
124 : : else if (PageTransCompound(page) && PageLRU(compound_trans_head(page)))
125 : : u |= 1 << KPF_THP;
126 : :
127 : : /*
128 : : * Caveats on high order pages: page->_count will only be set
129 : : * -1 on the head page; SLUB/SLQB do the same for PG_slab;
130 : : * SLOB won't set PG_slab at all on compound pages.
131 : : */
132 [ + + ]: 520192 : if (PageBuddy(page))
133 : 2531 : u |= 1 << KPF_BUDDY;
134 : :
135 : 520192 : u |= kpf_copy_bit(k, KPF_LOCKED, PG_locked);
136 : :
137 : 520192 : u |= kpf_copy_bit(k, KPF_SLAB, PG_slab);
138 : :
139 : 520192 : u |= kpf_copy_bit(k, KPF_ERROR, PG_error);
140 : 520192 : u |= kpf_copy_bit(k, KPF_DIRTY, PG_dirty);
141 : 520192 : u |= kpf_copy_bit(k, KPF_UPTODATE, PG_uptodate);
142 : 520192 : u |= kpf_copy_bit(k, KPF_WRITEBACK, PG_writeback);
143 : :
144 : 520192 : u |= kpf_copy_bit(k, KPF_LRU, PG_lru);
145 : 520192 : u |= kpf_copy_bit(k, KPF_REFERENCED, PG_referenced);
146 : 520192 : u |= kpf_copy_bit(k, KPF_ACTIVE, PG_active);
147 : 520192 : u |= kpf_copy_bit(k, KPF_RECLAIM, PG_reclaim);
148 : :
149 : 520192 : u |= kpf_copy_bit(k, KPF_SWAPCACHE, PG_swapcache);
150 : 520192 : u |= kpf_copy_bit(k, KPF_SWAPBACKED, PG_swapbacked);
151 : :
152 : 520192 : u |= kpf_copy_bit(k, KPF_UNEVICTABLE, PG_unevictable);
153 : 520192 : u |= kpf_copy_bit(k, KPF_MLOCKED, PG_mlocked);
154 : :
155 : : #ifdef CONFIG_MEMORY_FAILURE
156 : : u |= kpf_copy_bit(k, KPF_HWPOISON, PG_hwpoison);
157 : : #endif
158 : :
159 : : #ifdef CONFIG_ARCH_USES_PG_UNCACHED
160 : : u |= kpf_copy_bit(k, KPF_UNCACHED, PG_uncached);
161 : : #endif
162 : :
163 : 520192 : u |= kpf_copy_bit(k, KPF_RESERVED, PG_reserved);
164 : 520192 : u |= kpf_copy_bit(k, KPF_MAPPEDTODISK, PG_mappedtodisk);
165 : 520192 : u |= kpf_copy_bit(k, KPF_PRIVATE, PG_private);
166 : 520192 : u |= kpf_copy_bit(k, KPF_PRIVATE_2, PG_private_2);
167 : 520192 : u |= kpf_copy_bit(k, KPF_OWNER_PRIVATE, PG_owner_priv_1);
168 : 520192 : u |= kpf_copy_bit(k, KPF_ARCH, PG_arch_1);
169 : :
170 : 520192 : return u;
171 : : };
172 : :
173 : 0 : static ssize_t kpageflags_read(struct file *file, char __user *buf,
174 : : size_t count, loff_t *ppos)
175 : : {
176 : : u64 __user *out = (u64 __user *)buf;
177 : : struct page *ppage;
178 : 8193 : unsigned long src = *ppos;
179 : : unsigned long pfn;
180 : : ssize_t ret = 0;
181 : :
182 : 8193 : pfn = src / KPMSIZE;
183 : 8193 : count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src);
184 [ + - ][ + ]: 8193 : if (src & KPMMASK || count & KPMMASK)
185 : : return -EINVAL;
186 : :
187 [ + + ]: 1056768 : while (count > 0) {
188 [ + + ]: 1048575 : if (pfn_valid(pfn))
189 : 520192 : ppage = pfn_to_page(pfn);
190 : : else
191 : : ppage = NULL;
192 : :
193 [ + - ]: 1048575 : if (put_user(stable_page_flags(ppage), out)) {
194 : : ret = -EFAULT;
195 : : break;
196 : : }
197 : :
198 : 1048575 : pfn++;
199 : 1048575 : out++;
200 : 1048575 : count -= KPMSIZE;
201 : : }
202 : :
203 : 8193 : *ppos += (char __user *)out - buf;
204 [ + - ]: 8193 : if (!ret)
205 : : ret = (char __user *)out - buf;
206 : 8193 : return ret;
207 : : }
208 : :
209 : : static const struct file_operations proc_kpageflags_operations = {
210 : : .llseek = mem_lseek,
211 : : .read = kpageflags_read,
212 : : };
213 : :
214 : 0 : static int __init proc_page_init(void)
215 : : {
216 : : proc_create("kpagecount", S_IRUSR, NULL, &proc_kpagecount_operations);
217 : : proc_create("kpageflags", S_IRUSR, NULL, &proc_kpageflags_operations);
218 : 0 : return 0;
219 : : }
220 : : module_init(proc_page_init);
|
