2 #include <linux/hugetlb.h>
3 #include <linux/mount.h>
4 #include <linux/seq_file.h>
5 #include <linux/highmem.h>
6 #include <linux/pagemap.h>
7 #include <linux/mempolicy.h>
10 #include <asm/uaccess.h>
11 #include <asm/tlbflush.h>
14 char *task_mem(struct mm_struct
*mm
, char *buffer
)
16 unsigned long data
, text
, lib
;
18 data
= mm
->total_vm
- mm
->shared_vm
- mm
->stack_vm
;
19 text
= (PAGE_ALIGN(mm
->end_code
) - (mm
->start_code
& PAGE_MASK
)) >> 10;
20 lib
= (mm
->exec_vm
<< (PAGE_SHIFT
-10)) - text
;
21 buffer
+= sprintf(buffer
,
30 (mm
->total_vm
- mm
->reserved_vm
) << (PAGE_SHIFT
-10),
31 mm
->locked_vm
<< (PAGE_SHIFT
-10),
32 get_mm_rss(mm
) << (PAGE_SHIFT
-10),
33 data
<< (PAGE_SHIFT
-10),
34 mm
->stack_vm
<< (PAGE_SHIFT
-10), text
, lib
,
35 (PTRS_PER_PTE
*sizeof(pte_t
)*mm
->nr_ptes
) >> 10);
39 unsigned long task_vsize(struct mm_struct
*mm
)
41 return PAGE_SIZE
* mm
->total_vm
;
44 int task_statm(struct mm_struct
*mm
, int *shared
, int *text
,
45 int *data
, int *resident
)
47 *shared
= get_mm_counter(mm
, file_rss
);
48 *text
= (PAGE_ALIGN(mm
->end_code
) - (mm
->start_code
& PAGE_MASK
))
50 *data
= mm
->total_vm
- mm
->shared_vm
;
51 *resident
= *shared
+ get_mm_counter(mm
, anon_rss
);
55 int proc_exe_link(struct inode
*inode
, struct dentry
**dentry
, struct vfsmount
**mnt
)
57 struct vm_area_struct
* vma
;
59 struct task_struct
*task
= proc_task(inode
);
60 struct mm_struct
* mm
= get_task_mm(task
);
64 down_read(&mm
->mmap_sem
);
68 if ((vma
->vm_flags
& VM_EXECUTABLE
) && vma
->vm_file
)
74 *mnt
= mntget(vma
->vm_file
->f_vfsmnt
);
75 *dentry
= dget(vma
->vm_file
->f_dentry
);
79 up_read(&mm
->mmap_sem
);
85 static void pad_len_spaces(struct seq_file
*m
, int len
)
87 len
= 25 + sizeof(void*) * 6 - len
;
90 seq_printf(m
, "%*c", len
, ' ');
95 unsigned long resident
;
96 unsigned long shared_clean
;
97 unsigned long shared_dirty
;
98 unsigned long private_clean
;
99 unsigned long private_dirty
;
102 static int show_map_internal(struct seq_file
*m
, void *v
, struct mem_size_stats
*mss
)
104 struct task_struct
*task
= m
->private;
105 struct vm_area_struct
*vma
= v
;
106 struct mm_struct
*mm
= vma
->vm_mm
;
107 struct file
*file
= vma
->vm_file
;
108 int flags
= vma
->vm_flags
;
109 unsigned long ino
= 0;
114 struct inode
*inode
= vma
->vm_file
->f_dentry
->d_inode
;
115 dev
= inode
->i_sb
->s_dev
;
119 seq_printf(m
, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
122 flags
& VM_READ
? 'r' : '-',
123 flags
& VM_WRITE
? 'w' : '-',
124 flags
& VM_EXEC
? 'x' : '-',
125 flags
& VM_MAYSHARE
? 's' : 'p',
126 vma
->vm_pgoff
<< PAGE_SHIFT
,
127 MAJOR(dev
), MINOR(dev
), ino
, &len
);
130 * Print the dentry name for named mappings, and a
131 * special [heap] marker for the heap:
134 pad_len_spaces(m
, len
);
135 seq_path(m
, file
->f_vfsmnt
, file
->f_dentry
, "\n");
138 if (vma
->vm_start
<= mm
->start_brk
&&
139 vma
->vm_end
>= mm
->brk
) {
140 pad_len_spaces(m
, len
);
141 seq_puts(m
, "[heap]");
143 if (vma
->vm_start
<= mm
->start_stack
&&
144 vma
->vm_end
>= mm
->start_stack
) {
146 pad_len_spaces(m
, len
);
147 seq_puts(m
, "[stack]");
151 pad_len_spaces(m
, len
);
152 seq_puts(m
, "[vdso]");
161 "Shared_Clean: %8lu kB\n"
162 "Shared_Dirty: %8lu kB\n"
163 "Private_Clean: %8lu kB\n"
164 "Private_Dirty: %8lu kB\n",
165 (vma
->vm_end
- vma
->vm_start
) >> 10,
167 mss
->shared_clean
>> 10,
168 mss
->shared_dirty
>> 10,
169 mss
->private_clean
>> 10,
170 mss
->private_dirty
>> 10);
172 if (m
->count
< m
->size
) /* vma is copied successfully */
173 m
->version
= (vma
!= get_gate_vma(task
))? vma
->vm_start
: 0;
177 static int show_map(struct seq_file
*m
, void *v
)
179 return show_map_internal(m
, v
, 0);
182 static void smaps_pte_range(struct vm_area_struct
*vma
, pmd_t
*pmd
,
183 unsigned long addr
, unsigned long end
,
184 struct mem_size_stats
*mss
)
190 pte
= pte_offset_map(pmd
, addr
);
193 if (pte_none(ptent
) || !pte_present(ptent
))
196 mss
->resident
+= PAGE_SIZE
;
197 pfn
= pte_pfn(ptent
);
201 page
= pfn_to_page(pfn
);
202 if (page_count(page
) >= 2) {
203 if (pte_dirty(ptent
))
204 mss
->shared_dirty
+= PAGE_SIZE
;
206 mss
->shared_clean
+= PAGE_SIZE
;
208 if (pte_dirty(ptent
))
209 mss
->private_dirty
+= PAGE_SIZE
;
211 mss
->private_clean
+= PAGE_SIZE
;
213 } while (pte
++, addr
+= PAGE_SIZE
, addr
!= end
);
215 cond_resched_lock(&vma
->vm_mm
->page_table_lock
);
218 static inline void smaps_pmd_range(struct vm_area_struct
*vma
, pud_t
*pud
,
219 unsigned long addr
, unsigned long end
,
220 struct mem_size_stats
*mss
)
225 pmd
= pmd_offset(pud
, addr
);
227 next
= pmd_addr_end(addr
, end
);
228 if (pmd_none_or_clear_bad(pmd
))
230 smaps_pte_range(vma
, pmd
, addr
, next
, mss
);
231 } while (pmd
++, addr
= next
, addr
!= end
);
234 static inline void smaps_pud_range(struct vm_area_struct
*vma
, pgd_t
*pgd
,
235 unsigned long addr
, unsigned long end
,
236 struct mem_size_stats
*mss
)
241 pud
= pud_offset(pgd
, addr
);
243 next
= pud_addr_end(addr
, end
);
244 if (pud_none_or_clear_bad(pud
))
246 smaps_pmd_range(vma
, pud
, addr
, next
, mss
);
247 } while (pud
++, addr
= next
, addr
!= end
);
250 static inline void smaps_pgd_range(struct vm_area_struct
*vma
,
251 unsigned long addr
, unsigned long end
,
252 struct mem_size_stats
*mss
)
257 pgd
= pgd_offset(vma
->vm_mm
, addr
);
259 next
= pgd_addr_end(addr
, end
);
260 if (pgd_none_or_clear_bad(pgd
))
262 smaps_pud_range(vma
, pgd
, addr
, next
, mss
);
263 } while (pgd
++, addr
= next
, addr
!= end
);
266 static int show_smap(struct seq_file
*m
, void *v
)
268 struct vm_area_struct
*vma
= v
;
269 struct mm_struct
*mm
= vma
->vm_mm
;
270 struct mem_size_stats mss
;
272 memset(&mss
, 0, sizeof mss
);
275 spin_lock(&mm
->page_table_lock
);
276 smaps_pgd_range(vma
, vma
->vm_start
, vma
->vm_end
, &mss
);
277 spin_unlock(&mm
->page_table_lock
);
280 return show_map_internal(m
, v
, &mss
);
283 static void *m_start(struct seq_file
*m
, loff_t
*pos
)
285 struct task_struct
*task
= m
->private;
286 unsigned long last_addr
= m
->version
;
287 struct mm_struct
*mm
;
288 struct vm_area_struct
*vma
, *tail_vma
;
292 * We remember last_addr rather than next_addr to hit with
293 * mmap_cache most of the time. We have zero last_addr at
294 * the beginning and also after lseek. We will have -1 last_addr
295 * after the end of the vmas.
298 if (last_addr
== -1UL)
301 mm
= get_task_mm(task
);
305 tail_vma
= get_gate_vma(task
);
306 down_read(&mm
->mmap_sem
);
308 /* Start with last addr hint */
309 if (last_addr
&& (vma
= find_vma(mm
, last_addr
))) {
315 * Check the vma index is within the range and do
316 * sequential scan until m_index.
319 if ((unsigned long)l
< mm
->map_count
) {
326 if (l
!= mm
->map_count
)
327 tail_vma
= NULL
; /* After gate vma */
333 /* End of vmas has been reached */
334 m
->version
= (tail_vma
!= NULL
)? 0: -1UL;
335 up_read(&mm
->mmap_sem
);
340 static void m_stop(struct seq_file
*m
, void *v
)
342 struct task_struct
*task
= m
->private;
343 struct vm_area_struct
*vma
= v
;
344 if (vma
&& vma
!= get_gate_vma(task
)) {
345 struct mm_struct
*mm
= vma
->vm_mm
;
346 up_read(&mm
->mmap_sem
);
351 static void *m_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
353 struct task_struct
*task
= m
->private;
354 struct vm_area_struct
*vma
= v
;
355 struct vm_area_struct
*tail_vma
= get_gate_vma(task
);
358 if (vma
&& (vma
!= tail_vma
) && vma
->vm_next
)
361 return (vma
!= tail_vma
)? tail_vma
: NULL
;
364 struct seq_operations proc_pid_maps_op
= {
371 struct seq_operations proc_pid_smaps_op
= {
383 unsigned long mapped
;
384 unsigned long mapcount_max
;
385 unsigned long node
[MAX_NUMNODES
];
389 * Calculate numa node maps for a vma
391 static struct numa_maps
*get_numa_maps(const struct vm_area_struct
*vma
)
395 struct mm_struct
*mm
= vma
->vm_mm
;
397 struct numa_maps
*md
= kmalloc(sizeof(struct numa_maps
), GFP_KERNEL
);
404 md
->mapcount_max
= 0;
408 spin_lock(&mm
->page_table_lock
);
409 for (vaddr
= vma
->vm_start
; vaddr
< vma
->vm_end
; vaddr
+= PAGE_SIZE
) {
410 page
= follow_page(mm
, vaddr
, 0);
412 int count
= page_mapcount(page
);
416 if (count
> md
->mapcount_max
)
417 md
->mapcount_max
= count
;
421 md
->node
[page_to_nid(page
)]++;
424 spin_unlock(&mm
->page_table_lock
);
428 static int show_numa_map(struct seq_file
*m
, void *v
)
430 struct task_struct
*task
= m
->private;
431 struct vm_area_struct
*vma
= v
;
432 struct mempolicy
*pol
;
433 struct numa_maps
*md
;
441 md
= get_numa_maps(vma
);
445 seq_printf(m
, "%08lx", vma
->vm_start
);
446 pol
= get_vma_policy(task
, vma
, vma
->vm_start
);
448 switch (pol
->policy
) {
450 seq_printf(m
, " prefer=%d", pol
->v
.preferred_node
);
453 seq_printf(m
, " bind={");
455 for (z
= pol
->v
.zonelist
->zones
; *z
; z
++) {
461 seq_printf(m
, "%d/%s", (*z
)->zone_pgdat
->node_id
,
466 case MPOL_INTERLEAVE
:
467 seq_printf(m
, " interleave={");
470 if (node_isset(n
, pol
->v
.nodes
)) {
475 seq_printf(m
, "%d",n
);
481 seq_printf(m
," default");
484 seq_printf(m
, " MaxRef=%lu Pages=%lu Mapped=%lu",
485 md
->mapcount_max
, md
->pages
, md
->mapped
);
487 seq_printf(m
," Anon=%lu",md
->anon
);
489 for_each_online_node(n
) {
491 seq_printf(m
, " N%d=%lu", n
, md
->node
[n
]);
495 if (m
->count
< m
->size
) /* vma is copied successfully */
496 m
->version
= (vma
!= get_gate_vma(task
)) ? vma
->vm_start
: 0;
500 struct seq_operations proc_pid_numa_maps_op
= {
504 .show
= show_numa_map