xref: /openbmc/linux/fs/proc/task_mmu.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 #include <linux/mm.h>
2 #include <linux/hugetlb.h>
3 #include <linux/mount.h>
4 #include <linux/seq_file.h>
5 #include <linux/highmem.h>
6 #include <linux/ptrace.h>
7 #include <linux/pagemap.h>
8 #include <linux/mempolicy.h>
9 
10 #include <asm/elf.h>
11 #include <asm/uaccess.h>
12 #include <asm/tlbflush.h>
13 #include "internal.h"
14 
15 char *task_mem(struct mm_struct *mm, char *buffer)
16 {
17 	unsigned long data, text, lib;
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;
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,
38 		"VmPeak:\t%8lu kB\n"
39 		"VmSize:\t%8lu kB\n"
40 		"VmLck:\t%8lu kB\n"
41 		"VmHWM:\t%8lu kB\n"
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",
48 		hiwater_vm << (PAGE_SHIFT-10),
49 		(total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
50 		mm->locked_vm << (PAGE_SHIFT-10),
51 		hiwater_rss << (PAGE_SHIFT-10),
52 		total_rss << (PAGE_SHIFT-10),
53 		data << (PAGE_SHIFT-10),
54 		mm->stack_vm << (PAGE_SHIFT-10), text, lib,
55 		(PTRS_PER_PTE*sizeof(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 {
67 	*shared = get_mm_counter(mm, file_rss);
68 	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
69 								>> PAGE_SHIFT;
70 	*data = mm->total_vm - mm->shared_vm;
71 	*resident = *shared + get_mm_counter(mm, anon_rss);
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;
79 	struct task_struct *task = get_proc_task(inode);
80 	struct mm_struct * mm = NULL;
81 
82 	if (task) {
83 		mm = get_task_mm(task);
84 		put_task_struct(task);
85 	}
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) {
98 		*mnt = mntget(vma->vm_file->f_path.mnt);
99 		*dentry = dget(vma->vm_file->f_path.dentry);
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 
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;
124 	unsigned long referenced;
125 };
126 
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 
134 static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats *mss)
135 {
136 	struct proc_maps_private *priv = m->private;
137 	struct task_struct *task = priv->task;
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;
142 	unsigned long ino = 0;
143 	dev_t dev = 0;
144 	int len;
145 
146 	if (maps_protect && !ptrace_may_attach(task))
147 		return -EACCES;
148 
149 	if (file) {
150 		struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
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",
156 			vma->vm_start,
157 			vma->vm_end,
158 			flags & VM_READ ? 'r' : '-',
159 			flags & VM_WRITE ? 'w' : '-',
160 			flags & VM_EXEC ? 'x' : '-',
161 			flags & VM_MAYSHARE ? 's' : 'p',
162 			vma->vm_pgoff << PAGE_SHIFT,
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 	 */
169 	if (file) {
170 		pad_len_spaces(m, len);
171 		seq_path(m, file->f_path.mnt, file->f_path.dentry, "\n");
172 	} else {
173 		const char *name = arch_vma_name(vma);
174 		if (!name) {
175 			if (mm) {
176 				if (vma->vm_start <= mm->start_brk &&
177 						vma->vm_end >= mm->brk) {
178 					name = "[heap]";
179 				} else if (vma->vm_start <= mm->start_stack &&
180 					   vma->vm_end >= mm->start_stack) {
181 					name = "[stack]";
182 				}
183 			} else {
184 				name = "[vdso]";
185 			}
186 		}
187 		if (name) {
188 			pad_len_spaces(m, len);
189 			seq_puts(m, name);
190 		}
191 	}
192 	seq_putc(m, '\n');
193 
194 	if (mss)
195 		seq_printf(m,
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"
202 			   "Referenced:     %8lu kB\n",
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,
208 			   mss->private_dirty >> 10,
209 			   mss->referenced >> 10);
210 
211 	if (m->count < m->size)  /* vma is copied successfully */
212 		m->version = (vma != get_gate_vma(task))? vma->vm_start: 0;
213 	return 0;
214 }
215 
216 static int show_map(struct seq_file *m, void *v)
217 {
218 	return show_map_internal(m, v, NULL);
219 }
220 
221 static void smaps_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
222 			    unsigned long addr, unsigned long end,
223 			    void *private)
224 {
225 	struct mem_size_stats *mss = private;
226 	pte_t *pte, ptent;
227 	spinlock_t *ptl;
228 	struct page *page;
229 
230 	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
231 	for (; addr != end; pte++, addr += PAGE_SIZE) {
232 		ptent = *pte;
233 		if (!pte_present(ptent))
234 			continue;
235 
236 		mss->resident += PAGE_SIZE;
237 
238 		page = vm_normal_page(vma, addr, ptent);
239 		if (!page)
240 			continue;
241 
242 		/* Accumulate the size in pages that have been accessed. */
243 		if (pte_young(ptent) || PageReferenced(page))
244 			mss->referenced += PAGE_SIZE;
245 		if (page_mapcount(page) >= 2) {
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 		}
256 	}
257 	pte_unmap_unlock(pte - 1, ptl);
258 	cond_resched();
259 }
260 
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)
289 {
290 	pmd_t *pmd;
291 	unsigned long next;
292 
293 	for (pmd = pmd_offset(pud, addr); addr != end;
294 	     pmd++, addr = next) {
295 		next = pmd_addr_end(addr, end);
296 		if (pmd_none_or_clear_bad(pmd))
297 			continue;
298 		walker->action(walker->vma, pmd, addr, next, walker->private);
299 	}
300 }
301 
302 static inline void walk_pud_range(struct pmd_walker *walker, pgd_t *pgd,
303 				  unsigned long addr, unsigned long end)
304 {
305 	pud_t *pud;
306 	unsigned long next;
307 
308 	for (pud = pud_offset(pgd, addr); addr != end;
309 	     pud++, addr = next) {
310 		next = pud_addr_end(addr, end);
311 		if (pud_none_or_clear_bad(pud))
312 			continue;
313 		walk_pmd_range(walker, pud, addr, next);
314 	}
315 }
316 
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)
331 {
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 	};
339 	pgd_t *pgd;
340 	unsigned long next;
341 
342 	for (pgd = pgd_offset(vma->vm_mm, addr); addr != end;
343 	     pgd++, addr = next) {
344 		next = pgd_addr_end(addr, end);
345 		if (pgd_none_or_clear_bad(pgd))
346 			continue;
347 		walk_pud_range(&walker, pgd, addr, next);
348 	}
349 }
350 
351 static int show_smap(struct seq_file *m, void *v)
352 {
353 	struct vm_area_struct *vma = v;
354 	struct mem_size_stats mss;
355 
356 	memset(&mss, 0, sizeof mss);
357 	if (vma->vm_mm && !is_vm_hugetlb_page(vma))
358 		walk_page_range(vma, smaps_pte_range, &mss);
359 	return show_map_internal(m, v, &mss);
360 }
361 
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 
374 static void *m_start(struct seq_file *m, loff_t *pos)
375 {
376 	struct proc_maps_private *priv = m->private;
377 	unsigned long last_addr = m->version;
378 	struct mm_struct *mm;
379 	struct vm_area_struct *vma, *tail_vma = NULL;
380 	loff_t l = *pos;
381 
382 	/* Clear the per syscall fields in priv */
383 	priv->task = NULL;
384 	priv->tail_vma = NULL;
385 
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
389 	 * the beginning and also after lseek. We will have -1 last_addr
390 	 * after the end of the vmas.
391 	 */
392 
393 	if (last_addr == -1UL)
394 		return NULL;
395 
396 	priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
397 	if (!priv->task)
398 		return NULL;
399 
400 	mm = get_task_mm(priv->task);
401 	if (!mm)
402 		return NULL;
403 
404 	priv->tail_vma = tail_vma = get_gate_vma(priv->task);
405 	down_read(&mm->mmap_sem);
406 
407 	/* Start with last addr hint */
408 	if (last_addr && (vma = find_vma(mm, last_addr))) {
409 		vma = vma->vm_next;
410 		goto out;
411 	}
412 
413 	/*
414 	 * Check the vma index is within the range and do
415 	 * sequential scan until m_index.
416 	 */
417 	vma = NULL;
418 	if ((unsigned long)l < mm->map_count) {
419 		vma = mm->mmap;
420 		while (l-- && vma)
421 			vma = vma->vm_next;
422 		goto out;
423 	}
424 
425 	if (l != mm->map_count)
426 		tail_vma = NULL; /* After gate vma */
427 
428 out:
429 	if (vma)
430 		return vma;
431 
432 	/* End of vmas has been reached */
433 	m->version = (tail_vma != NULL)? 0: -1UL;
434 	up_read(&mm->mmap_sem);
435 	mmput(mm);
436 	return tail_vma;
437 }
438 
439 static void vma_stop(struct proc_maps_private *priv, struct vm_area_struct *vma)
440 {
441 	if (vma && vma != priv->tail_vma) {
442 		struct mm_struct *mm = vma->vm_mm;
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 {
450 	struct proc_maps_private *priv = m->private;
451 	struct vm_area_struct *vma = v;
452 	struct vm_area_struct *tail_vma = priv->tail_vma;
453 
454 	(*pos)++;
455 	if (vma && (vma != tail_vma) && vma->vm_next)
456 		return vma->vm_next;
457 	vma_stop(priv, vma);
458 	return (vma != tail_vma)? tail_vma: NULL;
459 }
460 
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 
471 static struct seq_operations proc_pid_maps_op = {
472 	.start	= m_start,
473 	.next	= m_next,
474 	.stop	= m_stop,
475 	.show	= show_map
476 };
477 
478 static struct seq_operations proc_pid_smaps_op = {
479 	.start	= m_start,
480 	.next	= m_next,
481 	.stop	= m_stop,
482 	.show	= show_smap
483 };
484 
485 static int do_maps_open(struct inode *inode, struct file *file,
486 			struct seq_operations *ops)
487 {
488 	struct proc_maps_private *priv;
489 	int ret = -ENOMEM;
490 	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
491 	if (priv) {
492 		priv->pid = proc_pid(inode);
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 		}
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 
509 const struct file_operations proc_maps_operations = {
510 	.open		= maps_open,
511 	.read		= seq_read,
512 	.llseek		= seq_lseek,
513 	.release	= seq_release_private,
514 };
515 
516 #ifdef CONFIG_NUMA
517 extern int show_numa_map(struct seq_file *m, void *v);
518 
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 
530 static struct seq_operations proc_pid_numa_maps_op = {
531         .start  = m_start,
532         .next   = m_next,
533         .stop   = m_stop,
534         .show   = show_numa_map_checked
535 };
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 
542 const struct file_operations proc_numa_maps_operations = {
543 	.open		= numa_maps_open,
544 	.read		= seq_read,
545 	.llseek		= seq_lseek,
546 	.release	= seq_release_private,
547 };
548 #endif
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 
555 const struct file_operations proc_smaps_operations = {
556 	.open		= smaps_open,
557 	.read		= seq_read,
558 	.llseek		= seq_lseek,
559 	.release	= seq_release_private,
560 };
561