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