[deliverable/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/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 = proc_task(inode);
	struct mm_struct * mm = get_task_mm(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_vfsmnt);
		*dentry = dget(vma->vm_file->f_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;
};

static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats *mss)
{
	struct task_struct *task = m->private;
	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 (file) {
		struct inode *inode = vma->vm_file->f_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_vfsmnt, file->f_dentry, "\n");
	} else {
		if (mm) {
			if (vma->vm_start <= mm->start_brk &&
						vma->vm_end >= mm->brk) {
				pad_len_spaces(m, len);
				seq_puts(m, "[heap]");
			} else {
				if (vma->vm_start <= mm->start_stack &&
					vma->vm_end >= mm->start_stack) {

					pad_len_spaces(m, len);
					seq_puts(m, "[stack]");
				}
			}
		} else {
			pad_len_spaces(m, len);
			seq_puts(m, "[vdso]");
		}
	}
	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",
			   (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);

	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, 0);
}

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

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

		mss->resident += PAGE_SIZE;
		pfn = pte_pfn(ptent);
		if (!pfn_valid(pfn))
			continue;

		page = pfn_to_page(pfn);
		if (page_count(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;
		}
	} while (pte++, addr += PAGE_SIZE, addr != end);
	pte_unmap_unlock(pte - 1, ptl);
	cond_resched();
}

static inline void smaps_pmd_range(struct vm_area_struct *vma, pud_t *pud,
				unsigned long addr, unsigned long end,
				struct mem_size_stats *mss)
{
	pmd_t *pmd;
	unsigned long next;

	pmd = pmd_offset(pud, addr);
	do {
		next = pmd_addr_end(addr, end);
		if (pmd_none_or_clear_bad(pmd))
			continue;
		smaps_pte_range(vma, pmd, addr, next, mss);
	} while (pmd++, addr = next, addr != end);
}

static inline void smaps_pud_range(struct vm_area_struct *vma, pgd_t *pgd,
				unsigned long addr, unsigned long end,
				struct mem_size_stats *mss)
{
	pud_t *pud;
	unsigned long next;

	pud = pud_offset(pgd, addr);
	do {
		next = pud_addr_end(addr, end);
		if (pud_none_or_clear_bad(pud))
			continue;
		smaps_pmd_range(vma, pud, addr, next, mss);
	} while (pud++, addr = next, addr != end);
}

static inline void smaps_pgd_range(struct vm_area_struct *vma,
				unsigned long addr, unsigned long end,
				struct mem_size_stats *mss)
{
	pgd_t *pgd;
	unsigned long next;

	pgd = pgd_offset(vma->vm_mm, addr);
	do {
		next = pgd_addr_end(addr, end);
		if (pgd_none_or_clear_bad(pgd))
			continue;
		smaps_pud_range(vma, pgd, addr, next, mss);
	} while (pgd++, addr = next, addr != end);
}

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)
		smaps_pgd_range(vma, vma->vm_start, vma->vm_end, &mss);
	return show_map_internal(m, v, &mss);
}

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

	/*
	 * 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;

	mm = get_task_mm(task);
	if (!mm)
		return NULL;

	tail_vma = get_gate_vma(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 m_stop(struct seq_file *m, void *v)
{
	struct task_struct *task = m->private;
	struct vm_area_struct *vma = v;
	if (vma && vma != get_gate_vma(task)) {
		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 task_struct *task = m->private;
	struct vm_area_struct *vma = v;
	struct vm_area_struct *tail_vma = get_gate_vma(task);

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

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

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

#ifdef CONFIG_NUMA

struct numa_maps {
	unsigned long pages;
	unsigned long anon;
	unsigned long mapped;
	unsigned long mapcount_max;
	unsigned long node[MAX_NUMNODES];
};

/*
 * Calculate numa node maps for a vma
 */
static struct numa_maps *get_numa_maps(const struct vm_area_struct *vma)
{
	struct page *page;
	unsigned long vaddr;
	struct mm_struct *mm = vma->vm_mm;
	int i;
	struct numa_maps *md = kmalloc(sizeof(struct numa_maps), GFP_KERNEL);

	if (!md)
		return NULL;
	md->pages = 0;
	md->anon = 0;
	md->mapped = 0;
	md->mapcount_max = 0;
	for_each_node(i)
		md->node[i] =0;

 	for (vaddr = vma->vm_start; vaddr < vma->vm_end; vaddr += PAGE_SIZE) {
		page = follow_page(mm, vaddr, 0);
		if (page) {
			int count = page_mapcount(page);

			if (count)
				md->mapped++;
			if (count > md->mapcount_max)
				md->mapcount_max = count;
			md->pages++;
			if (PageAnon(page))
				md->anon++;
			md->node[page_to_nid(page)]++;
		}
		cond_resched();
	}
	return md;
}

static int show_numa_map(struct seq_file *m, void *v)
{
	struct task_struct *task = m->private;
	struct vm_area_struct *vma = v;
	struct mempolicy *pol;
	struct numa_maps *md;
	struct zone **z;
	int n;
	int first;

	if (!vma->vm_mm)
		return 0;

	md = get_numa_maps(vma);
	if (!md)
		return 0;

	seq_printf(m, "%08lx", vma->vm_start);
	pol = get_vma_policy(task, vma, vma->vm_start);
	/* Print policy */
	switch (pol->policy) {
	case MPOL_PREFERRED:
		seq_printf(m, " prefer=%d", pol->v.preferred_node);
		break;
	case MPOL_BIND:
		seq_printf(m, " bind={");
		first = 1;
		for (z = pol->v.zonelist->zones; *z; z++) {

			if (!first)
				seq_putc(m, ',');
			else
				first = 0;
			seq_printf(m, "%d/%s", (*z)->zone_pgdat->node_id,
					(*z)->name);
		}
		seq_putc(m, '}');
		break;
	case MPOL_INTERLEAVE:
		seq_printf(m, " interleave={");
		first = 1;
		for_each_node(n) {
			if (node_isset(n, pol->v.nodes)) {
				if (!first)
					seq_putc(m,',');
				else
					first = 0;
				seq_printf(m, "%d",n);
			}
		}
		seq_putc(m, '}');
		break;
	default:
		seq_printf(m," default");
		break;
	}
	seq_printf(m, " MaxRef=%lu Pages=%lu Mapped=%lu",
			md->mapcount_max, md->pages, md->mapped);
	if (md->anon)
		seq_printf(m," Anon=%lu",md->anon);

	for_each_online_node(n) {
		if (md->node[n])
			seq_printf(m, " N%d=%lu", n, md->node[n]);
	}
	seq_putc(m, '\n');
	kfree(md);
	if (m->count < m->size)  /* vma is copied successfully */
		m->version = (vma != get_gate_vma(task)) ? vma->vm_start : 0;
	return 0;
}

struct seq_operations proc_pid_numa_maps_op = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_numa_map
};
#endif
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>
6e21c8f1 CL	6	#include <linux/pagemap.h>
6e21c8f1 CL	7	#include <linux/mempolicy.h>
e070ad49	8
1da177e4 LT	9	#include <asm/elf.h>
1da177e4 LT	10	#include <asm/uaccess.h>
e070ad49	11	#include <asm/tlbflush.h>
1da177e4 LT	12	#include "internal.h"
	13
	14	char task_mem(struct mm_struct mm, char *buffer)
	15	{
	16	unsigned long data, text, lib;
365e9c87 HD	17	unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss;
	18
	19	/*
	20	* Note: to minimize their overhead, mm maintains hiwater_vm and
	21	* hiwater_rss only when about to lower total_vm or rss. Any
	22	* collector of these hiwater stats must therefore get total_vm
	23	* and rss too, which will usually be the higher. Barriers? not
	24	* worth the effort, such snapshots can always be inconsistent.
	25	*/
	26	hiwater_vm = total_vm = mm->total_vm;
	27	if (hiwater_vm < mm->hiwater_vm)
	28	hiwater_vm = mm->hiwater_vm;
	29	hiwater_rss = total_rss = get_mm_rss(mm);
	30	if (hiwater_rss < mm->hiwater_rss)
	31	hiwater_rss = mm->hiwater_rss;
1da177e4 LT	32
	33	data = mm->total_vm - mm->shared_vm - mm->stack_vm;
	34	text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10;
	35	lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
	36	buffer += sprintf(buffer,
365e9c87	37	"VmPeak:\t%8lu kB\n"
1da177e4 LT	38	"VmSize:\t%8lu kB\n"
1da177e4 LT	39	"VmLck:\t%8lu kB\n"
365e9c87	40	"VmHWM:\t%8lu kB\n"
1da177e4 LT	41	"VmRSS:\t%8lu kB\n"
	42	"VmData:\t%8lu kB\n"
	43	"VmStk:\t%8lu kB\n"
	44	"VmExe:\t%8lu kB\n"
	45	"VmLib:\t%8lu kB\n"
	46	"VmPTE:\t%8lu kB\n",
365e9c87 HD	47	hiwater_vm << (PAGE_SHIFT-10),
365e9c87 HD	48	(total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
1da177e4	49	mm->locked_vm << (PAGE_SHIFT-10),
365e9c87 HD	50	hiwater_rss << (PAGE_SHIFT-10),
365e9c87 HD	51	total_rss << (PAGE_SHIFT-10),
1da177e4 LT	52	data << (PAGE_SHIFT-10),
	53	mm->stack_vm << (PAGE_SHIFT-10), text, lib,
	54	(PTRS_PER_PTEsizeof(pte_t)mm->nr_ptes) >> 10);
	55	return buffer;
	56	}
	57
	58	unsigned long task_vsize(struct mm_struct *mm)
	59	{
	60	return PAGE_SIZE * mm->total_vm;
	61	}
	62
	63	int task_statm(struct mm_struct mm, int shared, int *text,
	64	int data, int resident)
	65	{
4294621f	66	*shared = get_mm_counter(mm, file_rss);
1da177e4 LT	67	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
	68	>> PAGE_SHIFT;
	69	*data = mm->total_vm - mm->shared_vm;
4294621f	70	resident = shared + get_mm_counter(mm, anon_rss);
1da177e4 LT	71	return mm->total_vm;
	72	}
	73
	74	int proc_exe_link(struct inode inode, struct dentry dentry, struct vfsmount *mnt)
	75	{
	76	struct vm_area_struct * vma;
	77	int result = -ENOENT;
	78	struct task_struct *task = proc_task(inode);
	79	struct mm_struct * mm = get_task_mm(task);
	80
	81	if (!mm)
	82	goto out;
	83	down_read(&mm->mmap_sem);
	84
	85	vma = mm->mmap;
	86	while (vma) {
	87	if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
	88	break;
	89	vma = vma->vm_next;
	90	}
	91
	92	if (vma) {
	93	*mnt = mntget(vma->vm_file->f_vfsmnt);
	94	*dentry = dget(vma->vm_file->f_dentry);
	95	result = 0;
	96	}
	97
	98	up_read(&mm->mmap_sem);
	99	mmput(mm);
	100	out:
	101	return result;
	102	}
	103
	104	static void pad_len_spaces(struct seq_file *m, int len)
	105	{
	106	len = 25 + sizeof(void) 6 - len;
	107	if (len < 1)
	108	len = 1;
	109	seq_printf(m, "%*c", len, ' ');
	110	}
	111
e070ad49 ML	112	struct mem_size_stats
	113	{
	114	unsigned long resident;
	115	unsigned long shared_clean;
	116	unsigned long shared_dirty;
	117	unsigned long private_clean;
	118	unsigned long private_dirty;
	119	};
	120
	121	static int show_map_internal(struct seq_file m, void v, struct mem_size_stats *mss)
1da177e4 LT	122	{
1da177e4 LT	123	struct task_struct *task = m->private;
e070ad49 ML	124	struct vm_area_struct *vma = v;
	125	struct mm_struct *mm = vma->vm_mm;
	126	struct file *file = vma->vm_file;
	127	int flags = vma->vm_flags;
1da177e4 LT	128	unsigned long ino = 0;
	129	dev_t dev = 0;
	130	int len;
	131
	132	if (file) {
e070ad49	133	struct inode *inode = vma->vm_file->f_dentry->d_inode;
1da177e4 LT	134	dev = inode->i_sb->s_dev;
	135	ino = inode->i_ino;
	136	}
	137
	138	seq_printf(m, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
e070ad49 ML	139	vma->vm_start,
e070ad49 ML	140	vma->vm_end,
1da177e4 LT	141	flags & VM_READ ? 'r' : '-',
	142	flags & VM_WRITE ? 'w' : '-',
	143	flags & VM_EXEC ? 'x' : '-',
	144	flags & VM_MAYSHARE ? 's' : 'p',
e070ad49	145	vma->vm_pgoff << PAGE_SHIFT,
1da177e4 LT	146	MAJOR(dev), MINOR(dev), ino, &len);
	147
	148	/*
	149	* Print the dentry name for named mappings, and a
	150	* special [heap] marker for the heap:
	151	*/
e070ad49	152	if (file) {
1da177e4	153	pad_len_spaces(m, len);
e070ad49	154	seq_path(m, file->f_vfsmnt, file->f_dentry, "\n");
1da177e4 LT	155	} else {
1da177e4 LT	156	if (mm) {
e070ad49 ML	157	if (vma->vm_start <= mm->start_brk &&
e070ad49 ML	158	vma->vm_end >= mm->brk) {
1da177e4 LT	159	pad_len_spaces(m, len);
	160	seq_puts(m, "[heap]");
	161	} else {
e070ad49 ML	162	if (vma->vm_start <= mm->start_stack &&
e070ad49 ML	163	vma->vm_end >= mm->start_stack) {
1da177e4 LT	164
	165	pad_len_spaces(m, len);
	166	seq_puts(m, "[stack]");
	167	}
	168	}
	169	} else {
	170	pad_len_spaces(m, len);
	171	seq_puts(m, "[vdso]");
	172	}
	173	}
	174	seq_putc(m, '\n');
e070ad49 ML	175
	176	if (mss)
	177	seq_printf(m,
	178	"Size: %8lu kB\n"
	179	"Rss: %8lu kB\n"
	180	"Shared_Clean: %8lu kB\n"
	181	"Shared_Dirty: %8lu kB\n"
	182	"Private_Clean: %8lu kB\n"
	183	"Private_Dirty: %8lu kB\n",
	184	(vma->vm_end - vma->vm_start) >> 10,
	185	mss->resident >> 10,
	186	mss->shared_clean >> 10,
	187	mss->shared_dirty >> 10,
	188	mss->private_clean >> 10,
	189	mss->private_dirty >> 10);
	190
	191	if (m->count < m->size) /* vma is copied successfully */
	192	m->version = (vma != get_gate_vma(task))? vma->vm_start: 0;
1da177e4 LT	193	return 0;
	194	}
	195
e070ad49 ML	196	static int show_map(struct seq_file m, void v)
	197	{
	198	return show_map_internal(m, v, 0);
	199	}
	200
	201	static void smaps_pte_range(struct vm_area_struct vma, pmd_t pmd,
	202	unsigned long addr, unsigned long end,
	203	struct mem_size_stats *mss)
	204	{
	205	pte_t *pte, ptent;
705e87c0	206	spinlock_t *ptl;
e070ad49 ML	207	unsigned long pfn;
	208	struct page *page;
	209
705e87c0	210	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
e070ad49 ML	211	do {
e070ad49 ML	212	ptent = *pte;
705e87c0	213	if (!pte_present(ptent))
e070ad49 ML	214	continue;
	215
	216	mss->resident += PAGE_SIZE;
	217	pfn = pte_pfn(ptent);
	218	if (!pfn_valid(pfn))
	219	continue;
	220
	221	page = pfn_to_page(pfn);
	222	if (page_count(page) >= 2) {
	223	if (pte_dirty(ptent))
	224	mss->shared_dirty += PAGE_SIZE;
	225	else
	226	mss->shared_clean += PAGE_SIZE;
	227	} else {
	228	if (pte_dirty(ptent))
	229	mss->private_dirty += PAGE_SIZE;
	230	else
	231	mss->private_clean += PAGE_SIZE;
	232	}
	233	} while (pte++, addr += PAGE_SIZE, addr != end);
705e87c0 HD	234	pte_unmap_unlock(pte - 1, ptl);
705e87c0 HD	235	cond_resched();
e070ad49 ML	236	}
	237
	238	static inline void smaps_pmd_range(struct vm_area_struct vma, pud_t pud,
	239	unsigned long addr, unsigned long end,
	240	struct mem_size_stats *mss)
	241	{
	242	pmd_t *pmd;
	243	unsigned long next;
	244
	245	pmd = pmd_offset(pud, addr);
	246	do {
	247	next = pmd_addr_end(addr, end);
	248	if (pmd_none_or_clear_bad(pmd))
	249	continue;
	250	smaps_pte_range(vma, pmd, addr, next, mss);
	251	} while (pmd++, addr = next, addr != end);
	252	}
	253
	254	static inline void smaps_pud_range(struct vm_area_struct vma, pgd_t pgd,
	255	unsigned long addr, unsigned long end,
	256	struct mem_size_stats *mss)
	257	{
	258	pud_t *pud;
	259	unsigned long next;
	260
	261	pud = pud_offset(pgd, addr);
	262	do {
	263	next = pud_addr_end(addr, end);
	264	if (pud_none_or_clear_bad(pud))
	265	continue;
	266	smaps_pmd_range(vma, pud, addr, next, mss);
	267	} while (pud++, addr = next, addr != end);
	268	}
	269
	270	static inline void smaps_pgd_range(struct vm_area_struct *vma,
	271	unsigned long addr, unsigned long end,
	272	struct mem_size_stats *mss)
	273	{
	274	pgd_t *pgd;
	275	unsigned long next;
	276
	277	pgd = pgd_offset(vma->vm_mm, addr);
	278	do {
	279	next = pgd_addr_end(addr, end);
	280	if (pgd_none_or_clear_bad(pgd))
	281	continue;
	282	smaps_pud_range(vma, pgd, addr, next, mss);
	283	} while (pgd++, addr = next, addr != end);
	284	}
	285
	286	static int show_smap(struct seq_file m, void v)
	287	{
	288	struct vm_area_struct *vma = v;
e070ad49 ML	289	struct mem_size_stats mss;
	290
	291	memset(&mss, 0, sizeof mss);
705e87c0	292	if (vma->vm_mm)
e070ad49	293	smaps_pgd_range(vma, vma->vm_start, vma->vm_end, &mss);
e070ad49 ML	294	return show_map_internal(m, v, &mss);
	295	}
	296
1da177e4 LT	297	static void m_start(struct seq_file m, loff_t *pos)
	298	{
	299	struct task_struct *task = m->private;
	300	unsigned long last_addr = m->version;
	301	struct mm_struct *mm;
e070ad49	302	struct vm_area_struct vma, tail_vma;
1da177e4 LT	303	loff_t l = *pos;
	304
	305	/*
	306	* We remember last_addr rather than next_addr to hit with
	307	* mmap_cache most of the time. We have zero last_addr at
e070ad49 ML	308	* the beginning and also after lseek. We will have -1 last_addr
e070ad49 ML	309	* after the end of the vmas.
1da177e4 LT	310	*/
	311
	312	if (last_addr == -1UL)
	313	return NULL;
	314
	315	mm = get_task_mm(task);
	316	if (!mm)
	317	return NULL;
	318
e070ad49	319	tail_vma = get_gate_vma(task);
1da177e4 LT	320	down_read(&mm->mmap_sem);
	321
	322	/* Start with last addr hint */
e070ad49 ML	323	if (last_addr && (vma = find_vma(mm, last_addr))) {
e070ad49 ML	324	vma = vma->vm_next;
1da177e4 LT	325	goto out;
	326	}
	327
	328	/*
e070ad49	329	* Check the vma index is within the range and do
1da177e4 LT	330	* sequential scan until m_index.
1da177e4 LT	331	*/
e070ad49	332	vma = NULL;
1da177e4	333	if ((unsigned long)l < mm->map_count) {
e070ad49 ML	334	vma = mm->mmap;
	335	while (l-- && vma)
	336	vma = vma->vm_next;
1da177e4 LT	337	goto out;
	338	}
	339
	340	if (l != mm->map_count)
e070ad49	341	tail_vma = NULL; /* After gate vma */
1da177e4 LT	342
1da177e4 LT	343	out:
e070ad49 ML	344	if (vma)
e070ad49 ML	345	return vma;
1da177e4	346
e070ad49 ML	347	/* End of vmas has been reached */
e070ad49 ML	348	m->version = (tail_vma != NULL)? 0: -1UL;
1da177e4 LT	349	up_read(&mm->mmap_sem);
1da177e4 LT	350	mmput(mm);
e070ad49	351	return tail_vma;
1da177e4 LT	352	}
	353
	354	static void m_stop(struct seq_file m, void v)
	355	{
	356	struct task_struct *task = m->private;
e070ad49 ML	357	struct vm_area_struct *vma = v;
	358	if (vma && vma != get_gate_vma(task)) {
	359	struct mm_struct *mm = vma->vm_mm;
1da177e4 LT	360	up_read(&mm->mmap_sem);
	361	mmput(mm);
	362	}
	363	}
	364
	365	static void m_next(struct seq_file m, void v, loff_t pos)
	366	{
	367	struct task_struct *task = m->private;
e070ad49 ML	368	struct vm_area_struct *vma = v;
e070ad49 ML	369	struct vm_area_struct *tail_vma = get_gate_vma(task);
1da177e4 LT	370
1da177e4 LT	371	(*pos)++;
e070ad49 ML	372	if (vma && (vma != tail_vma) && vma->vm_next)
e070ad49 ML	373	return vma->vm_next;
1da177e4	374	m_stop(m, v);
e070ad49	375	return (vma != tail_vma)? tail_vma: NULL;
1da177e4 LT	376	}
	377
	378	struct seq_operations proc_pid_maps_op = {
	379	.start = m_start,
	380	.next = m_next,
	381	.stop = m_stop,
	382	.show = show_map
	383	};
6e21c8f1	384
e070ad49 ML	385	struct seq_operations proc_pid_smaps_op = {
	386	.start = m_start,
	387	.next = m_next,
	388	.stop = m_stop,
	389	.show = show_smap
	390	};
	391
6e21c8f1 CL	392	#ifdef CONFIG_NUMA
	393
	394	struct numa_maps {
	395	unsigned long pages;
	396	unsigned long anon;
	397	unsigned long mapped;
	398	unsigned long mapcount_max;
	399	unsigned long node[MAX_NUMNODES];
	400	};
	401
	402	/*
	403	* Calculate numa node maps for a vma
	404	*/
	405	static struct numa_maps get_numa_maps(const struct vm_area_struct vma)
	406	{
	407	struct page *page;
	408	unsigned long vaddr;
	409	struct mm_struct *mm = vma->vm_mm;
	410	int i;
	411	struct numa_maps *md = kmalloc(sizeof(struct numa_maps), GFP_KERNEL);
	412
	413	if (!md)
	414	return NULL;
	415	md->pages = 0;
	416	md->anon = 0;
	417	md->mapped = 0;
	418	md->mapcount_max = 0;
	419	for_each_node(i)
	420	md->node[i] =0;
	421
6e21c8f1 CL	422	for (vaddr = vma->vm_start; vaddr < vma->vm_end; vaddr += PAGE_SIZE) {
	423	page = follow_page(mm, vaddr, 0);
	424	if (page) {
	425	int count = page_mapcount(page);
	426
	427	if (count)
	428	md->mapped++;
	429	if (count > md->mapcount_max)
	430	md->mapcount_max = count;
	431	md->pages++;
	432	if (PageAnon(page))
	433	md->anon++;
	434	md->node[page_to_nid(page)]++;
	435	}
deceb6cd	436	cond_resched();
6e21c8f1	437	}
6e21c8f1 CL	438	return md;
	439	}
	440
	441	static int show_numa_map(struct seq_file m, void v)
	442	{
	443	struct task_struct *task = m->private;
	444	struct vm_area_struct *vma = v;
	445	struct mempolicy *pol;
	446	struct numa_maps *md;
	447	struct zone **z;
	448	int n;
	449	int first;
	450
	451	if (!vma->vm_mm)
	452	return 0;
	453
	454	md = get_numa_maps(vma);
	455	if (!md)
	456	return 0;
	457
	458	seq_printf(m, "%08lx", vma->vm_start);
	459	pol = get_vma_policy(task, vma, vma->vm_start);
	460	/* Print policy */
	461	switch (pol->policy) {
	462	case MPOL_PREFERRED:
	463	seq_printf(m, " prefer=%d", pol->v.preferred_node);
	464	break;
	465	case MPOL_BIND:
	466	seq_printf(m, " bind={");
	467	first = 1;
	468	for (z = pol->v.zonelist->zones; *z; z++) {
	469
	470	if (!first)
	471	seq_putc(m, ',');
	472	else
	473	first = 0;
	474	seq_printf(m, "%d/%s", (*z)->zone_pgdat->node_id,
	475	(*z)->name);
	476	}
	477	seq_putc(m, '}');
	478	break;
	479	case MPOL_INTERLEAVE:
	480	seq_printf(m, " interleave={");
	481	first = 1;
	482	for_each_node(n) {
dfcd3c0d	483	if (node_isset(n, pol->v.nodes)) {
6e21c8f1 CL	484	if (!first)
	485	seq_putc(m,',');
	486	else
	487	first = 0;
	488	seq_printf(m, "%d",n);
	489	}
	490	}
	491	seq_putc(m, '}');
	492	break;
	493	default:
	494	seq_printf(m," default");
	495	break;
	496	}
	497	seq_printf(m, " MaxRef=%lu Pages=%lu Mapped=%lu",
	498	md->mapcount_max, md->pages, md->mapped);
	499	if (md->anon)
	500	seq_printf(m," Anon=%lu",md->anon);
	501
	502	for_each_online_node(n) {
	503	if (md->node[n])
	504	seq_printf(m, " N%d=%lu", n, md->node[n]);
	505	}
	506	seq_putc(m, '\n');
	507	kfree(md);
	508	if (m->count < m->size) /* vma is copied successfully */
	509	m->version = (vma != get_gate_vma(task)) ? vma->vm_start : 0;
	510	return 0;
	511	}
	512
	513	struct seq_operations proc_pid_numa_maps_op = {
	514	.start = m_start,
	515	.next = m_next,
	516	.stop = m_stop,
	517	.show = show_numa_map
	518	};
	519	#endif