[linux.git] / fs / proc / task_mmu.c

#include <linux/mm.h>
#include <linux/hugetlb.h>
#include <linux/mount.h>
#include <linux/seq_file.h>
#include <linux/highmem.h>
#include <linux/ptrace.h>
#include <linux/pagemap.h>
#include <linux/mempolicy.h>

#include <asm/elf.h>
#include <asm/uaccess.h>
#include <asm/tlbflush.h>
#include "internal.h"

char *task_mem(struct mm_struct *mm, char *buffer)
{
	unsigned long data, text, lib;
	unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss;

	/*
	 * Note: to minimize their overhead, mm maintains hiwater_vm and
	 * hiwater_rss only when about to *lower* total_vm or rss.  Any
	 * collector of these hiwater stats must therefore get total_vm
	 * and rss too, which will usually be the higher.  Barriers? not
	 * worth the effort, such snapshots can always be inconsistent.
	 */
	hiwater_vm = total_vm = mm->total_vm;
	if (hiwater_vm < mm->hiwater_vm)
		hiwater_vm = mm->hiwater_vm;
	hiwater_rss = total_rss = get_mm_rss(mm);
	if (hiwater_rss < mm->hiwater_rss)
		hiwater_rss = mm->hiwater_rss;

	data = mm->total_vm - mm->shared_vm - mm->stack_vm;
	text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10;
	lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
	buffer += sprintf(buffer,
		"VmPeak:\t%8lu kB\n"
		"VmSize:\t%8lu kB\n"
		"VmLck:\t%8lu kB\n"
		"VmHWM:\t%8lu kB\n"
		"VmRSS:\t%8lu kB\n"
		"VmData:\t%8lu kB\n"
		"VmStk:\t%8lu kB\n"
		"VmExe:\t%8lu kB\n"
		"VmLib:\t%8lu kB\n"
		"VmPTE:\t%8lu kB\n",
		hiwater_vm << (PAGE_SHIFT-10),
		(total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
		mm->locked_vm << (PAGE_SHIFT-10),
		hiwater_rss << (PAGE_SHIFT-10),
		total_rss << (PAGE_SHIFT-10),
		data << (PAGE_SHIFT-10),
		mm->stack_vm << (PAGE_SHIFT-10), text, lib,
		(PTRS_PER_PTE*sizeof(pte_t)*mm->nr_ptes) >> 10);
	return buffer;
}

unsigned long task_vsize(struct mm_struct *mm)
{
	return PAGE_SIZE * mm->total_vm;
}

int task_statm(struct mm_struct *mm, int *shared, int *text,
	       int *data, int *resident)
{
	*shared = get_mm_counter(mm, file_rss);
	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
								>> PAGE_SHIFT;
	*data = mm->total_vm - mm->shared_vm;
	*resident = *shared + get_mm_counter(mm, anon_rss);
	return mm->total_vm;
}

int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
	struct vm_area_struct * vma;
	int result = -ENOENT;
	struct task_struct *task = get_proc_task(inode);
	struct mm_struct * mm = NULL;

	if (task) {
		mm = get_task_mm(task);
		put_task_struct(task);
	}
	if (!mm)
		goto out;
	down_read(&mm->mmap_sem);

	vma = mm->mmap;
	while (vma) {
		if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
			break;
		vma = vma->vm_next;
	}

	if (vma) {
		*mnt = mntget(vma->vm_file->f_path.mnt);
		*dentry = dget(vma->vm_file->f_path.dentry);
		result = 0;
	}

	up_read(&mm->mmap_sem);
	mmput(mm);
out:
	return result;
}

static void pad_len_spaces(struct seq_file *m, int len)
{
	len = 25 + sizeof(void*) * 6 - len;
	if (len < 1)
		len = 1;
	seq_printf(m, "%*c", len, ' ');
}

struct mem_size_stats
{
	unsigned long resident;
	unsigned long shared_clean;
	unsigned long shared_dirty;
	unsigned long private_clean;
	unsigned long private_dirty;
	unsigned long referenced;
};

struct pmd_walker {
	struct vm_area_struct *vma;
	void *private;
	void (*action)(struct vm_area_struct *, pmd_t *, unsigned long,
		       unsigned long, void *);
};

static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats *mss)
{
	struct proc_maps_private *priv = m->private;
	struct task_struct *task = priv->task;
	struct vm_area_struct *vma = v;
	struct mm_struct *mm = vma->vm_mm;
	struct file *file = vma->vm_file;
	int flags = vma->vm_flags;
	unsigned long ino = 0;
	dev_t dev = 0;
	int len;

	if (maps_protect && !ptrace_may_attach(task))
		return -EACCES;

	if (file) {
		struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
		dev = inode->i_sb->s_dev;
		ino = inode->i_ino;
	}

	seq_printf(m, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
			vma->vm_start,
			vma->vm_end,
			flags & VM_READ ? 'r' : '-',
			flags & VM_WRITE ? 'w' : '-',
			flags & VM_EXEC ? 'x' : '-',
			flags & VM_MAYSHARE ? 's' : 'p',
			vma->vm_pgoff << PAGE_SHIFT,
			MAJOR(dev), MINOR(dev), ino, &len);

	/*
	 * Print the dentry name for named mappings, and a
	 * special [heap] marker for the heap:
	 */
	if (file) {
		pad_len_spaces(m, len);
		seq_path(m, file->f_path.mnt, file->f_path.dentry, "\n");
	} else {
		const char *name = arch_vma_name(vma);
		if (!name) {
			if (mm) {
				if (vma->vm_start <= mm->start_brk &&
						vma->vm_end >= mm->brk) {
					name = "[heap]";
				} else if (vma->vm_start <= mm->start_stack &&
					   vma->vm_end >= mm->start_stack) {
					name = "[stack]";
				}
			} else {
				name = "[vdso]";
			}
		}
		if (name) {
			pad_len_spaces(m, len);
			seq_puts(m, name);
		}
	}
	seq_putc(m, '\n');

	if (mss)
		seq_printf(m,
			   "Size:           %8lu kB\n"
			   "Rss:            %8lu kB\n"
			   "Shared_Clean:   %8lu kB\n"
			   "Shared_Dirty:   %8lu kB\n"
			   "Private_Clean:  %8lu kB\n"
			   "Private_Dirty:  %8lu kB\n"
			   "Referenced:     %8lu kB\n",
			   (vma->vm_end - vma->vm_start) >> 10,
			   mss->resident >> 10,
			   mss->shared_clean  >> 10,
			   mss->shared_dirty  >> 10,
			   mss->private_clean >> 10,
			   mss->private_dirty >> 10,
			   mss->referenced >> 10);

	if (m->count < m->size)  /* vma is copied successfully */
		m->version = (vma != get_gate_vma(task))? vma->vm_start: 0;
	return 0;
}

static int show_map(struct seq_file *m, void *v)
{
	return show_map_internal(m, v, NULL);
}

static void smaps_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
			    unsigned long addr, unsigned long end,
			    void *private)
{
	struct mem_size_stats *mss = private;
	pte_t *pte, ptent;
	spinlock_t *ptl;
	struct page *page;

	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
	for (; addr != end; pte++, addr += PAGE_SIZE) {
		ptent = *pte;
		if (!pte_present(ptent))
			continue;

		mss->resident += PAGE_SIZE;

		page = vm_normal_page(vma, addr, ptent);
		if (!page)
			continue;

		/* Accumulate the size in pages that have been accessed. */
		if (pte_young(ptent) || PageReferenced(page))
			mss->referenced += PAGE_SIZE;
		if (page_mapcount(page) >= 2) {
			if (pte_dirty(ptent))
				mss->shared_dirty += PAGE_SIZE;
			else
				mss->shared_clean += PAGE_SIZE;
		} else {
			if (pte_dirty(ptent))
				mss->private_dirty += PAGE_SIZE;
			else
				mss->private_clean += PAGE_SIZE;
		}
	}
	pte_unmap_unlock(pte - 1, ptl);
	cond_resched();
}

static void clear_refs_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
				 unsigned long addr, unsigned long end,
				 void *private)
{
	pte_t *pte, ptent;
	spinlock_t *ptl;
	struct page *page;

	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
	for (; addr != end; pte++, addr += PAGE_SIZE) {
		ptent = *pte;
		if (!pte_present(ptent))
			continue;

		page = vm_normal_page(vma, addr, ptent);
		if (!page)
			continue;

		/* Clear accessed and referenced bits. */
		ptep_test_and_clear_young(vma, addr, pte);
		ClearPageReferenced(page);
	}
	pte_unmap_unlock(pte - 1, ptl);
	cond_resched();
}

static inline void walk_pmd_range(struct pmd_walker *walker, pud_t *pud,
				  unsigned long addr, unsigned long end)
{
	pmd_t *pmd;
	unsigned long next;

	for (pmd = pmd_offset(pud, addr); addr != end;
	     pmd++, addr = next) {
		next = pmd_addr_end(addr, end);
		if (pmd_none_or_clear_bad(pmd))
			continue;
		walker->action(walker->vma, pmd, addr, next, walker->private);
	}
}

static inline void walk_pud_range(struct pmd_walker *walker, pgd_t *pgd,
				  unsigned long addr, unsigned long end)
{
	pud_t *pud;
	unsigned long next;

	for (pud = pud_offset(pgd, addr); addr != end;
	     pud++, addr = next) {
		next = pud_addr_end(addr, end);
		if (pud_none_or_clear_bad(pud))
			continue;
		walk_pmd_range(walker, pud, addr, next);
	}
}

/*
 * walk_page_range - walk the page tables of a VMA with a callback
 * @vma - VMA to walk
 * @action - callback invoked for every bottom-level (PTE) page table
 * @private - private data passed to the callback function
 *
 * Recursively walk the page table for the memory area in a VMA, calling
 * a callback for every bottom-level (PTE) page table.
 */
static inline void walk_page_range(struct vm_area_struct *vma,
				   void (*action)(struct vm_area_struct *,
						  pmd_t *, unsigned long,
						  unsigned long, void *),
				   void *private)
{
	unsigned long addr = vma->vm_start;
	unsigned long end = vma->vm_end;
	struct pmd_walker walker = {
		.vma		= vma,
		.private	= private,
		.action		= action,
	};
	pgd_t *pgd;
	unsigned long next;

	for (pgd = pgd_offset(vma->vm_mm, addr); addr != end;
	     pgd++, addr = next) {
		next = pgd_addr_end(addr, end);
		if (pgd_none_or_clear_bad(pgd))
			continue;
		walk_pud_range(&walker, pgd, addr, next);
	}
}

static int show_smap(struct seq_file *m, void *v)
{
	struct vm_area_struct *vma = v;
	struct mem_size_stats mss;

	memset(&mss, 0, sizeof mss);
	if (vma->vm_mm && !is_vm_hugetlb_page(vma))
		walk_page_range(vma, smaps_pte_range, &mss);
	return show_map_internal(m, v, &mss);
}

void clear_refs_smap(struct mm_struct *mm)
{
	struct vm_area_struct *vma;

	down_read(&mm->mmap_sem);
	for (vma = mm->mmap; vma; vma = vma->vm_next)
		if (vma->vm_mm && !is_vm_hugetlb_page(vma))
			walk_page_range(vma, clear_refs_pte_range, NULL);
	flush_tlb_mm(mm);
	up_read(&mm->mmap_sem);
}

static void *m_start(struct seq_file *m, loff_t *pos)
{
	struct proc_maps_private *priv = m->private;
	unsigned long last_addr = m->version;
	struct mm_struct *mm;
	struct vm_area_struct *vma, *tail_vma = NULL;
	loff_t l = *pos;

	/* Clear the per syscall fields in priv */
	priv->task = NULL;
	priv->tail_vma = NULL;

	/*
	 * We remember last_addr rather than next_addr to hit with
	 * mmap_cache most of the time. We have zero last_addr at
	 * the beginning and also after lseek. We will have -1 last_addr
	 * after the end of the vmas.
	 */

	if (last_addr == -1UL)
		return NULL;

	priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
	if (!priv->task)
		return NULL;

	mm = get_task_mm(priv->task);
	if (!mm)
		return NULL;

	priv->tail_vma = tail_vma = get_gate_vma(priv->task);
	down_read(&mm->mmap_sem);

	/* Start with last addr hint */
	if (last_addr && (vma = find_vma(mm, last_addr))) {
		vma = vma->vm_next;
		goto out;
	}

	/*
	 * Check the vma index is within the range and do
	 * sequential scan until m_index.
	 */
	vma = NULL;
	if ((unsigned long)l < mm->map_count) {
		vma = mm->mmap;
		while (l-- && vma)
			vma = vma->vm_next;
		goto out;
	}

	if (l != mm->map_count)
		tail_vma = NULL; /* After gate vma */

out:
	if (vma)
		return vma;

	/* End of vmas has been reached */
	m->version = (tail_vma != NULL)? 0: -1UL;
	up_read(&mm->mmap_sem);
	mmput(mm);
	return tail_vma;
}

static void vma_stop(struct proc_maps_private *priv, struct vm_area_struct *vma)
{
	if (vma && vma != priv->tail_vma) {
		struct mm_struct *mm = vma->vm_mm;
		up_read(&mm->mmap_sem);
		mmput(mm);
	}
}

static void *m_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct proc_maps_private *priv = m->private;
	struct vm_area_struct *vma = v;
	struct vm_area_struct *tail_vma = priv->tail_vma;

	(*pos)++;
	if (vma && (vma != tail_vma) && vma->vm_next)
		return vma->vm_next;
	vma_stop(priv, vma);
	return (vma != tail_vma)? tail_vma: NULL;
}

static void m_stop(struct seq_file *m, void *v)
{
	struct proc_maps_private *priv = m->private;
	struct vm_area_struct *vma = v;

	vma_stop(priv, vma);
	if (priv->task)
		put_task_struct(priv->task);
}

static struct seq_operations proc_pid_maps_op = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_map
};

static struct seq_operations proc_pid_smaps_op = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_smap
};

static int do_maps_open(struct inode *inode, struct file *file,
			struct seq_operations *ops)
{
	struct proc_maps_private *priv;
	int ret = -ENOMEM;
	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (priv) {
		priv->pid = proc_pid(inode);
		ret = seq_open(file, ops);
		if (!ret) {
			struct seq_file *m = file->private_data;
			m->private = priv;
		} else {
			kfree(priv);
		}
	}
	return ret;
}

static int maps_open(struct inode *inode, struct file *file)
{
	return do_maps_open(inode, file, &proc_pid_maps_op);
}

const struct file_operations proc_maps_operations = {
	.open		= maps_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release_private,
};

#ifdef CONFIG_NUMA
extern int show_numa_map(struct seq_file *m, void *v);

static int show_numa_map_checked(struct seq_file *m, void *v)
{
	struct proc_maps_private *priv = m->private;
	struct task_struct *task = priv->task;

	if (maps_protect && !ptrace_may_attach(task))
		return -EACCES;

	return show_numa_map(m, v);
}

static struct seq_operations proc_pid_numa_maps_op = {
        .start  = m_start,
        .next   = m_next,
        .stop   = m_stop,
        .show   = show_numa_map_checked
};

static int numa_maps_open(struct inode *inode, struct file *file)
{
	return do_maps_open(inode, file, &proc_pid_numa_maps_op);
}

const struct file_operations proc_numa_maps_operations = {
	.open		= numa_maps_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release_private,
};
#endif

static int smaps_open(struct inode *inode, struct file *file)
{
	return do_maps_open(inode, file, &proc_pid_smaps_op);
}

const struct file_operations proc_smaps_operations = {
	.open		= smaps_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release_private,
};
Commit	Line	Data
1da177e4 LT	1	#include <linux/mm.h>
	2	#include <linux/hugetlb.h>
	3	#include <linux/mount.h>
	4	#include <linux/seq_file.h>
e070ad49	5	#include <linux/highmem.h>
5096add8	6	#include <linux/ptrace.h>
6e21c8f1 CL	7	#include <linux/pagemap.h>
6e21c8f1 CL	8	#include <linux/mempolicy.h>
e070ad49	9
1da177e4 LT	10	#include <asm/elf.h>
1da177e4 LT	11	#include <asm/uaccess.h>
e070ad49	12	#include <asm/tlbflush.h>
1da177e4 LT	13	#include "internal.h"
	14
	15	char task_mem(struct mm_struct mm, char *buffer)
	16	{
	17	unsigned long data, text, lib;
365e9c87 HD	18	unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss;
	19
	20	/*
	21	* Note: to minimize their overhead, mm maintains hiwater_vm and
	22	* hiwater_rss only when about to lower total_vm or rss. Any
	23	* collector of these hiwater stats must therefore get total_vm
	24	* and rss too, which will usually be the higher. Barriers? not
	25	* worth the effort, such snapshots can always be inconsistent.
	26	*/
	27	hiwater_vm = total_vm = mm->total_vm;
	28	if (hiwater_vm < mm->hiwater_vm)
	29	hiwater_vm = mm->hiwater_vm;
	30	hiwater_rss = total_rss = get_mm_rss(mm);
	31	if (hiwater_rss < mm->hiwater_rss)
	32	hiwater_rss = mm->hiwater_rss;
1da177e4 LT	33
	34	data = mm->total_vm - mm->shared_vm - mm->stack_vm;
	35	text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10;
	36	lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
	37	buffer += sprintf(buffer,
365e9c87	38	"VmPeak:\t%8lu kB\n"
1da177e4 LT	39	"VmSize:\t%8lu kB\n"
1da177e4 LT	40	"VmLck:\t%8lu kB\n"
365e9c87	41	"VmHWM:\t%8lu kB\n"
1da177e4 LT	42	"VmRSS:\t%8lu kB\n"
	43	"VmData:\t%8lu kB\n"
	44	"VmStk:\t%8lu kB\n"
	45	"VmExe:\t%8lu kB\n"
	46	"VmLib:\t%8lu kB\n"
	47	"VmPTE:\t%8lu kB\n",
365e9c87 HD	48	hiwater_vm << (PAGE_SHIFT-10),
365e9c87 HD	49	(total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
1da177e4	50	mm->locked_vm << (PAGE_SHIFT-10),
365e9c87 HD	51	hiwater_rss << (PAGE_SHIFT-10),
365e9c87 HD	52	total_rss << (PAGE_SHIFT-10),
1da177e4 LT	53	data << (PAGE_SHIFT-10),
	54	mm->stack_vm << (PAGE_SHIFT-10), text, lib,
	55	(PTRS_PER_PTEsizeof(pte_t)mm->nr_ptes) >> 10);
	56	return buffer;
	57	}
	58
	59	unsigned long task_vsize(struct mm_struct *mm)
	60	{
	61	return PAGE_SIZE * mm->total_vm;
	62	}
	63
	64	int task_statm(struct mm_struct mm, int shared, int *text,
	65	int data, int resident)
	66	{
4294621f	67	*shared = get_mm_counter(mm, file_rss);
1da177e4 LT	68	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
	69	>> PAGE_SHIFT;
	70	*data = mm->total_vm - mm->shared_vm;
4294621f	71	resident = shared + get_mm_counter(mm, anon_rss);
1da177e4 LT	72	return mm->total_vm;
	73	}
	74
	75	int proc_exe_link(struct inode inode, struct dentry dentry, struct vfsmount *mnt)
	76	{
	77	struct vm_area_struct * vma;
	78	int result = -ENOENT;
99f89551 EB	79	struct task_struct *task = get_proc_task(inode);
99f89551 EB	80	struct mm_struct * mm = NULL;
1da177e4	81
99f89551 EB	82	if (task) {
	83	mm = get_task_mm(task);
	84	put_task_struct(task);
	85	}
1da177e4 LT	86	if (!mm)
	87	goto out;
	88	down_read(&mm->mmap_sem);
	89
	90	vma = mm->mmap;
	91	while (vma) {
	92	if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
	93	break;
	94	vma = vma->vm_next;
	95	}
	96
	97	if (vma) {
2fddfeef JJS	98	*mnt = mntget(vma->vm_file->f_path.mnt);
2fddfeef JJS	99	*dentry = dget(vma->vm_file->f_path.dentry);
1da177e4 LT	100	result = 0;
	101	}
	102
	103	up_read(&mm->mmap_sem);
	104	mmput(mm);
	105	out:
	106	return result;
	107	}
	108
	109	static void pad_len_spaces(struct seq_file *m, int len)
	110	{
	111	len = 25 + sizeof(void) 6 - len;
	112	if (len < 1)
	113	len = 1;
	114	seq_printf(m, "%*c", len, ' ');
	115	}
	116
e070ad49 ML	117	struct mem_size_stats
	118	{
	119	unsigned long resident;
	120	unsigned long shared_clean;
	121	unsigned long shared_dirty;
	122	unsigned long private_clean;
	123	unsigned long private_dirty;
f79f177c	124	unsigned long referenced;
e070ad49 ML	125	};
e070ad49 ML	126
826fad1b DR	127	struct pmd_walker {
	128	struct vm_area_struct *vma;
	129	void *private;
	130	void (action)(struct vm_area_struct , pmd_t *, unsigned long,
	131	unsigned long, void *);
	132	};
	133
e070ad49	134	static int show_map_internal(struct seq_file m, void v, struct mem_size_stats *mss)
1da177e4	135	{
99f89551 EB	136	struct proc_maps_private *priv = m->private;
99f89551 EB	137	struct task_struct *task = priv->task;
e070ad49 ML	138	struct vm_area_struct *vma = v;
	139	struct mm_struct *mm = vma->vm_mm;
	140	struct file *file = vma->vm_file;
	141	int flags = vma->vm_flags;
1da177e4 LT	142	unsigned long ino = 0;
	143	dev_t dev = 0;
	144	int len;
	145
5096add8 KC	146	if (maps_protect && !ptrace_may_attach(task))
	147	return -EACCES;
	148
1da177e4	149	if (file) {
2fddfeef	150	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
1da177e4 LT	151	dev = inode->i_sb->s_dev;
	152	ino = inode->i_ino;
	153	}
	154
	155	seq_printf(m, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
e070ad49 ML	156	vma->vm_start,
e070ad49 ML	157	vma->vm_end,
1da177e4 LT	158	flags & VM_READ ? 'r' : '-',
	159	flags & VM_WRITE ? 'w' : '-',
	160	flags & VM_EXEC ? 'x' : '-',
	161	flags & VM_MAYSHARE ? 's' : 'p',
e070ad49	162	vma->vm_pgoff << PAGE_SHIFT,
1da177e4 LT	163	MAJOR(dev), MINOR(dev), ino, &len);
	164
	165	/*
	166	* Print the dentry name for named mappings, and a
	167	* special [heap] marker for the heap:
	168	*/
e070ad49	169	if (file) {
1da177e4	170	pad_len_spaces(m, len);
2fddfeef	171	seq_path(m, file->f_path.mnt, file->f_path.dentry, "\n");
1da177e4	172	} else {
e6e5494c IM	173	const char *name = arch_vma_name(vma);
	174	if (!name) {
	175	if (mm) {
	176	if (vma->vm_start <= mm->start_brk &&
e070ad49	177	vma->vm_end >= mm->brk) {
e6e5494c IM	178	name = "[heap]";
	179	} else if (vma->vm_start <= mm->start_stack &&
	180	vma->vm_end >= mm->start_stack) {
	181	name = "[stack]";
1da177e4	182	}
e6e5494c IM	183	} else {
e6e5494c IM	184	name = "[vdso]";
1da177e4	185	}
e6e5494c IM	186	}
e6e5494c IM	187	if (name) {
1da177e4	188	pad_len_spaces(m, len);
e6e5494c	189	seq_puts(m, name);
1da177e4 LT	190	}
	191	}
	192	seq_putc(m, '\n');
e070ad49 ML	193
	194	if (mss)
	195	seq_printf(m,
f79f177c DR	196	"Size: %8lu kB\n"
	197	"Rss: %8lu kB\n"
	198	"Shared_Clean: %8lu kB\n"
	199	"Shared_Dirty: %8lu kB\n"
	200	"Private_Clean: %8lu kB\n"
	201	"Private_Dirty: %8lu kB\n"
b813e931	202	"Referenced: %8lu kB\n",
e070ad49 ML	203	(vma->vm_end - vma->vm_start) >> 10,
	204	mss->resident >> 10,
	205	mss->shared_clean >> 10,
	206	mss->shared_dirty >> 10,
	207	mss->private_clean >> 10,
f79f177c DR	208	mss->private_dirty >> 10,
f79f177c DR	209	mss->referenced >> 10);
e070ad49 ML	210
	211	if (m->count < m->size) /* vma is copied successfully */
	212	m->version = (vma != get_gate_vma(task))? vma->vm_start: 0;
1da177e4 LT	213	return 0;
	214	}
	215
e070ad49 ML	216	static int show_map(struct seq_file m, void v)
e070ad49 ML	217	{
0f5c79f2	218	return show_map_internal(m, v, NULL);
e070ad49 ML	219	}
e070ad49 ML	220
b813e931 DR	221	static void smaps_pte_range(struct vm_area_struct vma, pmd_t pmd,
	222	unsigned long addr, unsigned long end,
	223	void *private)
e070ad49	224	{
826fad1b	225	struct mem_size_stats *mss = private;
e070ad49	226	pte_t *pte, ptent;
705e87c0	227	spinlock_t *ptl;
e070ad49 ML	228	struct page *page;
e070ad49 ML	229
705e87c0	230	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
826fad1b	231	for (; addr != end; pte++, addr += PAGE_SIZE) {
e070ad49	232	ptent = *pte;
705e87c0	233	if (!pte_present(ptent))
e070ad49 ML	234	continue;
	235
	236	mss->resident += PAGE_SIZE;
ad820c5d NP	237
	238	page = vm_normal_page(vma, addr, ptent);
	239	if (!page)
e070ad49 ML	240	continue;
e070ad49 ML	241
f79f177c DR	242	/* Accumulate the size in pages that have been accessed. */
	243	if (pte_young(ptent) \|\| PageReferenced(page))
	244	mss->referenced += PAGE_SIZE;
ad820c5d	245	if (page_mapcount(page) >= 2) {
e070ad49 ML	246	if (pte_dirty(ptent))
	247	mss->shared_dirty += PAGE_SIZE;
	248	else
	249	mss->shared_clean += PAGE_SIZE;
	250	} else {
	251	if (pte_dirty(ptent))
	252	mss->private_dirty += PAGE_SIZE;
	253	else
	254	mss->private_clean += PAGE_SIZE;
	255	}
826fad1b	256	}
705e87c0 HD	257	pte_unmap_unlock(pte - 1, ptl);
705e87c0 HD	258	cond_resched();
e070ad49 ML	259	}
e070ad49 ML	260
b813e931 DR	261	static void clear_refs_pte_range(struct vm_area_struct vma, pmd_t pmd,
	262	unsigned long addr, unsigned long end,
	263	void *private)
	264	{
	265	pte_t *pte, ptent;
	266	spinlock_t *ptl;
	267	struct page *page;
	268
	269	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
	270	for (; addr != end; pte++, addr += PAGE_SIZE) {
	271	ptent = *pte;
	272	if (!pte_present(ptent))
	273	continue;
	274
	275	page = vm_normal_page(vma, addr, ptent);
	276	if (!page)
	277	continue;
	278
	279	/* Clear accessed and referenced bits. */
	280	ptep_test_and_clear_young(vma, addr, pte);
	281	ClearPageReferenced(page);
	282	}
	283	pte_unmap_unlock(pte - 1, ptl);
	284	cond_resched();
	285	}
	286
	287	static inline void walk_pmd_range(struct pmd_walker walker, pud_t pud,
	288	unsigned long addr, unsigned long end)
e070ad49 ML	289	{
	290	pmd_t *pmd;
	291	unsigned long next;
	292
826fad1b DR	293	for (pmd = pmd_offset(pud, addr); addr != end;
826fad1b DR	294	pmd++, addr = next) {
e070ad49 ML	295	next = pmd_addr_end(addr, end);
	296	if (pmd_none_or_clear_bad(pmd))
	297	continue;
826fad1b DR	298	walker->action(walker->vma, pmd, addr, next, walker->private);
826fad1b DR	299	}
e070ad49 ML	300	}
e070ad49 ML	301
b813e931 DR	302	static inline void walk_pud_range(struct pmd_walker walker, pgd_t pgd,
b813e931 DR	303	unsigned long addr, unsigned long end)
e070ad49 ML	304	{
	305	pud_t *pud;
	306	unsigned long next;
	307
826fad1b DR	308	for (pud = pud_offset(pgd, addr); addr != end;
826fad1b DR	309	pud++, addr = next) {
e070ad49 ML	310	next = pud_addr_end(addr, end);
	311	if (pud_none_or_clear_bad(pud))
	312	continue;
b813e931	313	walk_pmd_range(walker, pud, addr, next);
826fad1b	314	}
e070ad49 ML	315	}
e070ad49 ML	316
b813e931 DR	317	/*
	318	* walk_page_range - walk the page tables of a VMA with a callback
	319	* @vma - VMA to walk
	320	* @action - callback invoked for every bottom-level (PTE) page table
	321	* @private - private data passed to the callback function
	322	*
	323	* Recursively walk the page table for the memory area in a VMA, calling
	324	* a callback for every bottom-level (PTE) page table.
	325	*/
	326	static inline void walk_page_range(struct vm_area_struct *vma,
	327	void (action)(struct vm_area_struct ,
	328	pmd_t *, unsigned long,
	329	unsigned long, void *),
	330	void *private)
e070ad49	331	{
826fad1b DR	332	unsigned long addr = vma->vm_start;
	333	unsigned long end = vma->vm_end;
	334	struct pmd_walker walker = {
	335	.vma = vma,
	336	.private = private,
	337	.action = action,
	338	};
e070ad49 ML	339	pgd_t *pgd;
	340	unsigned long next;
	341
826fad1b DR	342	for (pgd = pgd_offset(vma->vm_mm, addr); addr != end;
826fad1b DR	343	pgd++, addr = next) {
e070ad49 ML	344	next = pgd_addr_end(addr, end);
	345	if (pgd_none_or_clear_bad(pgd))
	346	continue;
b813e931	347	walk_pud_range(&walker, pgd, addr, next);
826fad1b	348	}
e070ad49 ML	349	}
	350
	351	static int show_smap(struct seq_file m, void v)
	352	{
	353	struct vm_area_struct *vma = v;
e070ad49 ML	354	struct mem_size_stats mss;
	355
	356	memset(&mss, 0, sizeof mss);
5ddfae16	357	if (vma->vm_mm && !is_vm_hugetlb_page(vma))
b813e931	358	walk_page_range(vma, smaps_pte_range, &mss);
e070ad49 ML	359	return show_map_internal(m, v, &mss);
	360	}
	361
b813e931 DR	362	void clear_refs_smap(struct mm_struct *mm)
	363	{
	364	struct vm_area_struct *vma;
	365
	366	down_read(&mm->mmap_sem);
	367	for (vma = mm->mmap; vma; vma = vma->vm_next)
	368	if (vma->vm_mm && !is_vm_hugetlb_page(vma))
	369	walk_page_range(vma, clear_refs_pte_range, NULL);
	370	flush_tlb_mm(mm);
	371	up_read(&mm->mmap_sem);
	372	}
	373
1da177e4 LT	374	static void m_start(struct seq_file m, loff_t *pos)
1da177e4 LT	375	{
99f89551	376	struct proc_maps_private *priv = m->private;
1da177e4 LT	377	unsigned long last_addr = m->version;
1da177e4 LT	378	struct mm_struct *mm;
99f89551	379	struct vm_area_struct vma, tail_vma = NULL;
1da177e4 LT	380	loff_t l = *pos;
1da177e4 LT	381
99f89551 EB	382	/* Clear the per syscall fields in priv */
	383	priv->task = NULL;
	384	priv->tail_vma = NULL;
	385
1da177e4 LT	386	/*
	387	* We remember last_addr rather than next_addr to hit with
	388	* mmap_cache most of the time. We have zero last_addr at
e070ad49 ML	389	* the beginning and also after lseek. We will have -1 last_addr
e070ad49 ML	390	* after the end of the vmas.
1da177e4 LT	391	*/
	392
	393	if (last_addr == -1UL)
	394	return NULL;
	395
13b41b09	396	priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
99f89551 EB	397	if (!priv->task)
	398	return NULL;
	399
	400	mm = get_task_mm(priv->task);
1da177e4 LT	401	if (!mm)
	402	return NULL;
	403
99f89551	404	priv->tail_vma = tail_vma = get_gate_vma(priv->task);
1da177e4 LT	405	down_read(&mm->mmap_sem);
	406
	407	/* Start with last addr hint */
e070ad49 ML	408	if (last_addr && (vma = find_vma(mm, last_addr))) {
e070ad49 ML	409	vma = vma->vm_next;
1da177e4 LT	410	goto out;
	411	}
	412
	413	/*
e070ad49	414	* Check the vma index is within the range and do
1da177e4 LT	415	* sequential scan until m_index.
1da177e4 LT	416	*/
e070ad49	417	vma = NULL;
1da177e4	418	if ((unsigned long)l < mm->map_count) {
e070ad49 ML	419	vma = mm->mmap;
	420	while (l-- && vma)
	421	vma = vma->vm_next;
1da177e4 LT	422	goto out;
	423	}
	424
	425	if (l != mm->map_count)
e070ad49	426	tail_vma = NULL; /* After gate vma */
1da177e4 LT	427
1da177e4 LT	428	out:
e070ad49 ML	429	if (vma)
e070ad49 ML	430	return vma;
1da177e4	431
e070ad49 ML	432	/* End of vmas has been reached */
e070ad49 ML	433	m->version = (tail_vma != NULL)? 0: -1UL;
1da177e4 LT	434	up_read(&mm->mmap_sem);
1da177e4 LT	435	mmput(mm);
e070ad49	436	return tail_vma;
1da177e4 LT	437	}
1da177e4 LT	438
99f89551	439	static void vma_stop(struct proc_maps_private priv, struct vm_area_struct vma)
1da177e4	440	{
99f89551	441	if (vma && vma != priv->tail_vma) {
e070ad49	442	struct mm_struct *mm = vma->vm_mm;
1da177e4 LT	443	up_read(&mm->mmap_sem);
	444	mmput(mm);
	445	}
	446	}
	447
	448	static void m_next(struct seq_file m, void v, loff_t pos)
	449	{
99f89551	450	struct proc_maps_private *priv = m->private;
e070ad49	451	struct vm_area_struct *vma = v;
99f89551	452	struct vm_area_struct *tail_vma = priv->tail_vma;
1da177e4 LT	453
1da177e4 LT	454	(*pos)++;
e070ad49 ML	455	if (vma && (vma != tail_vma) && vma->vm_next)
e070ad49 ML	456	return vma->vm_next;
99f89551	457	vma_stop(priv, vma);
e070ad49	458	return (vma != tail_vma)? tail_vma: NULL;
1da177e4 LT	459	}
1da177e4 LT	460
99f89551 EB	461	static void m_stop(struct seq_file m, void v)
	462	{
	463	struct proc_maps_private *priv = m->private;
	464	struct vm_area_struct *vma = v;
	465
	466	vma_stop(priv, vma);
	467	if (priv->task)
	468	put_task_struct(priv->task);
	469	}
	470
662795de	471	static struct seq_operations proc_pid_maps_op = {
1da177e4 LT	472	.start = m_start,
	473	.next = m_next,
	474	.stop = m_stop,
	475	.show = show_map
	476	};
6e21c8f1	477
662795de	478	static struct seq_operations proc_pid_smaps_op = {
e070ad49 ML	479	.start = m_start,
	480	.next = m_next,
	481	.stop = m_stop,
	482	.show = show_smap
	483	};
	484
662795de EB	485	static int do_maps_open(struct inode inode, struct file file,
	486	struct seq_operations *ops)
	487	{
99f89551 EB	488	struct proc_maps_private *priv;
	489	int ret = -ENOMEM;
	490	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	491	if (priv) {
13b41b09	492	priv->pid = proc_pid(inode);
99f89551 EB	493	ret = seq_open(file, ops);
	494	if (!ret) {
	495	struct seq_file *m = file->private_data;
	496	m->private = priv;
	497	} else {
	498	kfree(priv);
	499	}
662795de EB	500	}
	501	return ret;
	502	}
	503
	504	static int maps_open(struct inode inode, struct file file)
	505	{
	506	return do_maps_open(inode, file, &proc_pid_maps_op);
	507	}
	508
00977a59	509	const struct file_operations proc_maps_operations = {
662795de EB	510	.open = maps_open,
	511	.read = seq_read,
	512	.llseek = seq_lseek,
99f89551	513	.release = seq_release_private,
662795de EB	514	};
662795de EB	515
6e21c8f1	516	#ifdef CONFIG_NUMA
1a75a6c8	517	extern int show_numa_map(struct seq_file m, void v);
6e21c8f1	518
5096add8 KC	519	static int show_numa_map_checked(struct seq_file m, void v)
	520	{
	521	struct proc_maps_private *priv = m->private;
	522	struct task_struct *task = priv->task;
	523
	524	if (maps_protect && !ptrace_may_attach(task))
	525	return -EACCES;
	526
	527	return show_numa_map(m, v);
	528	}
	529
662795de	530	static struct seq_operations proc_pid_numa_maps_op = {
1a75a6c8 CL	531	.start = m_start,
	532	.next = m_next,
	533	.stop = m_stop,
5096add8	534	.show = show_numa_map_checked
6e21c8f1	535	};
662795de EB	536
	537	static int numa_maps_open(struct inode inode, struct file file)
	538	{
	539	return do_maps_open(inode, file, &proc_pid_numa_maps_op);
	540	}
	541
00977a59	542	const struct file_operations proc_numa_maps_operations = {
662795de EB	543	.open = numa_maps_open,
	544	.read = seq_read,
	545	.llseek = seq_lseek,
99f89551	546	.release = seq_release_private,
662795de	547	};
6e21c8f1	548	#endif
662795de EB	549
	550	static int smaps_open(struct inode inode, struct file file)
	551	{
	552	return do_maps_open(inode, file, &proc_pid_smaps_op);
	553	}
	554
00977a59	555	const struct file_operations proc_smaps_operations = {
662795de EB	556	.open = smaps_open,
	557	.read = seq_read,
	558	.llseek = seq_lseek,
99f89551	559	.release = seq_release_private,
662795de	560	};