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 <linux/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->_refcount 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 if (PageSwapCache(page)) 177 u |= 1 << KPF_SWAPCACHE; 178 u |= kpf_copy_bit(k, KPF_SWAPBACKED, PG_swapbacked); 179 180 u |= kpf_copy_bit(k, KPF_UNEVICTABLE, PG_unevictable); 181 u |= kpf_copy_bit(k, KPF_MLOCKED, PG_mlocked); 182 183 #ifdef CONFIG_MEMORY_FAILURE 184 u |= kpf_copy_bit(k, KPF_HWPOISON, PG_hwpoison); 185 #endif 186 187 #ifdef CONFIG_ARCH_USES_PG_UNCACHED 188 u |= kpf_copy_bit(k, KPF_UNCACHED, PG_uncached); 189 #endif 190 191 u |= kpf_copy_bit(k, KPF_RESERVED, PG_reserved); 192 u |= kpf_copy_bit(k, KPF_MAPPEDTODISK, PG_mappedtodisk); 193 u |= kpf_copy_bit(k, KPF_PRIVATE, PG_private); 194 u |= kpf_copy_bit(k, KPF_PRIVATE_2, PG_private_2); 195 u |= kpf_copy_bit(k, KPF_OWNER_PRIVATE, PG_owner_priv_1); 196 u |= kpf_copy_bit(k, KPF_ARCH, PG_arch_1); 197 198 return u; 199 }; 200 201 static ssize_t kpageflags_read(struct file *file, char __user *buf, 202 size_t count, loff_t *ppos) 203 { 204 u64 __user *out = (u64 __user *)buf; 205 struct page *ppage; 206 unsigned long src = *ppos; 207 unsigned long pfn; 208 ssize_t ret = 0; 209 210 pfn = src / KPMSIZE; 211 count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src); 212 if (src & KPMMASK || count & KPMMASK) 213 return -EINVAL; 214 215 while (count > 0) { 216 if (pfn_valid(pfn)) 217 ppage = pfn_to_page(pfn); 218 else 219 ppage = NULL; 220 221 if (put_user(stable_page_flags(ppage), out)) { 222 ret = -EFAULT; 223 break; 224 } 225 226 pfn++; 227 out++; 228 count -= KPMSIZE; 229 230 cond_resched(); 231 } 232 233 *ppos += (char __user *)out - buf; 234 if (!ret) 235 ret = (char __user *)out - buf; 236 return ret; 237 } 238 239 static const struct file_operations proc_kpageflags_operations = { 240 .llseek = mem_lseek, 241 .read = kpageflags_read, 242 }; 243 244 #ifdef CONFIG_MEMCG 245 static ssize_t kpagecgroup_read(struct file *file, char __user *buf, 246 size_t count, loff_t *ppos) 247 { 248 u64 __user *out = (u64 __user *)buf; 249 struct page *ppage; 250 unsigned long src = *ppos; 251 unsigned long pfn; 252 ssize_t ret = 0; 253 u64 ino; 254 255 pfn = src / KPMSIZE; 256 count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src); 257 if (src & KPMMASK || count & KPMMASK) 258 return -EINVAL; 259 260 while (count > 0) { 261 if (pfn_valid(pfn)) 262 ppage = pfn_to_page(pfn); 263 else 264 ppage = NULL; 265 266 if (ppage) 267 ino = page_cgroup_ino(ppage); 268 else 269 ino = 0; 270 271 if (put_user(ino, out)) { 272 ret = -EFAULT; 273 break; 274 } 275 276 pfn++; 277 out++; 278 count -= KPMSIZE; 279 280 cond_resched(); 281 } 282 283 *ppos += (char __user *)out - buf; 284 if (!ret) 285 ret = (char __user *)out - buf; 286 return ret; 287 } 288 289 static const struct file_operations proc_kpagecgroup_operations = { 290 .llseek = mem_lseek, 291 .read = kpagecgroup_read, 292 }; 293 #endif /* CONFIG_MEMCG */ 294 295 static int __init proc_page_init(void) 296 { 297 proc_create("kpagecount", S_IRUSR, NULL, &proc_kpagecount_operations); 298 proc_create("kpageflags", S_IRUSR, NULL, &proc_kpageflags_operations); 299 #ifdef CONFIG_MEMCG 300 proc_create("kpagecgroup", S_IRUSR, NULL, &proc_kpagecgroup_operations); 301 #endif 302 return 0; 303 } 304 fs_initcall(proc_page_init); 305