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>
11 #include <asm/uaccess.h>
12 #include <asm/tlbflush.h>
15 char *task_mem(struct mm_struct
*mm
, char *buffer
)
17 unsigned long data
, text
, lib
;
18 unsigned long hiwater_vm
, total_vm
, hiwater_rss
, total_rss
;
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.
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
;
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
,
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);
59 unsigned long task_vsize(struct mm_struct
*mm
)
61 return PAGE_SIZE
* mm
->total_vm
;
64 int task_statm(struct mm_struct
*mm
, int *shared
, int *text
,
65 int *data
, int *resident
)
67 *shared
= get_mm_counter(mm
, file_rss
);
68 *text
= (PAGE_ALIGN(mm
->end_code
) - (mm
->start_code
& PAGE_MASK
))
70 *data
= mm
->total_vm
- mm
->shared_vm
;
71 *resident
= *shared
+ get_mm_counter(mm
, anon_rss
);
75 int proc_exe_link(struct inode
*inode
, struct dentry
**dentry
, struct vfsmount
**mnt
)
77 struct vm_area_struct
* vma
;
79 struct task_struct
*task
= get_proc_task(inode
);
80 struct mm_struct
* mm
= NULL
;
83 mm
= get_task_mm(task
);
84 put_task_struct(task
);
88 down_read(&mm
->mmap_sem
);
92 if ((vma
->vm_flags
& VM_EXECUTABLE
) && vma
->vm_file
)
98 *mnt
= mntget(vma
->vm_file
->f_path
.mnt
);
99 *dentry
= dget(vma
->vm_file
->f_path
.dentry
);
103 up_read(&mm
->mmap_sem
);
109 static void pad_len_spaces(struct seq_file
*m
, int len
)
111 len
= 25 + sizeof(void*) * 6 - len
;
114 seq_printf(m
, "%*c", len
, ' ');
118 * Proportional Set Size(PSS): my share of RSS.
120 * PSS of a process is the count of pages it has in memory, where each
121 * page is divided by the number of processes sharing it. So if a
122 * process has 1000 pages all to itself, and 1000 shared with one other
123 * process, its PSS will be 1500.
125 * To keep (accumulated) division errors low, we adopt a 64bit
126 * fixed-point pss counter to minimize division errors. So (pss >>
127 * PSS_SHIFT) would be the real byte count.
129 * A shift of 12 before division means (assuming 4K page size):
130 * - 1M 3-user-pages add up to 8KB errors;
131 * - supports mapcount up to 2^24, or 16M;
132 * - supports PSS up to 2^52 bytes, or 4PB.
136 struct mem_size_stats
138 unsigned long resident
;
139 unsigned long shared_clean
;
140 unsigned long shared_dirty
;
141 unsigned long private_clean
;
142 unsigned long private_dirty
;
143 unsigned long referenced
;
148 struct vm_area_struct
*vma
;
150 void (*action
)(struct vm_area_struct
*, pmd_t
*, unsigned long,
151 unsigned long, void *);
154 static int show_map_internal(struct seq_file
*m
, void *v
, struct mem_size_stats
*mss
)
156 struct proc_maps_private
*priv
= m
->private;
157 struct task_struct
*task
= priv
->task
;
158 struct vm_area_struct
*vma
= v
;
159 struct mm_struct
*mm
= vma
->vm_mm
;
160 struct file
*file
= vma
->vm_file
;
161 int flags
= vma
->vm_flags
;
162 unsigned long ino
= 0;
166 if (maps_protect
&& !ptrace_may_attach(task
))
170 struct inode
*inode
= vma
->vm_file
->f_path
.dentry
->d_inode
;
171 dev
= inode
->i_sb
->s_dev
;
175 seq_printf(m
, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
178 flags
& VM_READ
? 'r' : '-',
179 flags
& VM_WRITE
? 'w' : '-',
180 flags
& VM_EXEC
? 'x' : '-',
181 flags
& VM_MAYSHARE
? 's' : 'p',
182 vma
->vm_pgoff
<< PAGE_SHIFT
,
183 MAJOR(dev
), MINOR(dev
), ino
, &len
);
186 * Print the dentry name for named mappings, and a
187 * special [heap] marker for the heap:
190 pad_len_spaces(m
, len
);
191 seq_path(m
, file
->f_path
.mnt
, file
->f_path
.dentry
, "\n");
193 const char *name
= arch_vma_name(vma
);
196 if (vma
->vm_start
<= mm
->start_brk
&&
197 vma
->vm_end
>= mm
->brk
) {
199 } else if (vma
->vm_start
<= mm
->start_stack
&&
200 vma
->vm_end
>= mm
->start_stack
) {
208 pad_len_spaces(m
, len
);
219 "Shared_Clean: %8lu kB\n"
220 "Shared_Dirty: %8lu kB\n"
221 "Private_Clean: %8lu kB\n"
222 "Private_Dirty: %8lu kB\n"
223 "Referenced: %8lu kB\n",
224 (vma
->vm_end
- vma
->vm_start
) >> 10,
226 (unsigned long)(mss
->pss
>> (10 + PSS_SHIFT
)),
227 mss
->shared_clean
>> 10,
228 mss
->shared_dirty
>> 10,
229 mss
->private_clean
>> 10,
230 mss
->private_dirty
>> 10,
231 mss
->referenced
>> 10);
233 if (m
->count
< m
->size
) /* vma is copied successfully */
234 m
->version
= (vma
!= get_gate_vma(task
))? vma
->vm_start
: 0;
238 static int show_map(struct seq_file
*m
, void *v
)
240 return show_map_internal(m
, v
, NULL
);
243 static void smaps_pte_range(struct vm_area_struct
*vma
, pmd_t
*pmd
,
244 unsigned long addr
, unsigned long end
,
247 struct mem_size_stats
*mss
= private;
253 pte
= pte_offset_map_lock(vma
->vm_mm
, pmd
, addr
, &ptl
);
254 for (; addr
!= end
; pte
++, addr
+= PAGE_SIZE
) {
256 if (!pte_present(ptent
))
259 mss
->resident
+= PAGE_SIZE
;
261 page
= vm_normal_page(vma
, addr
, ptent
);
265 /* Accumulate the size in pages that have been accessed. */
266 if (pte_young(ptent
) || PageReferenced(page
))
267 mss
->referenced
+= PAGE_SIZE
;
268 mapcount
= page_mapcount(page
);
270 if (pte_dirty(ptent
))
271 mss
->shared_dirty
+= PAGE_SIZE
;
273 mss
->shared_clean
+= PAGE_SIZE
;
274 mss
->pss
+= (PAGE_SIZE
<< PSS_SHIFT
) / mapcount
;
276 if (pte_dirty(ptent
))
277 mss
->private_dirty
+= PAGE_SIZE
;
279 mss
->private_clean
+= PAGE_SIZE
;
280 mss
->pss
+= (PAGE_SIZE
<< PSS_SHIFT
);
283 pte_unmap_unlock(pte
- 1, ptl
);
287 static void clear_refs_pte_range(struct vm_area_struct
*vma
, pmd_t
*pmd
,
288 unsigned long addr
, unsigned long end
,
295 pte
= pte_offset_map_lock(vma
->vm_mm
, pmd
, addr
, &ptl
);
296 for (; addr
!= end
; pte
++, addr
+= PAGE_SIZE
) {
298 if (!pte_present(ptent
))
301 page
= vm_normal_page(vma
, addr
, ptent
);
305 /* Clear accessed and referenced bits. */
306 ptep_test_and_clear_young(vma
, addr
, pte
);
307 ClearPageReferenced(page
);
309 pte_unmap_unlock(pte
- 1, ptl
);
313 static inline void walk_pmd_range(struct pmd_walker
*walker
, pud_t
*pud
,
314 unsigned long addr
, unsigned long end
)
319 for (pmd
= pmd_offset(pud
, addr
); addr
!= end
;
320 pmd
++, addr
= next
) {
321 next
= pmd_addr_end(addr
, end
);
322 if (pmd_none_or_clear_bad(pmd
))
324 walker
->action(walker
->vma
, pmd
, addr
, next
, walker
->private);
328 static inline void walk_pud_range(struct pmd_walker
*walker
, pgd_t
*pgd
,
329 unsigned long addr
, unsigned long end
)
334 for (pud
= pud_offset(pgd
, addr
); addr
!= end
;
335 pud
++, addr
= next
) {
336 next
= pud_addr_end(addr
, end
);
337 if (pud_none_or_clear_bad(pud
))
339 walk_pmd_range(walker
, pud
, addr
, next
);
344 * walk_page_range - walk the page tables of a VMA with a callback
346 * @action - callback invoked for every bottom-level (PTE) page table
347 * @private - private data passed to the callback function
349 * Recursively walk the page table for the memory area in a VMA, calling
350 * a callback for every bottom-level (PTE) page table.
352 static inline void walk_page_range(struct vm_area_struct
*vma
,
353 void (*action
)(struct vm_area_struct
*,
354 pmd_t
*, unsigned long,
355 unsigned long, void *),
358 unsigned long addr
= vma
->vm_start
;
359 unsigned long end
= vma
->vm_end
;
360 struct pmd_walker walker
= {
368 for (pgd
= pgd_offset(vma
->vm_mm
, addr
); addr
!= end
;
369 pgd
++, addr
= next
) {
370 next
= pgd_addr_end(addr
, end
);
371 if (pgd_none_or_clear_bad(pgd
))
373 walk_pud_range(&walker
, pgd
, addr
, next
);
377 static int show_smap(struct seq_file
*m
, void *v
)
379 struct vm_area_struct
*vma
= v
;
380 struct mem_size_stats mss
;
382 memset(&mss
, 0, sizeof mss
);
383 if (vma
->vm_mm
&& !is_vm_hugetlb_page(vma
))
384 walk_page_range(vma
, smaps_pte_range
, &mss
);
385 return show_map_internal(m
, v
, &mss
);
388 void clear_refs_smap(struct mm_struct
*mm
)
390 struct vm_area_struct
*vma
;
392 down_read(&mm
->mmap_sem
);
393 for (vma
= mm
->mmap
; vma
; vma
= vma
->vm_next
)
394 if (vma
->vm_mm
&& !is_vm_hugetlb_page(vma
))
395 walk_page_range(vma
, clear_refs_pte_range
, NULL
);
397 up_read(&mm
->mmap_sem
);
400 static void *m_start(struct seq_file
*m
, loff_t
*pos
)
402 struct proc_maps_private
*priv
= m
->private;
403 unsigned long last_addr
= m
->version
;
404 struct mm_struct
*mm
;
405 struct vm_area_struct
*vma
, *tail_vma
= NULL
;
408 /* Clear the per syscall fields in priv */
410 priv
->tail_vma
= NULL
;
413 * We remember last_addr rather than next_addr to hit with
414 * mmap_cache most of the time. We have zero last_addr at
415 * the beginning and also after lseek. We will have -1 last_addr
416 * after the end of the vmas.
419 if (last_addr
== -1UL)
422 priv
->task
= get_pid_task(priv
->pid
, PIDTYPE_PID
);
426 mm
= mm_for_maps(priv
->task
);
430 priv
->tail_vma
= tail_vma
= get_gate_vma(priv
->task
);
432 /* Start with last addr hint */
433 if (last_addr
&& (vma
= find_vma(mm
, last_addr
))) {
439 * Check the vma index is within the range and do
440 * sequential scan until m_index.
443 if ((unsigned long)l
< mm
->map_count
) {
450 if (l
!= mm
->map_count
)
451 tail_vma
= NULL
; /* After gate vma */
457 /* End of vmas has been reached */
458 m
->version
= (tail_vma
!= NULL
)? 0: -1UL;
459 up_read(&mm
->mmap_sem
);
464 static void vma_stop(struct proc_maps_private
*priv
, struct vm_area_struct
*vma
)
466 if (vma
&& vma
!= priv
->tail_vma
) {
467 struct mm_struct
*mm
= vma
->vm_mm
;
468 up_read(&mm
->mmap_sem
);
473 static void *m_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
475 struct proc_maps_private
*priv
= m
->private;
476 struct vm_area_struct
*vma
= v
;
477 struct vm_area_struct
*tail_vma
= priv
->tail_vma
;
480 if (vma
&& (vma
!= tail_vma
) && vma
->vm_next
)
483 return (vma
!= tail_vma
)? tail_vma
: NULL
;
486 static void m_stop(struct seq_file
*m
, void *v
)
488 struct proc_maps_private
*priv
= m
->private;
489 struct vm_area_struct
*vma
= v
;
493 put_task_struct(priv
->task
);
496 static struct seq_operations proc_pid_maps_op
= {
503 static struct seq_operations proc_pid_smaps_op
= {
510 static int do_maps_open(struct inode
*inode
, struct file
*file
,
511 struct seq_operations
*ops
)
513 struct proc_maps_private
*priv
;
515 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
517 priv
->pid
= proc_pid(inode
);
518 ret
= seq_open(file
, ops
);
520 struct seq_file
*m
= file
->private_data
;
529 static int maps_open(struct inode
*inode
, struct file
*file
)
531 return do_maps_open(inode
, file
, &proc_pid_maps_op
);
534 const struct file_operations proc_maps_operations
= {
538 .release
= seq_release_private
,
542 extern int show_numa_map(struct seq_file
*m
, void *v
);
544 static int show_numa_map_checked(struct seq_file
*m
, void *v
)
546 struct proc_maps_private
*priv
= m
->private;
547 struct task_struct
*task
= priv
->task
;
549 if (maps_protect
&& !ptrace_may_attach(task
))
552 return show_numa_map(m
, v
);
555 static struct seq_operations proc_pid_numa_maps_op
= {
559 .show
= show_numa_map_checked
562 static int numa_maps_open(struct inode
*inode
, struct file
*file
)
564 return do_maps_open(inode
, file
, &proc_pid_numa_maps_op
);
567 const struct file_operations proc_numa_maps_operations
= {
568 .open
= numa_maps_open
,
571 .release
= seq_release_private
,
575 static int smaps_open(struct inode
*inode
, struct file
*file
)
577 return do_maps_open(inode
, file
, &proc_pid_smaps_op
);
580 const struct file_operations proc_smaps_operations
= {
584 .release
= seq_release_private
,