source: src/linux/universal/linux-4.4/fs/proc/task_mmu.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 3 months ago

update

File size: 39.1 KB
Line 
1#include <linux/mm.h>
2#include <linux/vmacache.h>
3#include <linux/hugetlb.h>
4#include <linux/huge_mm.h>
5#include <linux/mount.h>
6#include <linux/seq_file.h>
7#include <linux/highmem.h>
8#include <linux/ptrace.h>
9#include <linux/slab.h>
10#include <linux/pagemap.h>
11#include <linux/mempolicy.h>
12#include <linux/rmap.h>
13#include <linux/swap.h>
14#include <linux/swapops.h>
15#include <linux/mmu_notifier.h>
16#include <linux/page_idle.h>
17
18#include <asm/elf.h>
19#include <asm/uaccess.h>
20#include <asm/tlbflush.h>
21#include "internal.h"
22
23void task_mem(struct seq_file *m, struct mm_struct *mm)
24{
25        unsigned long data, text, lib, swap, ptes, pmds;
26        unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss;
27
28        /*
29         * Note: to minimize their overhead, mm maintains hiwater_vm and
30         * hiwater_rss only when about to *lower* total_vm or rss.  Any
31         * collector of these hiwater stats must therefore get total_vm
32         * and rss too, which will usually be the higher.  Barriers? not
33         * worth the effort, such snapshots can always be inconsistent.
34         */
35        hiwater_vm = total_vm = mm->total_vm;
36        if (hiwater_vm < mm->hiwater_vm)
37                hiwater_vm = mm->hiwater_vm;
38        hiwater_rss = total_rss = get_mm_rss(mm);
39        if (hiwater_rss < mm->hiwater_rss)
40                hiwater_rss = mm->hiwater_rss;
41
42        data = mm->total_vm - mm->shared_vm - mm->stack_vm;
43        text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10;
44        lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
45        swap = get_mm_counter(mm, MM_SWAPENTS);
46        ptes = PTRS_PER_PTE * sizeof(pte_t) * atomic_long_read(&mm->nr_ptes);
47        pmds = PTRS_PER_PMD * sizeof(pmd_t) * mm_nr_pmds(mm);
48        seq_printf(m,
49                "VmPeak:\t%8lu kB\n"
50                "VmSize:\t%8lu kB\n"
51                "VmLck:\t%8lu kB\n"
52                "VmPin:\t%8lu kB\n"
53                "VmHWM:\t%8lu kB\n"
54                "VmRSS:\t%8lu kB\n"
55                "VmData:\t%8lu kB\n"
56                "VmStk:\t%8lu kB\n"
57                "VmExe:\t%8lu kB\n"
58                "VmLib:\t%8lu kB\n"
59                "VmPTE:\t%8lu kB\n"
60                "VmPMD:\t%8lu kB\n"
61                "VmSwap:\t%8lu kB\n",
62                hiwater_vm << (PAGE_SHIFT-10),
63                total_vm << (PAGE_SHIFT-10),
64                mm->locked_vm << (PAGE_SHIFT-10),
65                mm->pinned_vm << (PAGE_SHIFT-10),
66                hiwater_rss << (PAGE_SHIFT-10),
67                total_rss << (PAGE_SHIFT-10),
68                data << (PAGE_SHIFT-10),
69                mm->stack_vm << (PAGE_SHIFT-10), text, lib,
70                ptes >> 10,
71                pmds >> 10,
72                swap << (PAGE_SHIFT-10));
73        hugetlb_report_usage(m, mm);
74}
75
76unsigned long task_vsize(struct mm_struct *mm)
77{
78        return PAGE_SIZE * mm->total_vm;
79}
80
81unsigned long task_statm(struct mm_struct *mm,
82                         unsigned long *shared, unsigned long *text,
83                         unsigned long *data, unsigned long *resident)
84{
85        *shared = get_mm_counter(mm, MM_FILEPAGES);
86        *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
87                                                                >> PAGE_SHIFT;
88        *data = mm->total_vm - mm->shared_vm;
89        *resident = *shared + get_mm_counter(mm, MM_ANONPAGES);
90        return mm->total_vm;
91}
92
93#ifdef CONFIG_NUMA
94/*
95 * Save get_task_policy() for show_numa_map().
96 */
97static void hold_task_mempolicy(struct proc_maps_private *priv)
98{
99        struct task_struct *task = priv->task;
100
101        task_lock(task);
102        priv->task_mempolicy = get_task_policy(task);
103        mpol_get(priv->task_mempolicy);
104        task_unlock(task);
105}
106static void release_task_mempolicy(struct proc_maps_private *priv)
107{
108        mpol_put(priv->task_mempolicy);
109}
110#else
111static void hold_task_mempolicy(struct proc_maps_private *priv)
112{
113}
114static void release_task_mempolicy(struct proc_maps_private *priv)
115{
116}
117#endif
118
119static void vma_stop(struct proc_maps_private *priv)
120{
121        struct mm_struct *mm = priv->mm;
122
123        release_task_mempolicy(priv);
124        up_read(&mm->mmap_sem);
125        mmput(mm);
126}
127
128static struct vm_area_struct *
129m_next_vma(struct proc_maps_private *priv, struct vm_area_struct *vma)
130{
131        if (vma == priv->tail_vma)
132                return NULL;
133        return vma->vm_next ?: priv->tail_vma;
134}
135
136static void m_cache_vma(struct seq_file *m, struct vm_area_struct *vma)
137{
138        if (m->count < m->size) /* vma is copied successfully */
139                m->version = m_next_vma(m->private, vma) ? vma->vm_start : -1UL;
140}
141
142static void *m_start(struct seq_file *m, loff_t *ppos)
143{
144        struct proc_maps_private *priv = m->private;
145        unsigned long last_addr = m->version;
146        struct mm_struct *mm;
147        struct vm_area_struct *vma;
148        unsigned int pos = *ppos;
149
150        /* See m_cache_vma(). Zero at the start or after lseek. */
151        if (last_addr == -1UL)
152                return NULL;
153
154        priv->task = get_proc_task(priv->inode);
155        if (!priv->task)
156                return ERR_PTR(-ESRCH);
157
158        mm = priv->mm;
159        if (!mm || !atomic_inc_not_zero(&mm->mm_users))
160                return NULL;
161
162        down_read(&mm->mmap_sem);
163        hold_task_mempolicy(priv);
164        priv->tail_vma = get_gate_vma(mm);
165
166        if (last_addr) {
167                vma = find_vma(mm, last_addr);
168                if (vma && (vma = m_next_vma(priv, vma)))
169                        return vma;
170        }
171
172        m->version = 0;
173        if (pos < mm->map_count) {
174                for (vma = mm->mmap; pos; pos--) {
175                        m->version = vma->vm_start;
176                        vma = vma->vm_next;
177                }
178                return vma;
179        }
180
181        /* we do not bother to update m->version in this case */
182        if (pos == mm->map_count && priv->tail_vma)
183                return priv->tail_vma;
184
185        vma_stop(priv);
186        return NULL;
187}
188
189static void *m_next(struct seq_file *m, void *v, loff_t *pos)
190{
191        struct proc_maps_private *priv = m->private;
192        struct vm_area_struct *next;
193
194        (*pos)++;
195        next = m_next_vma(priv, v);
196        if (!next)
197                vma_stop(priv);
198        return next;
199}
200
201static void m_stop(struct seq_file *m, void *v)
202{
203        struct proc_maps_private *priv = m->private;
204
205        if (!IS_ERR_OR_NULL(v))
206                vma_stop(priv);
207        if (priv->task) {
208                put_task_struct(priv->task);
209                priv->task = NULL;
210        }
211}
212
213static int proc_maps_open(struct inode *inode, struct file *file,
214                        const struct seq_operations *ops, int psize)
215{
216        struct proc_maps_private *priv = __seq_open_private(file, ops, psize);
217
218        if (!priv)
219                return -ENOMEM;
220
221        priv->inode = inode;
222        priv->mm = proc_mem_open(inode, PTRACE_MODE_READ);
223        if (IS_ERR(priv->mm)) {
224                int err = PTR_ERR(priv->mm);
225
226                seq_release_private(inode, file);
227                return err;
228        }
229
230        return 0;
231}
232
233static int proc_map_release(struct inode *inode, struct file *file)
234{
235        struct seq_file *seq = file->private_data;
236        struct proc_maps_private *priv = seq->private;
237
238        if (priv->mm)
239                mmdrop(priv->mm);
240
241        return seq_release_private(inode, file);
242}
243
244static int do_maps_open(struct inode *inode, struct file *file,
245                        const struct seq_operations *ops)
246{
247        return proc_maps_open(inode, file, ops,
248                                sizeof(struct proc_maps_private));
249}
250
251/*
252 * Indicate if the VMA is a stack for the given task; for
253 * /proc/PID/maps that is the stack of the main task.
254 */
255static int is_stack(struct proc_maps_private *priv,
256                    struct vm_area_struct *vma, int is_pid)
257{
258        int stack = 0;
259
260        if (is_pid) {
261                stack = vma->vm_start <= vma->vm_mm->start_stack &&
262                        vma->vm_end >= vma->vm_mm->start_stack;
263        } else {
264                struct inode *inode = priv->inode;
265                struct task_struct *task;
266
267                rcu_read_lock();
268                task = pid_task(proc_pid(inode), PIDTYPE_PID);
269                if (task)
270                        stack = vma_is_stack_for_task(vma, task);
271                rcu_read_unlock();
272        }
273        return stack;
274}
275
276static void
277show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
278{
279        struct mm_struct *mm = vma->vm_mm;
280        struct file *file = vma->vm_file;
281        struct proc_maps_private *priv = m->private;
282        vm_flags_t flags = vma->vm_flags;
283        unsigned long ino = 0;
284        unsigned long long pgoff = 0;
285        unsigned long start, end;
286        dev_t dev = 0;
287        const char *name = NULL;
288
289        if (file) {
290                struct inode *inode = file_inode(vma->vm_file);
291                dev = inode->i_sb->s_dev;
292                ino = inode->i_ino;
293                pgoff = ((loff_t)vma->vm_pgoff) << PAGE_SHIFT;
294        }
295
296        /* We don't show the stack guard page in /proc/maps */
297        start = vma->vm_start;
298        if (stack_guard_page_start(vma, start))
299                start += PAGE_SIZE;
300        end = vma->vm_end;
301        if (stack_guard_page_end(vma, end))
302                end -= PAGE_SIZE;
303
304        seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
305        seq_printf(m, "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
306                        start,
307                        end,
308                        flags & VM_READ ? 'r' : '-',
309                        flags & VM_WRITE ? 'w' : '-',
310                        flags & VM_EXEC ? 'x' : '-',
311                        flags & VM_MAYSHARE ? 's' : 'p',
312                        pgoff,
313                        MAJOR(dev), MINOR(dev), ino);
314
315        /*
316         * Print the dentry name for named mappings, and a
317         * special [heap] marker for the heap:
318         */
319        if (file) {
320                seq_pad(m, ' ');
321                seq_file_path(m, file, "\n");
322                goto done;
323        }
324
325        if (vma->vm_ops && vma->vm_ops->name) {
326                name = vma->vm_ops->name(vma);
327                if (name)
328                        goto done;
329        }
330
331        name = arch_vma_name(vma);
332        if (!name) {
333                if (!mm) {
334                        name = "[vdso]";
335                        goto done;
336                }
337
338                if (vma->vm_start <= mm->brk &&
339                    vma->vm_end >= mm->start_brk) {
340                        name = "[heap]";
341                        goto done;
342                }
343
344                if (is_stack(priv, vma, is_pid))
345                        name = "[stack]";
346        }
347
348done:
349        if (name) {
350                seq_pad(m, ' ');
351                seq_puts(m, name);
352        }
353        seq_putc(m, '\n');
354}
355
356static int show_map(struct seq_file *m, void *v, int is_pid)
357{
358        show_map_vma(m, v, is_pid);
359        m_cache_vma(m, v);
360        return 0;
361}
362
363static int show_pid_map(struct seq_file *m, void *v)
364{
365        return show_map(m, v, 1);
366}
367
368static int show_tid_map(struct seq_file *m, void *v)
369{
370        return show_map(m, v, 0);
371}
372
373static const struct seq_operations proc_pid_maps_op = {
374        .start  = m_start,
375        .next   = m_next,
376        .stop   = m_stop,
377        .show   = show_pid_map
378};
379
380static const struct seq_operations proc_tid_maps_op = {
381        .start  = m_start,
382        .next   = m_next,
383        .stop   = m_stop,
384        .show   = show_tid_map
385};
386
387static int pid_maps_open(struct inode *inode, struct file *file)
388{
389        return do_maps_open(inode, file, &proc_pid_maps_op);
390}
391
392static int tid_maps_open(struct inode *inode, struct file *file)
393{
394        return do_maps_open(inode, file, &proc_tid_maps_op);
395}
396
397const struct file_operations proc_pid_maps_operations = {
398        .open           = pid_maps_open,
399        .read           = seq_read,
400        .llseek         = seq_lseek,
401        .release        = proc_map_release,
402};
403
404const struct file_operations proc_tid_maps_operations = {
405        .open           = tid_maps_open,
406        .read           = seq_read,
407        .llseek         = seq_lseek,
408        .release        = proc_map_release,
409};
410
411/*
412 * Proportional Set Size(PSS): my share of RSS.
413 *
414 * PSS of a process is the count of pages it has in memory, where each
415 * page is divided by the number of processes sharing it.  So if a
416 * process has 1000 pages all to itself, and 1000 shared with one other
417 * process, its PSS will be 1500.
418 *
419 * To keep (accumulated) division errors low, we adopt a 64bit
420 * fixed-point pss counter to minimize division errors. So (pss >>
421 * PSS_SHIFT) would be the real byte count.
422 *
423 * A shift of 12 before division means (assuming 4K page size):
424 *      - 1M 3-user-pages add up to 8KB errors;
425 *      - supports mapcount up to 2^24, or 16M;
426 *      - supports PSS up to 2^52 bytes, or 4PB.
427 */
428#define PSS_SHIFT 12
429
430#ifdef CONFIG_PROC_PAGE_MONITOR
431struct mem_size_stats {
432        unsigned long resident;
433        unsigned long shared_clean;
434        unsigned long shared_dirty;
435        unsigned long private_clean;
436        unsigned long private_dirty;
437        unsigned long referenced;
438        unsigned long anonymous;
439        unsigned long anonymous_thp;
440        unsigned long swap;
441        unsigned long shared_hugetlb;
442        unsigned long private_hugetlb;
443        u64 pss;
444        u64 swap_pss;
445};
446
447static void smaps_account(struct mem_size_stats *mss, struct page *page,
448                unsigned long size, bool young, bool dirty)
449{
450        int mapcount;
451
452        if (PageAnon(page))
453                mss->anonymous += size;
454
455        mss->resident += size;
456        /* Accumulate the size in pages that have been accessed. */
457        if (young || page_is_young(page) || PageReferenced(page))
458                mss->referenced += size;
459        mapcount = page_mapcount(page);
460        if (mapcount >= 2) {
461                u64 pss_delta;
462
463                if (dirty || PageDirty(page))
464                        mss->shared_dirty += size;
465                else
466                        mss->shared_clean += size;
467                pss_delta = (u64)size << PSS_SHIFT;
468                do_div(pss_delta, mapcount);
469                mss->pss += pss_delta;
470        } else {
471                if (dirty || PageDirty(page))
472                        mss->private_dirty += size;
473                else
474                        mss->private_clean += size;
475                mss->pss += (u64)size << PSS_SHIFT;
476        }
477}
478
479static void smaps_pte_entry(pte_t *pte, unsigned long addr,
480                struct mm_walk *walk)
481{
482        struct mem_size_stats *mss = walk->private;
483        struct vm_area_struct *vma = walk->vma;
484        struct page *page = NULL;
485
486        if (pte_present(*pte)) {
487                page = vm_normal_page(vma, addr, *pte);
488        } else if (is_swap_pte(*pte)) {
489                swp_entry_t swpent = pte_to_swp_entry(*pte);
490
491                if (!non_swap_entry(swpent)) {
492                        int mapcount;
493
494                        mss->swap += PAGE_SIZE;
495                        mapcount = swp_swapcount(swpent);
496                        if (mapcount >= 2) {
497                                u64 pss_delta = (u64)PAGE_SIZE << PSS_SHIFT;
498
499                                do_div(pss_delta, mapcount);
500                                mss->swap_pss += pss_delta;
501                        } else {
502                                mss->swap_pss += (u64)PAGE_SIZE << PSS_SHIFT;
503                        }
504                } else if (is_migration_entry(swpent))
505                        page = migration_entry_to_page(swpent);
506        }
507
508        if (!page)
509                return;
510        smaps_account(mss, page, PAGE_SIZE, pte_young(*pte), pte_dirty(*pte));
511}
512
513#ifdef CONFIG_TRANSPARENT_HUGEPAGE
514static void smaps_pmd_entry(pmd_t *pmd, unsigned long addr,
515                struct mm_walk *walk)
516{
517        struct mem_size_stats *mss = walk->private;
518        struct vm_area_struct *vma = walk->vma;
519        struct page *page;
520
521        /* FOLL_DUMP will return -EFAULT on huge zero page */
522        page = follow_trans_huge_pmd(vma, addr, pmd, FOLL_DUMP);
523        if (IS_ERR_OR_NULL(page))
524                return;
525        mss->anonymous_thp += HPAGE_PMD_SIZE;
526        smaps_account(mss, page, HPAGE_PMD_SIZE,
527                        pmd_young(*pmd), pmd_dirty(*pmd));
528}
529#else
530static void smaps_pmd_entry(pmd_t *pmd, unsigned long addr,
531                struct mm_walk *walk)
532{
533}
534#endif
535
536static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
537                           struct mm_walk *walk)
538{
539        struct vm_area_struct *vma = walk->vma;
540        pte_t *pte;
541        spinlock_t *ptl;
542
543        if (pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
544                smaps_pmd_entry(pmd, addr, walk);
545                spin_unlock(ptl);
546                return 0;
547        }
548
549        if (pmd_trans_unstable(pmd))
550                return 0;
551        /*
552         * The mmap_sem held all the way back in m_start() is what
553         * keeps khugepaged out of here and from collapsing things
554         * in here.
555         */
556        pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
557        for (; addr != end; pte++, addr += PAGE_SIZE)
558                smaps_pte_entry(pte, addr, walk);
559        pte_unmap_unlock(pte - 1, ptl);
560        cond_resched();
561        return 0;
562}
563
564static void show_smap_vma_flags(struct seq_file *m, struct vm_area_struct *vma)
565{
566        /*
567         * Don't forget to update Documentation/ on changes.
568         */
569        static const char mnemonics[BITS_PER_LONG][2] = {
570                /*
571                 * In case if we meet a flag we don't know about.
572                 */
573                [0 ... (BITS_PER_LONG-1)] = "??",
574
575                [ilog2(VM_READ)]        = "rd",
576                [ilog2(VM_WRITE)]       = "wr",
577                [ilog2(VM_EXEC)]        = "ex",
578                [ilog2(VM_SHARED)]      = "sh",
579                [ilog2(VM_MAYREAD)]     = "mr",
580                [ilog2(VM_MAYWRITE)]    = "mw",
581                [ilog2(VM_MAYEXEC)]     = "me",
582                [ilog2(VM_MAYSHARE)]    = "ms",
583                [ilog2(VM_GROWSDOWN)]   = "gd",
584                [ilog2(VM_PFNMAP)]      = "pf",
585                [ilog2(VM_DENYWRITE)]   = "dw",
586#ifdef CONFIG_X86_INTEL_MPX
587                [ilog2(VM_MPX)]         = "mp",
588#endif
589                [ilog2(VM_LOCKED)]      = "lo",
590                [ilog2(VM_IO)]          = "io",
591                [ilog2(VM_SEQ_READ)]    = "sr",
592                [ilog2(VM_RAND_READ)]   = "rr",
593                [ilog2(VM_DONTCOPY)]    = "dc",
594                [ilog2(VM_DONTEXPAND)]  = "de",
595                [ilog2(VM_ACCOUNT)]     = "ac",
596                [ilog2(VM_NORESERVE)]   = "nr",
597                [ilog2(VM_HUGETLB)]     = "ht",
598                [ilog2(VM_ARCH_1)]      = "ar",
599                [ilog2(VM_DONTDUMP)]    = "dd",
600#ifdef CONFIG_MEM_SOFT_DIRTY
601                [ilog2(VM_SOFTDIRTY)]   = "sd",
602#endif
603                [ilog2(VM_MIXEDMAP)]    = "mm",
604                [ilog2(VM_HUGEPAGE)]    = "hg",
605                [ilog2(VM_NOHUGEPAGE)]  = "nh",
606                [ilog2(VM_MERGEABLE)]   = "mg",
607                [ilog2(VM_UFFD_MISSING)]= "um",
608                [ilog2(VM_UFFD_WP)]     = "uw",
609        };
610        size_t i;
611
612        seq_puts(m, "VmFlags: ");
613        for (i = 0; i < BITS_PER_LONG; i++) {
614                if (vma->vm_flags & (1UL << i)) {
615                        seq_printf(m, "%c%c ",
616                                   mnemonics[i][0], mnemonics[i][1]);
617                }
618        }
619        seq_putc(m, '\n');
620}
621
622#ifdef CONFIG_HUGETLB_PAGE
623static int smaps_hugetlb_range(pte_t *pte, unsigned long hmask,
624                                 unsigned long addr, unsigned long end,
625                                 struct mm_walk *walk)
626{
627        struct mem_size_stats *mss = walk->private;
628        struct vm_area_struct *vma = walk->vma;
629        struct page *page = NULL;
630
631        if (pte_present(*pte)) {
632                page = vm_normal_page(vma, addr, *pte);
633        } else if (is_swap_pte(*pte)) {
634                swp_entry_t swpent = pte_to_swp_entry(*pte);
635
636                if (is_migration_entry(swpent))
637                        page = migration_entry_to_page(swpent);
638        }
639        if (page) {
640                int mapcount = page_mapcount(page);
641
642                if (mapcount >= 2)
643                        mss->shared_hugetlb += huge_page_size(hstate_vma(vma));
644                else
645                        mss->private_hugetlb += huge_page_size(hstate_vma(vma));
646        }
647        return 0;
648}
649#endif /* HUGETLB_PAGE */
650
651static int show_smap(struct seq_file *m, void *v, int is_pid)
652{
653        struct vm_area_struct *vma = v;
654        struct mem_size_stats mss;
655        struct mm_walk smaps_walk = {
656                .pmd_entry = smaps_pte_range,
657#ifdef CONFIG_HUGETLB_PAGE
658                .hugetlb_entry = smaps_hugetlb_range,
659#endif
660                .mm = vma->vm_mm,
661                .private = &mss,
662        };
663
664        memset(&mss, 0, sizeof mss);
665        /* mmap_sem is held in m_start */
666        walk_page_vma(vma, &smaps_walk);
667
668        show_map_vma(m, vma, is_pid);
669
670        seq_printf(m,
671                   "Size:           %8lu kB\n"
672                   "Rss:            %8lu kB\n"
673                   "Pss:            %8lu kB\n"
674                   "Shared_Clean:   %8lu kB\n"
675                   "Shared_Dirty:   %8lu kB\n"
676                   "Private_Clean:  %8lu kB\n"
677                   "Private_Dirty:  %8lu kB\n"
678                   "Referenced:     %8lu kB\n"
679                   "Anonymous:      %8lu kB\n"
680                   "AnonHugePages:  %8lu kB\n"
681                   "Shared_Hugetlb: %8lu kB\n"
682                   "Private_Hugetlb: %7lu kB\n"
683                   "Swap:           %8lu kB\n"
684                   "SwapPss:        %8lu kB\n"
685                   "KernelPageSize: %8lu kB\n"
686                   "MMUPageSize:    %8lu kB\n"
687                   "Locked:         %8lu kB\n",
688                   (vma->vm_end - vma->vm_start) >> 10,
689                   mss.resident >> 10,
690                   (unsigned long)(mss.pss >> (10 + PSS_SHIFT)),
691                   mss.shared_clean  >> 10,
692                   mss.shared_dirty  >> 10,
693                   mss.private_clean >> 10,
694                   mss.private_dirty >> 10,
695                   mss.referenced >> 10,
696                   mss.anonymous >> 10,
697                   mss.anonymous_thp >> 10,
698                   mss.shared_hugetlb >> 10,
699                   mss.private_hugetlb >> 10,
700                   mss.swap >> 10,
701                   (unsigned long)(mss.swap_pss >> (10 + PSS_SHIFT)),
702                   vma_kernel_pagesize(vma) >> 10,
703                   vma_mmu_pagesize(vma) >> 10,
704                   (vma->vm_flags & VM_LOCKED) ?
705                        (unsigned long)(mss.pss >> (10 + PSS_SHIFT)) : 0);
706
707        show_smap_vma_flags(m, vma);
708        m_cache_vma(m, vma);
709        return 0;
710}
711
712static int show_pid_smap(struct seq_file *m, void *v)
713{
714        return show_smap(m, v, 1);
715}
716
717static int show_tid_smap(struct seq_file *m, void *v)
718{
719        return show_smap(m, v, 0);
720}
721
722static const struct seq_operations proc_pid_smaps_op = {
723        .start  = m_start,
724        .next   = m_next,
725        .stop   = m_stop,
726        .show   = show_pid_smap
727};
728
729static const struct seq_operations proc_tid_smaps_op = {
730        .start  = m_start,
731        .next   = m_next,
732        .stop   = m_stop,
733        .show   = show_tid_smap
734};
735
736static int pid_smaps_open(struct inode *inode, struct file *file)
737{
738        return do_maps_open(inode, file, &proc_pid_smaps_op);
739}
740
741static int tid_smaps_open(struct inode *inode, struct file *file)
742{
743        return do_maps_open(inode, file, &proc_tid_smaps_op);
744}
745
746const struct file_operations proc_pid_smaps_operations = {
747        .open           = pid_smaps_open,
748        .read           = seq_read,
749        .llseek         = seq_lseek,
750        .release        = proc_map_release,
751};
752
753const struct file_operations proc_tid_smaps_operations = {
754        .open           = tid_smaps_open,
755        .read           = seq_read,
756        .llseek         = seq_lseek,
757        .release        = proc_map_release,
758};
759
760enum clear_refs_types {
761        CLEAR_REFS_ALL = 1,
762        CLEAR_REFS_ANON,
763        CLEAR_REFS_MAPPED,
764        CLEAR_REFS_SOFT_DIRTY,
765        CLEAR_REFS_MM_HIWATER_RSS,
766        CLEAR_REFS_LAST,
767};
768
769struct clear_refs_private {
770        enum clear_refs_types type;
771};
772
773#ifdef CONFIG_MEM_SOFT_DIRTY
774static inline void clear_soft_dirty(struct vm_area_struct *vma,
775                unsigned long addr, pte_t *pte)
776{
777        /*
778         * The soft-dirty tracker uses #PF-s to catch writes
779         * to pages, so write-protect the pte as well. See the
780         * Documentation/vm/soft-dirty.txt for full description
781         * of how soft-dirty works.
782         */
783        pte_t ptent = *pte;
784
785        if (pte_present(ptent)) {
786                ptent = ptep_modify_prot_start(vma->vm_mm, addr, pte);
787                ptent = pte_wrprotect(ptent);
788                ptent = pte_clear_soft_dirty(ptent);
789                ptep_modify_prot_commit(vma->vm_mm, addr, pte, ptent);
790        } else if (is_swap_pte(ptent)) {
791                ptent = pte_swp_clear_soft_dirty(ptent);
792                set_pte_at(vma->vm_mm, addr, pte, ptent);
793        }
794}
795#else
796static inline void clear_soft_dirty(struct vm_area_struct *vma,
797                unsigned long addr, pte_t *pte)
798{
799}
800#endif
801
802#if defined(CONFIG_MEM_SOFT_DIRTY) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
803static inline void clear_soft_dirty_pmd(struct vm_area_struct *vma,
804                unsigned long addr, pmd_t *pmdp)
805{
806        pmd_t pmd = *pmdp;
807
808        /* See comment in change_huge_pmd() */
809        pmdp_invalidate(vma, addr, pmdp);
810        if (pmd_dirty(*pmdp))
811                pmd = pmd_mkdirty(pmd);
812        if (pmd_young(*pmdp))
813                pmd = pmd_mkyoung(pmd);
814
815        pmd = pmd_wrprotect(pmd);
816        pmd = pmd_clear_soft_dirty(pmd);
817
818        if (vma->vm_flags & VM_SOFTDIRTY)
819                vma->vm_flags &= ~VM_SOFTDIRTY;
820
821        set_pmd_at(vma->vm_mm, addr, pmdp, pmd);
822}
823#else
824static inline void clear_soft_dirty_pmd(struct vm_area_struct *vma,
825                unsigned long addr, pmd_t *pmdp)
826{
827}
828#endif
829
830static int clear_refs_pte_range(pmd_t *pmd, unsigned long addr,
831                                unsigned long end, struct mm_walk *walk)
832{
833        struct clear_refs_private *cp = walk->private;
834        struct vm_area_struct *vma = walk->vma;
835        pte_t *pte, ptent;
836        spinlock_t *ptl;
837        struct page *page;
838
839        if (pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
840                if (cp->type == CLEAR_REFS_SOFT_DIRTY) {
841                        clear_soft_dirty_pmd(vma, addr, pmd);
842                        goto out;
843                }
844
845                page = pmd_page(*pmd);
846
847                /* Clear accessed and referenced bits. */
848                pmdp_test_and_clear_young(vma, addr, pmd);
849                test_and_clear_page_young(page);
850                ClearPageReferenced(page);
851out:
852                spin_unlock(ptl);
853                return 0;
854        }
855
856        if (pmd_trans_unstable(pmd))
857                return 0;
858
859        pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
860        for (; addr != end; pte++, addr += PAGE_SIZE) {
861                ptent = *pte;
862
863                if (cp->type == CLEAR_REFS_SOFT_DIRTY) {
864                        clear_soft_dirty(vma, addr, pte);
865                        continue;
866                }
867
868                if (!pte_present(ptent))
869                        continue;
870
871                page = vm_normal_page(vma, addr, ptent);
872                if (!page)
873                        continue;
874
875                /* Clear accessed and referenced bits. */
876                ptep_test_and_clear_young(vma, addr, pte);
877                test_and_clear_page_young(page);
878                ClearPageReferenced(page);
879        }
880        pte_unmap_unlock(pte - 1, ptl);
881        cond_resched();
882        return 0;
883}
884
885static int clear_refs_test_walk(unsigned long start, unsigned long end,
886                                struct mm_walk *walk)
887{
888        struct clear_refs_private *cp = walk->private;
889        struct vm_area_struct *vma = walk->vma;
890
891        if (vma->vm_flags & VM_PFNMAP)
892                return 1;
893
894        /*
895         * Writing 1 to /proc/pid/clear_refs affects all pages.
896         * Writing 2 to /proc/pid/clear_refs only affects anonymous pages.
897         * Writing 3 to /proc/pid/clear_refs only affects file mapped pages.
898         * Writing 4 to /proc/pid/clear_refs affects all pages.
899         */
900        if (cp->type == CLEAR_REFS_ANON && vma->vm_file)
901                return 1;
902        if (cp->type == CLEAR_REFS_MAPPED && !vma->vm_file)
903                return 1;
904        return 0;
905}
906
907static ssize_t clear_refs_write(struct file *file, const char __user *buf,
908                                size_t count, loff_t *ppos)
909{
910        struct task_struct *task;
911        char buffer[PROC_NUMBUF];
912        struct mm_struct *mm;
913        struct vm_area_struct *vma;
914        enum clear_refs_types type;
915        int itype;
916        int rv;
917
918        memset(buffer, 0, sizeof(buffer));
919        if (count > sizeof(buffer) - 1)
920                count = sizeof(buffer) - 1;
921        if (copy_from_user(buffer, buf, count))
922                return -EFAULT;
923        rv = kstrtoint(strstrip(buffer), 10, &itype);
924        if (rv < 0)
925                return rv;
926        type = (enum clear_refs_types)itype;
927        if (type < CLEAR_REFS_ALL || type >= CLEAR_REFS_LAST)
928                return -EINVAL;
929
930        task = get_proc_task(file_inode(file));
931        if (!task)
932                return -ESRCH;
933        mm = get_task_mm(task);
934        if (mm) {
935                struct clear_refs_private cp = {
936                        .type = type,
937                };
938                struct mm_walk clear_refs_walk = {
939                        .pmd_entry = clear_refs_pte_range,
940                        .test_walk = clear_refs_test_walk,
941                        .mm = mm,
942                        .private = &cp,
943                };
944
945                if (type == CLEAR_REFS_MM_HIWATER_RSS) {
946                        /*
947                         * Writing 5 to /proc/pid/clear_refs resets the peak
948                         * resident set size to this mm's current rss value.
949                         */
950                        down_write(&mm->mmap_sem);
951                        reset_mm_hiwater_rss(mm);
952                        up_write(&mm->mmap_sem);
953                        goto out_mm;
954                }
955
956                down_read(&mm->mmap_sem);
957                if (type == CLEAR_REFS_SOFT_DIRTY) {
958                        for (vma = mm->mmap; vma; vma = vma->vm_next) {
959                                if (!(vma->vm_flags & VM_SOFTDIRTY))
960                                        continue;
961                                up_read(&mm->mmap_sem);
962                                down_write(&mm->mmap_sem);
963                                for (vma = mm->mmap; vma; vma = vma->vm_next) {
964                                        vma->vm_flags &= ~VM_SOFTDIRTY;
965                                        vma_set_page_prot(vma);
966                                }
967                                downgrade_write(&mm->mmap_sem);
968                                break;
969                        }
970                        mmu_notifier_invalidate_range_start(mm, 0, -1);
971                }
972                walk_page_range(0, ~0UL, &clear_refs_walk);
973                if (type == CLEAR_REFS_SOFT_DIRTY)
974                        mmu_notifier_invalidate_range_end(mm, 0, -1);
975                flush_tlb_mm(mm);
976                up_read(&mm->mmap_sem);
977out_mm:
978                mmput(mm);
979        }
980        put_task_struct(task);
981
982        return count;
983}
984
985const struct file_operations proc_clear_refs_operations = {
986        .write          = clear_refs_write,
987        .llseek         = noop_llseek,
988};
989
990typedef struct {
991        u64 pme;
992} pagemap_entry_t;
993
994struct pagemapread {
995        int pos, len;           /* units: PM_ENTRY_BYTES, not bytes */
996        pagemap_entry_t *buffer;
997        bool show_pfn;
998};
999
1000#define PAGEMAP_WALK_SIZE       (PMD_SIZE)
1001#define PAGEMAP_WALK_MASK       (PMD_MASK)
1002
1003#define PM_ENTRY_BYTES          sizeof(pagemap_entry_t)
1004#define PM_PFRAME_BITS          55
1005#define PM_PFRAME_MASK          GENMASK_ULL(PM_PFRAME_BITS - 1, 0)
1006#define PM_SOFT_DIRTY           BIT_ULL(55)
1007#define PM_MMAP_EXCLUSIVE       BIT_ULL(56)
1008#define PM_FILE                 BIT_ULL(61)
1009#define PM_SWAP                 BIT_ULL(62)
1010#define PM_PRESENT              BIT_ULL(63)
1011
1012#define PM_END_OF_BUFFER    1
1013
1014static inline pagemap_entry_t make_pme(u64 frame, u64 flags)
1015{
1016        return (pagemap_entry_t) { .pme = (frame & PM_PFRAME_MASK) | flags };
1017}
1018
1019static int add_to_pagemap(unsigned long addr, pagemap_entry_t *pme,
1020                          struct pagemapread *pm)
1021{
1022        pm->buffer[pm->pos++] = *pme;
1023        if (pm->pos >= pm->len)
1024                return PM_END_OF_BUFFER;
1025        return 0;
1026}
1027
1028static int pagemap_pte_hole(unsigned long start, unsigned long end,
1029                                struct mm_walk *walk)
1030{
1031        struct pagemapread *pm = walk->private;
1032        unsigned long addr = start;
1033        int err = 0;
1034
1035        while (addr < end) {
1036                struct vm_area_struct *vma = find_vma(walk->mm, addr);
1037                pagemap_entry_t pme = make_pme(0, 0);
1038                /* End of address space hole, which we mark as non-present. */
1039                unsigned long hole_end;
1040
1041                if (vma)
1042                        hole_end = min(end, vma->vm_start);
1043                else
1044                        hole_end = end;
1045
1046                for (; addr < hole_end; addr += PAGE_SIZE) {
1047                        err = add_to_pagemap(addr, &pme, pm);
1048                        if (err)
1049                                goto out;
1050                }
1051
1052                if (!vma)
1053                        break;
1054
1055                /* Addresses in the VMA. */
1056                if (vma->vm_flags & VM_SOFTDIRTY)
1057                        pme = make_pme(0, PM_SOFT_DIRTY);
1058                for (; addr < min(end, vma->vm_end); addr += PAGE_SIZE) {
1059                        err = add_to_pagemap(addr, &pme, pm);
1060                        if (err)
1061                                goto out;
1062                }
1063        }
1064out:
1065        return err;
1066}
1067
1068static pagemap_entry_t pte_to_pagemap_entry(struct pagemapread *pm,
1069                struct vm_area_struct *vma, unsigned long addr, pte_t pte)
1070{
1071        u64 frame = 0, flags = 0;
1072        struct page *page = NULL;
1073
1074        if (pte_present(pte)) {
1075                if (pm->show_pfn)
1076                        frame = pte_pfn(pte);
1077                flags |= PM_PRESENT;
1078                page = vm_normal_page(vma, addr, pte);
1079                if (pte_soft_dirty(pte))
1080                        flags |= PM_SOFT_DIRTY;
1081        } else if (is_swap_pte(pte)) {
1082                swp_entry_t entry;
1083                if (pte_swp_soft_dirty(pte))
1084                        flags |= PM_SOFT_DIRTY;
1085                entry = pte_to_swp_entry(pte);
1086                frame = swp_type(entry) |
1087                        (swp_offset(entry) << MAX_SWAPFILES_SHIFT);
1088                flags |= PM_SWAP;
1089                if (is_migration_entry(entry))
1090                        page = migration_entry_to_page(entry);
1091        }
1092
1093        if (page && !PageAnon(page))
1094                flags |= PM_FILE;
1095        if (page && page_mapcount(page) == 1)
1096                flags |= PM_MMAP_EXCLUSIVE;
1097        if (vma->vm_flags & VM_SOFTDIRTY)
1098                flags |= PM_SOFT_DIRTY;
1099
1100        return make_pme(frame, flags);
1101}
1102
1103static int pagemap_pmd_range(pmd_t *pmdp, unsigned long addr, unsigned long end,
1104                             struct mm_walk *walk)
1105{
1106        struct vm_area_struct *vma = walk->vma;
1107        struct pagemapread *pm = walk->private;
1108        spinlock_t *ptl;
1109        pte_t *pte, *orig_pte;
1110        int err = 0;
1111
1112#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1113        if (pmd_trans_huge_lock(pmdp, vma, &ptl) == 1) {
1114                u64 flags = 0, frame = 0;
1115                pmd_t pmd = *pmdp;
1116
1117                if ((vma->vm_flags & VM_SOFTDIRTY) || pmd_soft_dirty(pmd))
1118                        flags |= PM_SOFT_DIRTY;
1119
1120                /*
1121                 * Currently pmd for thp is always present because thp
1122                 * can not be swapped-out, migrated, or HWPOISONed
1123                 * (split in such cases instead.)
1124                 * This if-check is just to prepare for future implementation.
1125                 */
1126                if (pmd_present(pmd)) {
1127                        struct page *page = pmd_page(pmd);
1128
1129                        if (page_mapcount(page) == 1)
1130                                flags |= PM_MMAP_EXCLUSIVE;
1131
1132                        flags |= PM_PRESENT;
1133                        if (pm->show_pfn)
1134                                frame = pmd_pfn(pmd) +
1135                                        ((addr & ~PMD_MASK) >> PAGE_SHIFT);
1136                }
1137
1138                for (; addr != end; addr += PAGE_SIZE) {
1139                        pagemap_entry_t pme = make_pme(frame, flags);
1140
1141                        err = add_to_pagemap(addr, &pme, pm);
1142                        if (err)
1143                                break;
1144                        if (pm->show_pfn && (flags & PM_PRESENT))
1145                                frame++;
1146                }
1147                spin_unlock(ptl);
1148                return err;
1149        }
1150
1151        if (pmd_trans_unstable(pmdp))
1152                return 0;
1153#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
1154
1155        /*
1156         * We can assume that @vma always points to a valid one and @end never
1157         * goes beyond vma->vm_end.
1158         */
1159        orig_pte = pte = pte_offset_map_lock(walk->mm, pmdp, addr, &ptl);
1160        for (; addr < end; pte++, addr += PAGE_SIZE) {
1161                pagemap_entry_t pme;
1162
1163                pme = pte_to_pagemap_entry(pm, vma, addr, *pte);
1164                err = add_to_pagemap(addr, &pme, pm);
1165                if (err)
1166                        break;
1167        }
1168        pte_unmap_unlock(orig_pte, ptl);
1169
1170        cond_resched();
1171
1172        return err;
1173}
1174
1175#ifdef CONFIG_HUGETLB_PAGE
1176/* This function walks within one hugetlb entry in the single call */
1177static int pagemap_hugetlb_range(pte_t *ptep, unsigned long hmask,
1178                                 unsigned long addr, unsigned long end,
1179                                 struct mm_walk *walk)
1180{
1181        struct pagemapread *pm = walk->private;
1182        struct vm_area_struct *vma = walk->vma;
1183        u64 flags = 0, frame = 0;
1184        int err = 0;
1185        pte_t pte;
1186
1187        if (vma->vm_flags & VM_SOFTDIRTY)
1188                flags |= PM_SOFT_DIRTY;
1189
1190        pte = huge_ptep_get(ptep);
1191        if (pte_present(pte)) {
1192                struct page *page = pte_page(pte);
1193
1194                if (!PageAnon(page))
1195                        flags |= PM_FILE;
1196
1197                if (page_mapcount(page) == 1)
1198                        flags |= PM_MMAP_EXCLUSIVE;
1199
1200                flags |= PM_PRESENT;
1201                if (pm->show_pfn)
1202                        frame = pte_pfn(pte) +
1203                                ((addr & ~hmask) >> PAGE_SHIFT);
1204        }
1205
1206        for (; addr != end; addr += PAGE_SIZE) {
1207                pagemap_entry_t pme = make_pme(frame, flags);
1208
1209                err = add_to_pagemap(addr, &pme, pm);
1210                if (err)
1211                        return err;
1212                if (pm->show_pfn && (flags & PM_PRESENT))
1213                        frame++;
1214        }
1215
1216        cond_resched();
1217
1218        return err;
1219}
1220#endif /* HUGETLB_PAGE */
1221
1222/*
1223 * /proc/pid/pagemap - an array mapping virtual pages to pfns
1224 *
1225 * For each page in the address space, this file contains one 64-bit entry
1226 * consisting of the following:
1227 *
1228 * Bits 0-54  page frame number (PFN) if present
1229 * Bits 0-4   swap type if swapped
1230 * Bits 5-54  swap offset if swapped
1231 * Bit  55    pte is soft-dirty (see Documentation/vm/soft-dirty.txt)
1232 * Bit  56    page exclusively mapped
1233 * Bits 57-60 zero
1234 * Bit  61    page is file-page or shared-anon
1235 * Bit  62    page swapped
1236 * Bit  63    page present
1237 *
1238 * If the page is not present but in swap, then the PFN contains an
1239 * encoding of the swap file number and the page's offset into the
1240 * swap. Unmapped pages return a null PFN. This allows determining
1241 * precisely which pages are mapped (or in swap) and comparing mapped
1242 * pages between processes.
1243 *
1244 * Efficient users of this interface will use /proc/pid/maps to
1245 * determine which areas of memory are actually mapped and llseek to
1246 * skip over unmapped regions.
1247 */
1248static ssize_t pagemap_read(struct file *file, char __user *buf,
1249                            size_t count, loff_t *ppos)
1250{
1251        struct mm_struct *mm = file->private_data;
1252        struct pagemapread pm;
1253        struct mm_walk pagemap_walk = {};
1254        unsigned long src;
1255        unsigned long svpfn;
1256        unsigned long start_vaddr;
1257        unsigned long end_vaddr;
1258        int ret = 0, copied = 0;
1259
1260        if (!mm || !atomic_inc_not_zero(&mm->mm_users))
1261                goto out;
1262
1263        ret = -EINVAL;
1264        /* file position must be aligned */
1265        if ((*ppos % PM_ENTRY_BYTES) || (count % PM_ENTRY_BYTES))
1266                goto out_mm;
1267
1268        ret = 0;
1269        if (!count)
1270                goto out_mm;
1271
1272        /* do not disclose physical addresses: attack vector */
1273        pm.show_pfn = file_ns_capable(file, &init_user_ns, CAP_SYS_ADMIN);
1274
1275        pm.len = (PAGEMAP_WALK_SIZE >> PAGE_SHIFT);
1276        pm.buffer = kmalloc(pm.len * PM_ENTRY_BYTES, GFP_TEMPORARY);
1277        ret = -ENOMEM;
1278        if (!pm.buffer)
1279                goto out_mm;
1280
1281        pagemap_walk.pmd_entry = pagemap_pmd_range;
1282        pagemap_walk.pte_hole = pagemap_pte_hole;
1283#ifdef CONFIG_HUGETLB_PAGE
1284        pagemap_walk.hugetlb_entry = pagemap_hugetlb_range;
1285#endif
1286        pagemap_walk.mm = mm;
1287        pagemap_walk.private = &pm;
1288
1289        src = *ppos;
1290        svpfn = src / PM_ENTRY_BYTES;
1291        start_vaddr = svpfn << PAGE_SHIFT;
1292        end_vaddr = mm->task_size;
1293
1294        /* watch out for wraparound */
1295        if (svpfn > mm->task_size >> PAGE_SHIFT)
1296                start_vaddr = end_vaddr;
1297
1298        /*
1299         * The odds are that this will stop walking way
1300         * before end_vaddr, because the length of the
1301         * user buffer is tracked in "pm", and the walk
1302         * will stop when we hit the end of the buffer.
1303         */
1304        ret = 0;
1305        while (count && (start_vaddr < end_vaddr)) {
1306                int len;
1307                unsigned long end;
1308
1309                pm.pos = 0;
1310                end = (start_vaddr + PAGEMAP_WALK_SIZE) & PAGEMAP_WALK_MASK;
1311                /* overflow ? */
1312                if (end < start_vaddr || end > end_vaddr)
1313                        end = end_vaddr;
1314                down_read(&mm->mmap_sem);
1315                ret = walk_page_range(start_vaddr, end, &pagemap_walk);
1316                up_read(&mm->mmap_sem);
1317                start_vaddr = end;
1318
1319                len = min(count, PM_ENTRY_BYTES * pm.pos);
1320                if (copy_to_user(buf, pm.buffer, len)) {
1321                        ret = -EFAULT;
1322                        goto out_free;
1323                }
1324                copied += len;
1325                buf += len;
1326                count -= len;
1327        }
1328        *ppos += copied;
1329        if (!ret || ret == PM_END_OF_BUFFER)
1330                ret = copied;
1331
1332out_free:
1333        kfree(pm.buffer);
1334out_mm:
1335        mmput(mm);
1336out:
1337        return ret;
1338}
1339
1340static int pagemap_open(struct inode *inode, struct file *file)
1341{
1342        struct mm_struct *mm;
1343
1344        mm = proc_mem_open(inode, PTRACE_MODE_READ);
1345        if (IS_ERR(mm))
1346                return PTR_ERR(mm);
1347        file->private_data = mm;
1348        return 0;
1349}
1350
1351static int pagemap_release(struct inode *inode, struct file *file)
1352{
1353        struct mm_struct *mm = file->private_data;
1354
1355        if (mm)
1356                mmdrop(mm);
1357        return 0;
1358}
1359
1360const struct file_operations proc_pagemap_operations = {
1361        .llseek         = mem_lseek, /* borrow this */
1362        .read           = pagemap_read,
1363        .open           = pagemap_open,
1364        .release        = pagemap_release,
1365};
1366#endif /* CONFIG_PROC_PAGE_MONITOR */
1367
1368#ifdef CONFIG_NUMA
1369
1370struct numa_maps {
1371        unsigned long pages;
1372        unsigned long anon;
1373        unsigned long active;
1374        unsigned long writeback;
1375        unsigned long mapcount_max;
1376        unsigned long dirty;
1377        unsigned long swapcache;
1378        unsigned long node[MAX_NUMNODES];
1379};
1380
1381struct numa_maps_private {
1382        struct proc_maps_private proc_maps;
1383        struct numa_maps md;
1384};
1385
1386static void gather_stats(struct page *page, struct numa_maps *md, int pte_dirty,
1387                        unsigned long nr_pages)
1388{
1389        int count = page_mapcount(page);
1390
1391        md->pages += nr_pages;
1392        if (pte_dirty || PageDirty(page))
1393                md->dirty += nr_pages;
1394
1395        if (PageSwapCache(page))
1396                md->swapcache += nr_pages;
1397
1398        if (PageActive(page) || PageUnevictable(page))
1399                md->active += nr_pages;
1400
1401        if (PageWriteback(page))
1402                md->writeback += nr_pages;
1403
1404        if (PageAnon(page))
1405                md->anon += nr_pages;
1406
1407        if (count > md->mapcount_max)
1408                md->mapcount_max = count;
1409
1410        md->node[page_to_nid(page)] += nr_pages;
1411}
1412
1413static struct page *can_gather_numa_stats(pte_t pte, struct vm_area_struct *vma,
1414                unsigned long addr)
1415{
1416        struct page *page;
1417        int nid;
1418
1419        if (!pte_present(pte))
1420                return NULL;
1421
1422        page = vm_normal_page(vma, addr, pte);
1423        if (!page)
1424                return NULL;
1425
1426        if (PageReserved(page))
1427                return NULL;
1428
1429        nid = page_to_nid(page);
1430        if (!node_isset(nid, node_states[N_MEMORY]))
1431                return NULL;
1432
1433        return page;
1434}
1435
1436#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1437static struct page *can_gather_numa_stats_pmd(pmd_t pmd,
1438                                              struct vm_area_struct *vma,
1439                                              unsigned long addr)
1440{
1441        struct page *page;
1442        int nid;
1443
1444        if (!pmd_present(pmd))
1445                return NULL;
1446
1447        page = vm_normal_page_pmd(vma, addr, pmd);
1448        if (!page)
1449                return NULL;
1450
1451        if (PageReserved(page))
1452                return NULL;
1453
1454        nid = page_to_nid(page);
1455        if (!node_isset(nid, node_states[N_MEMORY]))
1456                return NULL;
1457
1458        return page;
1459}
1460#endif
1461
1462static int gather_pte_stats(pmd_t *pmd, unsigned long addr,
1463                unsigned long end, struct mm_walk *walk)
1464{
1465        struct numa_maps *md = walk->private;
1466        struct vm_area_struct *vma = walk->vma;
1467        spinlock_t *ptl;
1468        pte_t *orig_pte;
1469        pte_t *pte;
1470
1471#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1472        if (pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
1473                struct page *page;
1474
1475                page = can_gather_numa_stats_pmd(*pmd, vma, addr);
1476                if (page)
1477                        gather_stats(page, md, pmd_dirty(*pmd),
1478                                     HPAGE_PMD_SIZE/PAGE_SIZE);
1479                spin_unlock(ptl);
1480                return 0;
1481        }
1482
1483        if (pmd_trans_unstable(pmd))
1484                return 0;
1485#endif
1486        orig_pte = pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
1487        do {
1488                struct page *page = can_gather_numa_stats(*pte, vma, addr);
1489                if (!page)
1490                        continue;
1491                gather_stats(page, md, pte_dirty(*pte), 1);
1492
1493        } while (pte++, addr += PAGE_SIZE, addr != end);
1494        pte_unmap_unlock(orig_pte, ptl);
1495        return 0;
1496}
1497#ifdef CONFIG_HUGETLB_PAGE
1498static int gather_hugetlb_stats(pte_t *pte, unsigned long hmask,
1499                unsigned long addr, unsigned long end, struct mm_walk *walk)
1500{
1501        pte_t huge_pte = huge_ptep_get(pte);
1502        struct numa_maps *md;
1503        struct page *page;
1504
1505        if (!pte_present(huge_pte))
1506                return 0;
1507
1508        page = pte_page(huge_pte);
1509        if (!page)
1510                return 0;
1511
1512        md = walk->private;
1513        gather_stats(page, md, pte_dirty(huge_pte), 1);
1514        return 0;
1515}
1516
1517#else
1518static int gather_hugetlb_stats(pte_t *pte, unsigned long hmask,
1519                unsigned long addr, unsigned long end, struct mm_walk *walk)
1520{
1521        return 0;
1522}
1523#endif
1524
1525/*
1526 * Display pages allocated per node and memory policy via /proc.
1527 */
1528static int show_numa_map(struct seq_file *m, void *v, int is_pid)
1529{
1530        struct numa_maps_private *numa_priv = m->private;
1531        struct proc_maps_private *proc_priv = &numa_priv->proc_maps;
1532        struct vm_area_struct *vma = v;
1533        struct numa_maps *md = &numa_priv->md;
1534        struct file *file = vma->vm_file;
1535        struct mm_struct *mm = vma->vm_mm;
1536        struct mm_walk walk = {
1537                .hugetlb_entry = gather_hugetlb_stats,
1538                .pmd_entry = gather_pte_stats,
1539                .private = md,
1540                .mm = mm,
1541        };
1542        struct mempolicy *pol;
1543        char buffer[64];
1544        int nid;
1545
1546        if (!mm)
1547                return 0;
1548
1549        /* Ensure we start with an empty set of numa_maps statistics. */
1550        memset(md, 0, sizeof(*md));
1551
1552        pol = __get_vma_policy(vma, vma->vm_start);
1553        if (pol) {
1554                mpol_to_str(buffer, sizeof(buffer), pol);
1555                mpol_cond_put(pol);
1556        } else {
1557                mpol_to_str(buffer, sizeof(buffer), proc_priv->task_mempolicy);
1558        }
1559
1560        seq_printf(m, "%08lx %s", vma->vm_start, buffer);
1561
1562        if (file) {
1563                seq_puts(m, " file=");
1564                seq_file_path(m, file, "\n\t= ");
1565        } else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {
1566                seq_puts(m, " heap");
1567        } else if (is_stack(proc_priv, vma, is_pid)) {
1568                seq_puts(m, " stack");
1569        }
1570
1571        if (is_vm_hugetlb_page(vma))
1572                seq_puts(m, " huge");
1573
1574        /* mmap_sem is held by m_start */
1575        walk_page_vma(vma, &walk);
1576
1577        if (!md->pages)
1578                goto out;
1579
1580        if (md->anon)
1581                seq_printf(m, " anon=%lu", md->anon);
1582
1583        if (md->dirty)
1584                seq_printf(m, " dirty=%lu", md->dirty);
1585
1586        if (md->pages != md->anon && md->pages != md->dirty)
1587                seq_printf(m, " mapped=%lu", md->pages);
1588
1589        if (md->mapcount_max > 1)
1590                seq_printf(m, " mapmax=%lu", md->mapcount_max);
1591
1592        if (md->swapcache)
1593                seq_printf(m, " swapcache=%lu", md->swapcache);
1594
1595        if (md->active < md->pages && !is_vm_hugetlb_page(vma))
1596                seq_printf(m, " active=%lu", md->active);
1597
1598        if (md->writeback)
1599                seq_printf(m, " writeback=%lu", md->writeback);
1600
1601        for_each_node_state(nid, N_MEMORY)
1602                if (md->node[nid])
1603                        seq_printf(m, " N%d=%lu", nid, md->node[nid]);
1604
1605        seq_printf(m, " kernelpagesize_kB=%lu", vma_kernel_pagesize(vma) >> 10);
1606out:
1607        seq_putc(m, '\n');
1608        m_cache_vma(m, vma);
1609        return 0;
1610}
1611
1612static int show_pid_numa_map(struct seq_file *m, void *v)
1613{
1614        return show_numa_map(m, v, 1);
1615}
1616
1617static int show_tid_numa_map(struct seq_file *m, void *v)
1618{
1619        return show_numa_map(m, v, 0);
1620}
1621
1622static const struct seq_operations proc_pid_numa_maps_op = {
1623        .start  = m_start,
1624        .next   = m_next,
1625        .stop   = m_stop,
1626        .show   = show_pid_numa_map,
1627};
1628
1629static const struct seq_operations proc_tid_numa_maps_op = {
1630        .start  = m_start,
1631        .next   = m_next,
1632        .stop   = m_stop,
1633        .show   = show_tid_numa_map,
1634};
1635
1636static int numa_maps_open(struct inode *inode, struct file *file,
1637                          const struct seq_operations *ops)
1638{
1639        return proc_maps_open(inode, file, ops,
1640                                sizeof(struct numa_maps_private));
1641}
1642
1643static int pid_numa_maps_open(struct inode *inode, struct file *file)
1644{
1645        return numa_maps_open(inode, file, &proc_pid_numa_maps_op);
1646}
1647
1648static int tid_numa_maps_open(struct inode *inode, struct file *file)
1649{
1650        return numa_maps_open(inode, file, &proc_tid_numa_maps_op);
1651}
1652
1653const struct file_operations proc_pid_numa_maps_operations = {
1654        .open           = pid_numa_maps_open,
1655        .read           = seq_read,
1656        .llseek         = seq_lseek,
1657        .release        = proc_map_release,
1658};
1659
1660const struct file_operations proc_tid_numa_maps_operations = {
1661        .open           = tid_numa_maps_open,
1662        .read           = seq_read,
1663        .llseek         = seq_lseek,
1664        .release        = proc_map_release,
1665};
1666#endif /* CONFIG_NUMA */
Note: See TracBrowser for help on using the repository browser.