mm: vmalloc: show number of vmalloc pages in /proc/meminfo

[mirror_ubuntu-hirsute-kernel.git] / fs / proc / task_mmu.c

diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 01d4eb0e6bd1155f38df153915bfaf20b96406c8..dedca3da428a136f0ead9aa590ba9fed03ce2e39 100644 (file)
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -166,7 +166,11 @@ static void *m_start(struct seq_file *m, loff_t *ppos)
        if (!mm || !mmget_not_zero(mm))
                return NULL;
 
-       down_read(&mm->mmap_sem);
+       if (down_read_killable(&mm->mmap_sem)) {
+               mmput(mm);
+               return ERR_PTR(-EINTR);
+       }
+
        hold_task_mempolicy(priv);
        priv->tail_vma = get_gate_vma(mm);
 
@@ -417,17 +421,53 @@ struct mem_size_stats {
        unsigned long shared_hugetlb;
        unsigned long private_hugetlb;
        u64 pss;
+       u64 pss_anon;
+       u64 pss_file;
+       u64 pss_shmem;
        u64 pss_locked;
        u64 swap_pss;
        bool check_shmem_swap;
 };
 
+static void smaps_page_accumulate(struct mem_size_stats *mss,
+               struct page *page, unsigned long size, unsigned long pss,
+               bool dirty, bool locked, bool private)
+{
+       mss->pss += pss;
+
+       if (PageAnon(page))
+               mss->pss_anon += pss;
+       else if (PageSwapBacked(page))
+               mss->pss_shmem += pss;
+       else
+               mss->pss_file += pss;
+
+       if (locked)
+               mss->pss_locked += pss;
+
+       if (dirty || PageDirty(page)) {
+               if (private)
+                       mss->private_dirty += size;
+               else
+                       mss->shared_dirty += size;
+       } else {
+               if (private)
+                       mss->private_clean += size;
+               else
+                       mss->shared_clean += size;
+       }
+}
+
 static void smaps_account(struct mem_size_stats *mss, struct page *page,
                bool compound, bool young, bool dirty, bool locked)
 {
        int i, nr = compound ? 1 << compound_order(page) : 1;
        unsigned long size = nr * PAGE_SIZE;
 
+       /*
+        * First accumulate quantities that depend only on |size| and the type
+        * of the compound page.
+        */
        if (PageAnon(page)) {
                mss->anonymous += size;
                if (!PageSwapBacked(page) && !dirty && !PageDirty(page))
@@ -440,42 +480,25 @@ static void smaps_account(struct mem_size_stats *mss, struct page *page,
                mss->referenced += size;
 
        /*
+        * Then accumulate quantities that may depend on sharing, or that may
+        * differ page-by-page.
+        *
         * page_count(page) == 1 guarantees the page is mapped exactly once.
         * If any subpage of the compound page mapped with PTE it would elevate
         * page_count().
         */
        if (page_count(page) == 1) {
-               if (dirty || PageDirty(page))
-                       mss->private_dirty += size;
-               else
-                       mss->private_clean += size;
-               mss->pss += (u64)size << PSS_SHIFT;
-               if (locked)
-                       mss->pss_locked += (u64)size << PSS_SHIFT;
+               smaps_page_accumulate(mss, page, size, size << PSS_SHIFT, dirty,
+                       locked, true);
                return;
        }
-
        for (i = 0; i < nr; i++, page++) {
                int mapcount = page_mapcount(page);
-               unsigned long pss = (PAGE_SIZE << PSS_SHIFT);
-
-               if (mapcount >= 2) {
-                       if (dirty || PageDirty(page))
-                               mss->shared_dirty += PAGE_SIZE;
-                       else
-                               mss->shared_clean += PAGE_SIZE;
-                       mss->pss += pss / mapcount;
-                       if (locked)
-                               mss->pss_locked += pss / mapcount;
-               } else {
-                       if (dirty || PageDirty(page))
-                               mss->private_dirty += PAGE_SIZE;
-                       else
-                               mss->private_clean += PAGE_SIZE;
-                       mss->pss += pss;
-                       if (locked)
-                               mss->pss_locked += pss;
-               }
+               unsigned long pss = PAGE_SIZE << PSS_SHIFT;
+               if (mapcount >= 2)
+                       pss /= mapcount;
+               smaps_page_accumulate(mss, page, PAGE_SIZE, pss, dirty, locked,
+                                     mapcount < 2);
        }
 }
 
@@ -754,10 +777,23 @@ static void smap_gather_stats(struct vm_area_struct *vma,
                seq_put_decimal_ull_width(m, str, (val) >> 10, 8)
 
 /* Show the contents common for smaps and smaps_rollup */
-static void __show_smap(struct seq_file *m, const struct mem_size_stats *mss)
+static void __show_smap(struct seq_file *m, const struct mem_size_stats *mss,
+       bool rollup_mode)
 {
        SEQ_PUT_DEC("Rss:            ", mss->resident);
        SEQ_PUT_DEC(" kB\nPss:            ", mss->pss >> PSS_SHIFT);
+       if (rollup_mode) {
+               /*
+                * These are meaningful only for smaps_rollup, otherwise two of
+                * them are zero, and the other one is the same as Pss.
+                */
+               SEQ_PUT_DEC(" kB\nPss_Anon:       ",
+                       mss->pss_anon >> PSS_SHIFT);
+               SEQ_PUT_DEC(" kB\nPss_File:       ",
+                       mss->pss_file >> PSS_SHIFT);
+               SEQ_PUT_DEC(" kB\nPss_Shmem:      ",
+                       mss->pss_shmem >> PSS_SHIFT);
+       }
        SEQ_PUT_DEC(" kB\nShared_Clean:   ", mss->shared_clean);
        SEQ_PUT_DEC(" kB\nShared_Dirty:   ", mss->shared_dirty);
        SEQ_PUT_DEC(" kB\nPrivate_Clean:  ", mss->private_clean);
@@ -794,7 +830,7 @@ static int show_smap(struct seq_file *m, void *v)
        SEQ_PUT_DEC(" kB\nMMUPageSize:    ", vma_mmu_pagesize(vma));
        seq_puts(m, " kB\n");
 
-       __show_smap(m, &mss);
+       __show_smap(m, &mss, false);
 
        seq_printf(m, "THPeligible:    %d\n", transparent_hugepage_enabled(vma));
 
@@ -828,7 +864,10 @@ static int show_smaps_rollup(struct seq_file *m, void *v)
 
        memset(&mss, 0, sizeof(mss));
 
-       down_read(&mm->mmap_sem);
+       ret = down_read_killable(&mm->mmap_sem);
+       if (ret)
+               goto out_put_mm;
+
        hold_task_mempolicy(priv);
 
        for (vma = priv->mm->mmap; vma; vma = vma->vm_next) {
@@ -841,12 +880,13 @@ static int show_smaps_rollup(struct seq_file *m, void *v)
        seq_pad(m, ' ');
        seq_puts(m, "[rollup]\n");
 
-       __show_smap(m, &mss);
+       __show_smap(m, &mss, true);
 
        release_task_mempolicy(priv);
        up_read(&mm->mmap_sem);
-       mmput(mm);
 
+out_put_mm:
+       mmput(mm);
 out_put_task:
        put_task_struct(priv->task);
        priv->task = NULL;
@@ -1132,7 +1172,10 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                        goto out_mm;
                }
 
-               down_read(&mm->mmap_sem);
+               if (down_read_killable(&mm->mmap_sem)) {
+                       count = -EINTR;
+                       goto out_mm;
+               }
                tlb_gather_mmu(&tlb, mm, 0, -1);
                if (type == CLEAR_REFS_SOFT_DIRTY) {
                        for (vma = mm->mmap; vma; vma = vma->vm_next) {
@@ -1539,7 +1582,9 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
                /* overflow ? */
                if (end < start_vaddr || end > end_vaddr)
                        end = end_vaddr;
-               down_read(&mm->mmap_sem);
+               ret = down_read_killable(&mm->mmap_sem);
+               if (ret)
+                       goto out_free;
                ret = walk_page_range(start_vaddr, end, &pagemap_walk);
                up_read(&mm->mmap_sem);
                start_vaddr = end;