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

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

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