~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/proc/page.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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->_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         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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp