task_mmu.c 18.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
#include <linux/mm.h>
#include <linux/hugetlb.h>
#include <linux/mount.h>
#include <linux/seq_file.h>
M
Mauricio Lin 已提交
5
#include <linux/highmem.h>
K
Kees Cook 已提交
6
#include <linux/ptrace.h>
7
#include <linux/pagemap.h>
8
#include <linux/ptrace.h>
9
#include <linux/mempolicy.h>
10 11
#include <linux/swap.h>
#include <linux/swapops.h>
12
#include <linux/seq_file.h>
M
Mauricio Lin 已提交
13

L
Linus Torvalds 已提交
14 15
#include <asm/elf.h>
#include <asm/uaccess.h>
M
Mauricio Lin 已提交
16
#include <asm/tlbflush.h>
L
Linus Torvalds 已提交
17 18
#include "internal.h"

19
void task_mem(struct seq_file *m, struct mm_struct *mm)
L
Linus Torvalds 已提交
20 21
{
	unsigned long data, text, lib;
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
	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;
L
Linus Torvalds 已提交
37 38 39 40

	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;
41
	seq_printf(m,
42
		"VmPeak:\t%8lu kB\n"
L
Linus Torvalds 已提交
43 44
		"VmSize:\t%8lu kB\n"
		"VmLck:\t%8lu kB\n"
45
		"VmHWM:\t%8lu kB\n"
L
Linus Torvalds 已提交
46 47 48 49 50 51
		"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",
52 53
		hiwater_vm << (PAGE_SHIFT-10),
		(total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
L
Linus Torvalds 已提交
54
		mm->locked_vm << (PAGE_SHIFT-10),
55 56
		hiwater_rss << (PAGE_SHIFT-10),
		total_rss << (PAGE_SHIFT-10),
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69
		data << (PAGE_SHIFT-10),
		mm->stack_vm << (PAGE_SHIFT-10), text, lib,
		(PTRS_PER_PTE*sizeof(pte_t)*mm->nr_ptes) >> 10);
}

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)
{
70
	*shared = get_mm_counter(mm, file_rss);
L
Linus Torvalds 已提交
71 72 73
	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
								>> PAGE_SHIFT;
	*data = mm->total_vm - mm->shared_vm;
74
	*resident = *shared + get_mm_counter(mm, anon_rss);
L
Linus Torvalds 已提交
75 76 77
	return mm->total_vm;
}

78
int proc_exe_link(struct inode *inode, struct path *path)
L
Linus Torvalds 已提交
79 80 81
{
	struct vm_area_struct * vma;
	int result = -ENOENT;
82 83
	struct task_struct *task = get_proc_task(inode);
	struct mm_struct * mm = NULL;
L
Linus Torvalds 已提交
84

85 86 87 88
	if (task) {
		mm = get_task_mm(task);
		put_task_struct(task);
	}
L
Linus Torvalds 已提交
89 90 91 92 93 94 95 96 97 98 99 100
	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) {
101 102
		*path = vma->vm_file->f_path;
		path_get(&vma->vm_file->f_path);
L
Linus Torvalds 已提交
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
		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, ' ');
}

120 121 122 123 124 125 126 127
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);
	}
}
128

129
static void *m_start(struct seq_file *m, loff_t *pos)
M
Mauricio Lin 已提交
130
{
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 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
	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 = mm_for_maps(priv->task);
	if (!mm)
		return NULL;

	tail_vma = get_gate_vma(priv->task);
	priv->tail_vma = tail_vma;

	/* Start with last addr hint */
	vma = find_vma(mm, last_addr);
	if (last_addr && vma) {
		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_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 int do_maps_open(struct inode *inode, struct file *file,
219
			const struct seq_operations *ops)
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
{
	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;
}
M
Mauricio Lin 已提交
236

237
static int show_map(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
238
{
239 240
	struct proc_maps_private *priv = m->private;
	struct task_struct *task = priv->task;
M
Mauricio Lin 已提交
241 242 243 244
	struct vm_area_struct *vma = v;
	struct mm_struct *mm = vma->vm_mm;
	struct file *file = vma->vm_file;
	int flags = vma->vm_flags;
L
Linus Torvalds 已提交
245 246 247 248
	unsigned long ino = 0;
	dev_t dev = 0;
	int len;

K
Kees Cook 已提交
249 250 251
	if (maps_protect && !ptrace_may_attach(task))
		return -EACCES;

L
Linus Torvalds 已提交
252
	if (file) {
253
		struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
254 255 256 257 258
		dev = inode->i_sb->s_dev;
		ino = inode->i_ino;
	}

	seq_printf(m, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
M
Mauricio Lin 已提交
259 260
			vma->vm_start,
			vma->vm_end,
L
Linus Torvalds 已提交
261 262 263 264
			flags & VM_READ ? 'r' : '-',
			flags & VM_WRITE ? 'w' : '-',
			flags & VM_EXEC ? 'x' : '-',
			flags & VM_MAYSHARE ? 's' : 'p',
M
Mauricio Lin 已提交
265
			vma->vm_pgoff << PAGE_SHIFT,
L
Linus Torvalds 已提交
266 267 268 269 270 271
			MAJOR(dev), MINOR(dev), ino, &len);

	/*
	 * Print the dentry name for named mappings, and a
	 * special [heap] marker for the heap:
	 */
M
Mauricio Lin 已提交
272
	if (file) {
L
Linus Torvalds 已提交
273
		pad_len_spaces(m, len);
274
		seq_path(m, &file->f_path, "\n");
L
Linus Torvalds 已提交
275
	} else {
276 277 278 279
		const char *name = arch_vma_name(vma);
		if (!name) {
			if (mm) {
				if (vma->vm_start <= mm->start_brk &&
M
Mauricio Lin 已提交
280
						vma->vm_end >= mm->brk) {
281 282 283 284
					name = "[heap]";
				} else if (vma->vm_start <= mm->start_stack &&
					   vma->vm_end >= mm->start_stack) {
					name = "[stack]";
L
Linus Torvalds 已提交
285
				}
286 287
			} else {
				name = "[vdso]";
L
Linus Torvalds 已提交
288
			}
289 290
		}
		if (name) {
L
Linus Torvalds 已提交
291
			pad_len_spaces(m, len);
292
			seq_puts(m, name);
L
Linus Torvalds 已提交
293 294 295
		}
	}
	seq_putc(m, '\n');
M
Mauricio Lin 已提交
296 297 298

	if (m->count < m->size)  /* vma is copied successfully */
		m->version = (vma != get_gate_vma(task))? vma->vm_start: 0;
L
Linus Torvalds 已提交
299 300 301
	return 0;
}

302
static const struct seq_operations proc_pid_maps_op = {
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_map
};

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

/*
 * Proportional Set Size(PSS): my share of RSS.
 *
 * PSS of a process is the count of pages it has in memory, where each
 * page is divided by the number of processes sharing it.  So if a
 * process has 1000 pages all to itself, and 1000 shared with one other
 * process, its PSS will be 1500.
 *
 * To keep (accumulated) division errors low, we adopt a 64bit
 * fixed-point pss counter to minimize division errors. So (pss >>
 * PSS_SHIFT) would be the real byte count.
 *
 * A shift of 12 before division means (assuming 4K page size):
 * 	- 1M 3-user-pages add up to 8KB errors;
 * 	- supports mapcount up to 2^24, or 16M;
 * 	- supports PSS up to 2^52 bytes, or 4PB.
 */
#define PSS_SHIFT 12

340
#ifdef CONFIG_PROC_PAGE_MONITOR
341 342 343 344 345 346 347 348 349 350 351 352
struct mem_size_stats
{
	struct vm_area_struct *vma;
	unsigned long resident;
	unsigned long shared_clean;
	unsigned long shared_dirty;
	unsigned long private_clean;
	unsigned long private_dirty;
	unsigned long referenced;
	u64 pss;
};

353 354
static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
			   void *private)
M
Mauricio Lin 已提交
355
{
356
	struct mem_size_stats *mss = private;
357
	struct vm_area_struct *vma = mss->vma;
M
Mauricio Lin 已提交
358
	pte_t *pte, ptent;
359
	spinlock_t *ptl;
M
Mauricio Lin 已提交
360
	struct page *page;
361
	int mapcount;
M
Mauricio Lin 已提交
362

363
	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
364
	for (; addr != end; pte++, addr += PAGE_SIZE) {
M
Mauricio Lin 已提交
365
		ptent = *pte;
366
		if (!pte_present(ptent))
M
Mauricio Lin 已提交
367 368 369
			continue;

		mss->resident += PAGE_SIZE;
N
Nick Piggin 已提交
370 371 372

		page = vm_normal_page(vma, addr, ptent);
		if (!page)
M
Mauricio Lin 已提交
373 374
			continue;

375 376 377
		/* Accumulate the size in pages that have been accessed. */
		if (pte_young(ptent) || PageReferenced(page))
			mss->referenced += PAGE_SIZE;
378 379
		mapcount = page_mapcount(page);
		if (mapcount >= 2) {
M
Mauricio Lin 已提交
380 381 382 383
			if (pte_dirty(ptent))
				mss->shared_dirty += PAGE_SIZE;
			else
				mss->shared_clean += PAGE_SIZE;
384
			mss->pss += (PAGE_SIZE << PSS_SHIFT) / mapcount;
M
Mauricio Lin 已提交
385 386 387 388 389
		} else {
			if (pte_dirty(ptent))
				mss->private_dirty += PAGE_SIZE;
			else
				mss->private_clean += PAGE_SIZE;
390
			mss->pss += (PAGE_SIZE << PSS_SHIFT);
M
Mauricio Lin 已提交
391
		}
392
	}
393 394
	pte_unmap_unlock(pte - 1, ptl);
	cond_resched();
395
	return 0;
M
Mauricio Lin 已提交
396 397
}

398
static struct mm_walk smaps_walk = { .pmd_entry = smaps_pte_range };
M
Mauricio Lin 已提交
399 400 401 402 403

static int show_smap(struct seq_file *m, void *v)
{
	struct vm_area_struct *vma = v;
	struct mem_size_stats mss;
404
	int ret;
M
Mauricio Lin 已提交
405 406

	memset(&mss, 0, sizeof mss);
407
	mss.vma = vma;
N
Nick Piggin 已提交
408
	if (vma->vm_mm && !is_vm_hugetlb_page(vma))
409 410
		walk_page_range(vma->vm_mm, vma->vm_start, vma->vm_end,
				&smaps_walk, &mss);
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434

	ret = show_map(m, v);
	if (ret)
		return ret;

	seq_printf(m,
		   "Size:           %8lu kB\n"
		   "Rss:            %8lu kB\n"
		   "Pss:            %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,
		   (unsigned long)(mss.pss >> (10 + PSS_SHIFT)),
		   mss.shared_clean  >> 10,
		   mss.shared_dirty  >> 10,
		   mss.private_clean >> 10,
		   mss.private_dirty >> 10,
		   mss.referenced >> 10);

	return ret;
M
Mauricio Lin 已提交
435 436
}

437
static const struct seq_operations proc_pid_smaps_op = {
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 470 471 472 473 474 475 476 477 478 479 480 481 482
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_smap
};

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

static int clear_refs_pte_range(pmd_t *pmd, unsigned long addr,
				unsigned long end, void *private)
{
	struct vm_area_struct *vma = 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();
	return 0;
}

483 484
static struct mm_walk clear_refs_walk = { .pmd_entry = clear_refs_pte_range };

485 486
static ssize_t clear_refs_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
487
{
488 489 490
	struct task_struct *task;
	char buffer[PROC_NUMBUF], *end;
	struct mm_struct *mm;
491 492
	struct vm_area_struct *vma;

493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count))
		return -EFAULT;
	if (!simple_strtol(buffer, &end, 0))
		return -EINVAL;
	if (*end == '\n')
		end++;
	task = get_proc_task(file->f_path.dentry->d_inode);
	if (!task)
		return -ESRCH;
	mm = get_task_mm(task);
	if (mm) {
		down_read(&mm->mmap_sem);
		for (vma = mm->mmap; vma; vma = vma->vm_next)
			if (!is_vm_hugetlb_page(vma))
				walk_page_range(mm, vma->vm_start, vma->vm_end,
						&clear_refs_walk, vma);
		flush_tlb_mm(mm);
		up_read(&mm->mmap_sem);
		mmput(mm);
	}
	put_task_struct(task);
	if (end - buffer == 0)
		return -EIO;
	return end - buffer;
520 521
}

522 523 524 525
const struct file_operations proc_clear_refs_operations = {
	.write		= clear_refs_write,
};

526 527 528 529 530 531 532 533
struct pagemapread {
	char __user *out, *end;
};

#define PM_ENTRY_BYTES sizeof(u64)
#define PM_RESERVED_BITS    3
#define PM_RESERVED_OFFSET  (64 - PM_RESERVED_BITS)
#define PM_RESERVED_MASK    (((1LL<<PM_RESERVED_BITS)-1) << PM_RESERVED_OFFSET)
534
#define PM_SPECIAL(nr)      (((nr) << PM_RESERVED_OFFSET) & PM_RESERVED_MASK)
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
#define PM_NOT_PRESENT      PM_SPECIAL(1LL)
#define PM_SWAP             PM_SPECIAL(2LL)
#define PM_END_OF_BUFFER    1

static int add_to_pagemap(unsigned long addr, u64 pfn,
			  struct pagemapread *pm)
{
	/*
	 * Make sure there's room in the buffer for an
	 * entire entry.  Otherwise, only copy part of
	 * the pfn.
	 */
	if (pm->out + PM_ENTRY_BYTES >= pm->end) {
		if (copy_to_user(pm->out, &pfn, pm->end - pm->out))
			return -EFAULT;
		pm->out = pm->end;
		return PM_END_OF_BUFFER;
	}

	if (put_user(pfn, pm->out))
		return -EFAULT;
	pm->out += PM_ENTRY_BYTES;
	return 0;
}

static int pagemap_pte_hole(unsigned long start, unsigned long end,
				void *private)
{
	struct pagemapread *pm = private;
	unsigned long addr;
	int err = 0;
	for (addr = start; addr < end; addr += PAGE_SIZE) {
		err = add_to_pagemap(addr, PM_NOT_PRESENT, pm);
		if (err)
			break;
	}
	return err;
}

u64 swap_pte_to_pagemap_entry(pte_t pte)
{
	swp_entry_t e = pte_to_swp_entry(pte);
	return PM_SWAP | swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
}

static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
			     void *private)
{
	struct pagemapread *pm = private;
	pte_t *pte;
	int err = 0;

	for (; addr != end; addr += PAGE_SIZE) {
		u64 pfn = PM_NOT_PRESENT;
		pte = pte_offset_map(pmd, addr);
		if (is_swap_pte(*pte))
			pfn = swap_pte_to_pagemap_entry(*pte);
		else if (pte_present(*pte))
			pfn = pte_pfn(*pte);
		/* unmap so we're not in atomic when we copy to userspace */
		pte_unmap(pte);
		err = add_to_pagemap(addr, pfn, pm);
		if (err)
			return err;
	}

	cond_resched();

	return err;
}

static struct mm_walk pagemap_walk = {
	.pmd_entry = pagemap_pte_range,
	.pte_hole = pagemap_pte_hole
};

/*
 * /proc/pid/pagemap - an array mapping virtual pages to pfns
 *
 * For each page in the address space, this file contains one 64-bit
 * entry representing the corresponding physical page frame number
 * (PFN) if the page is present. If there is a swap entry for the
 * physical page, then an encoding of the swap file number and the
 * page's offset into the swap file are returned. If no page is
 * present at all, PM_NOT_PRESENT is returned. This allows determining
 * precisely which pages are mapped (or in swap) and comparing mapped
 * pages between processes.
 *
 * Efficient users of this interface will use /proc/pid/maps to
 * determine which areas of memory are actually mapped and llseek to
 * skip over unmapped regions.
 */
static ssize_t pagemap_read(struct file *file, char __user *buf,
			    size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
	struct page **pages, *page;
	unsigned long uaddr, uend;
	struct mm_struct *mm;
	struct pagemapread pm;
	int pagecount;
	int ret = -ESRCH;

	if (!task)
		goto out;

	ret = -EACCES;
	if (!ptrace_may_attach(task))
643
		goto out_task;
644 645 646 647

	ret = -EINVAL;
	/* file position must be aligned */
	if (*ppos % PM_ENTRY_BYTES)
648
		goto out_task;
649 650 651 652

	ret = 0;
	mm = get_task_mm(task);
	if (!mm)
653
		goto out_task;
654 655 656 657 658 659 660

	ret = -ENOMEM;
	uaddr = (unsigned long)buf & PAGE_MASK;
	uend = (unsigned long)(buf + count);
	pagecount = (PAGE_ALIGN(uend) - uaddr) / PAGE_SIZE;
	pages = kmalloc(pagecount * sizeof(struct page *), GFP_KERNEL);
	if (!pages)
661
		goto out_mm;
662 663 664 665 666 667 668 669 670

	down_read(&current->mm->mmap_sem);
	ret = get_user_pages(current, current->mm, uaddr, pagecount,
			     1, 0, pages, NULL);
	up_read(&current->mm->mmap_sem);

	if (ret < 0)
		goto out_free;

671 672 673 674 675 676
	if (ret != pagecount) {
		pagecount = ret;
		ret = -EFAULT;
		goto out_pages;
	}

677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
	pm.out = buf;
	pm.end = buf + count;

	if (!ptrace_may_attach(task)) {
		ret = -EIO;
	} else {
		unsigned long src = *ppos;
		unsigned long svpfn = src / PM_ENTRY_BYTES;
		unsigned long start_vaddr = svpfn << PAGE_SHIFT;
		unsigned long end_vaddr = TASK_SIZE_OF(task);

		/* watch out for wraparound */
		if (svpfn > TASK_SIZE_OF(task) >> PAGE_SHIFT)
			start_vaddr = end_vaddr;

		/*
		 * The odds are that this will stop walking way
		 * before end_vaddr, because the length of the
		 * user buffer is tracked in "pm", and the walk
		 * will stop when we hit the end of the buffer.
		 */
		ret = walk_page_range(mm, start_vaddr, end_vaddr,
					&pagemap_walk, &pm);
		if (ret == PM_END_OF_BUFFER)
			ret = 0;
		/* don't need mmap_sem for these, but this looks cleaner */
		*ppos += pm.out - buf;
		if (!ret)
			ret = pm.out - buf;
	}

708
out_pages:
709 710 711 712 713 714 715 716
	for (; pagecount; pagecount--) {
		page = pages[pagecount-1];
		if (!PageReserved(page))
			SetPageDirty(page);
		page_cache_release(page);
	}
out_free:
	kfree(pages);
717 718
out_mm:
	mmput(mm);
719 720 721 722 723 724 725 726 727 728
out_task:
	put_task_struct(task);
out:
	return ret;
}

const struct file_operations proc_pagemap_operations = {
	.llseek		= mem_lseek, /* borrow this */
	.read		= pagemap_read,
};
729
#endif /* CONFIG_PROC_PAGE_MONITOR */
730

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

K
Kees Cook 已提交
734 735 736 737 738 739 740 741 742 743 744
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);
}

745
static const struct seq_operations proc_pid_numa_maps_op = {
746 747 748
        .start  = m_start,
        .next   = m_next,
        .stop   = m_stop,
K
Kees Cook 已提交
749
        .show   = show_numa_map_checked
750
};
751 752 753 754 755 756

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

757
const struct file_operations proc_numa_maps_operations = {
758 759 760
	.open		= numa_maps_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
761
	.release	= seq_release_private,
762
};
763
#endif