LCOV - code coverage report
Current view: top level - fs/proc - task_mmu.c (source / functions) Hit Total Coverage
Test: Real Lines: 131 450 29.1 %
Date: 2020-10-17 15:46:16 Functions: 0 34 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14