task_mmu.c 11.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4
#include <linux/mm.h>
#include <linux/hugetlb.h>
#include <linux/mount.h>
#include <linux/seq_file.h>
Mauricio Lin's avatar
Mauricio Lin committed
5
#include <linux/highmem.h>
6 7
#include <linux/pagemap.h>
#include <linux/mempolicy.h>
Mauricio Lin's avatar
Mauricio Lin committed
8

Linus Torvalds's avatar
Linus Torvalds committed
9 10
#include <asm/elf.h>
#include <asm/uaccess.h>
Mauricio Lin's avatar
Mauricio Lin committed
11
#include <asm/tlbflush.h>
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
#include "internal.h"

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

	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,
		"VmSize:\t%8lu kB\n"
		"VmLck:\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",
		(mm->total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
		mm->locked_vm << (PAGE_SHIFT-10),
32
		get_mm_rss(mm) << (PAGE_SHIFT-10),
Linus Torvalds's avatar
Linus Torvalds committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46
		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)
{
47
	*shared = get_mm_counter(mm, file_rss);
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50
	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
								>> PAGE_SHIFT;
	*data = mm->total_vm - mm->shared_vm;
51
	*resident = *shared + get_mm_counter(mm, anon_rss);
Linus Torvalds's avatar
Linus Torvalds committed
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
	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, ' ');
}

Mauricio Lin's avatar
Mauricio Lin committed
93 94 95 96 97 98 99 100 101 102
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)
Linus Torvalds's avatar
Linus Torvalds committed
103 104
{
	struct task_struct *task = m->private;
Mauricio Lin's avatar
Mauricio Lin committed
105 106 107 108
	struct vm_area_struct *vma = v;
	struct mm_struct *mm = vma->vm_mm;
	struct file *file = vma->vm_file;
	int flags = vma->vm_flags;
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113
	unsigned long ino = 0;
	dev_t dev = 0;
	int len;

	if (file) {
Mauricio Lin's avatar
Mauricio Lin committed
114
		struct inode *inode = vma->vm_file->f_dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
115 116 117 118 119
		dev = inode->i_sb->s_dev;
		ino = inode->i_ino;
	}

	seq_printf(m, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
Mauricio Lin's avatar
Mauricio Lin committed
120 121
			vma->vm_start,
			vma->vm_end,
Linus Torvalds's avatar
Linus Torvalds committed
122 123 124 125
			flags & VM_READ ? 'r' : '-',
			flags & VM_WRITE ? 'w' : '-',
			flags & VM_EXEC ? 'x' : '-',
			flags & VM_MAYSHARE ? 's' : 'p',
Mauricio Lin's avatar
Mauricio Lin committed
126
			vma->vm_pgoff << PAGE_SHIFT,
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130 131 132
			MAJOR(dev), MINOR(dev), ino, &len);

	/*
	 * Print the dentry name for named mappings, and a
	 * special [heap] marker for the heap:
	 */
Mauricio Lin's avatar
Mauricio Lin committed
133
	if (file) {
Linus Torvalds's avatar
Linus Torvalds committed
134
		pad_len_spaces(m, len);
Mauricio Lin's avatar
Mauricio Lin committed
135
		seq_path(m, file->f_vfsmnt, file->f_dentry, "\n");
Linus Torvalds's avatar
Linus Torvalds committed
136 137
	} else {
		if (mm) {
Mauricio Lin's avatar
Mauricio Lin committed
138 139
			if (vma->vm_start <= mm->start_brk &&
						vma->vm_end >= mm->brk) {
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142
				pad_len_spaces(m, len);
				seq_puts(m, "[heap]");
			} else {
Mauricio Lin's avatar
Mauricio Lin committed
143 144
				if (vma->vm_start <= mm->start_stack &&
					vma->vm_end >= mm->start_stack) {
Linus Torvalds's avatar
Linus Torvalds committed
145 146 147 148 149 150 151 152 153 154 155

					pad_len_spaces(m, len);
					seq_puts(m, "[stack]");
				}
			}
		} else {
			pad_len_spaces(m, len);
			seq_puts(m, "[vdso]");
		}
	}
	seq_putc(m, '\n');
Mauricio Lin's avatar
Mauricio Lin committed
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173

	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;
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176
	return 0;
}

Mauricio Lin's avatar
Mauricio Lin committed
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
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;
	unsigned long pfn;
	struct page *page;

	pte = pte_offset_map(pmd, addr);
	do {
		ptent = *pte;
		if (pte_none(ptent) || !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(pte - 1);
	cond_resched_lock(&vma->vm_mm->page_table_lock);
}

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 mm_struct *mm = vma->vm_mm;
	struct mem_size_stats mss;

	memset(&mss, 0, sizeof mss);

	if (mm) {
		spin_lock(&mm->page_table_lock);
		smaps_pgd_range(vma, vma->vm_start, vma->vm_end, &mss);
		spin_unlock(&mm->page_table_lock);
	}

	return show_map_internal(m, v, &mss);
}

Linus Torvalds's avatar
Linus Torvalds committed
283 284 285 286 287
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;
Mauricio Lin's avatar
Mauricio Lin committed
288
	struct vm_area_struct *vma, *tail_vma;
Linus Torvalds's avatar
Linus Torvalds committed
289 290 291 292 293
	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
Mauricio Lin's avatar
Mauricio Lin committed
294 295
	 * the beginning and also after lseek. We will have -1 last_addr
	 * after the end of the vmas.
Linus Torvalds's avatar
Linus Torvalds committed
296 297 298 299 300 301 302 303 304
	 */

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

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

Mauricio Lin's avatar
Mauricio Lin committed
305
	tail_vma = get_gate_vma(task);
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308
	down_read(&mm->mmap_sem);

	/* Start with last addr hint */
Mauricio Lin's avatar
Mauricio Lin committed
309 310
	if (last_addr && (vma = find_vma(mm, last_addr))) {
		vma = vma->vm_next;
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314
		goto out;
	}

	/*
Mauricio Lin's avatar
Mauricio Lin committed
315
	 * Check the vma index is within the range and do
Linus Torvalds's avatar
Linus Torvalds committed
316 317
	 * sequential scan until m_index.
	 */
Mauricio Lin's avatar
Mauricio Lin committed
318
	vma = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
319
	if ((unsigned long)l < mm->map_count) {
Mauricio Lin's avatar
Mauricio Lin committed
320 321 322
		vma = mm->mmap;
		while (l-- && vma)
			vma = vma->vm_next;
Linus Torvalds's avatar
Linus Torvalds committed
323 324 325 326
		goto out;
	}

	if (l != mm->map_count)
Mauricio Lin's avatar
Mauricio Lin committed
327
		tail_vma = NULL; /* After gate vma */
Linus Torvalds's avatar
Linus Torvalds committed
328 329

out:
Mauricio Lin's avatar
Mauricio Lin committed
330 331
	if (vma)
		return vma;
Linus Torvalds's avatar
Linus Torvalds committed
332

Mauricio Lin's avatar
Mauricio Lin committed
333 334
	/* End of vmas has been reached */
	m->version = (tail_vma != NULL)? 0: -1UL;
Linus Torvalds's avatar
Linus Torvalds committed
335 336
	up_read(&mm->mmap_sem);
	mmput(mm);
Mauricio Lin's avatar
Mauricio Lin committed
337
	return tail_vma;
Linus Torvalds's avatar
Linus Torvalds committed
338 339 340 341 342
}

static void m_stop(struct seq_file *m, void *v)
{
	struct task_struct *task = m->private;
Mauricio Lin's avatar
Mauricio Lin committed
343 344 345
	struct vm_area_struct *vma = v;
	if (vma && vma != get_gate_vma(task)) {
		struct mm_struct *mm = vma->vm_mm;
Linus Torvalds's avatar
Linus Torvalds committed
346 347 348 349 350 351 352 353
		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;
Mauricio Lin's avatar
Mauricio Lin committed
354 355
	struct vm_area_struct *vma = v;
	struct vm_area_struct *tail_vma = get_gate_vma(task);
Linus Torvalds's avatar
Linus Torvalds committed
356 357

	(*pos)++;
Mauricio Lin's avatar
Mauricio Lin committed
358 359
	if (vma && (vma != tail_vma) && vma->vm_next)
		return vma->vm_next;
Linus Torvalds's avatar
Linus Torvalds committed
360
	m_stop(m, v);
Mauricio Lin's avatar
Mauricio Lin committed
361
	return (vma != tail_vma)? tail_vma: NULL;
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365 366 367 368 369
}

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

Mauricio Lin's avatar
Mauricio Lin committed
371 372 373 374 375 376 377
struct seq_operations proc_pid_smaps_op = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_smap
};

378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
#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;

	spin_lock(&mm->page_table_lock);
 	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)]++;
		}
	}
	spin_unlock(&mm->page_table_lock);
	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) {
470
			if (node_isset(n, pol->v.nodes)) {
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
				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