3 #include <linux/file.h>
4 #include <linux/fdtable.h>
5 #include <linux/fs_struct.h>
6 #include <linux/mount.h>
7 #include <linux/ptrace.h>
8 #include <linux/slab.h>
9 #include <linux/seq_file.h>
10 #include <linux/sched/mm.h>
15 * Logic: we've got two memory sums for each process, "shared", and
16 * "non-shared". Shared memory may get counted more than once, for
17 * each process that owns it. Non-shared memory is counted
20 void task_mem(struct seq_file
*m
, struct mm_struct
*mm
)
22 struct vm_area_struct
*vma
;
23 struct vm_region
*region
;
25 unsigned long bytes
= 0, sbytes
= 0, slack
= 0, size
;
27 down_read(&mm
->mmap_sem
);
28 for (p
= rb_first(&mm
->mm_rb
); p
; p
= rb_next(p
)) {
29 vma
= rb_entry(p
, struct vm_area_struct
, vm_rb
);
31 bytes
+= kobjsize(vma
);
33 region
= vma
->vm_region
;
35 size
= kobjsize(region
);
36 size
+= region
->vm_end
- region
->vm_start
;
38 size
= vma
->vm_end
- vma
->vm_start
;
41 if (atomic_read(&mm
->mm_count
) > 1 ||
42 vma
->vm_flags
& VM_MAYSHARE
) {
47 slack
= region
->vm_end
- vma
->vm_end
;
51 if (atomic_read(&mm
->mm_count
) > 1)
52 sbytes
+= kobjsize(mm
);
54 bytes
+= kobjsize(mm
);
56 if (current
->fs
&& current
->fs
->users
> 1)
57 sbytes
+= kobjsize(current
->fs
);
59 bytes
+= kobjsize(current
->fs
);
61 if (current
->files
&& atomic_read(¤t
->files
->count
) > 1)
62 sbytes
+= kobjsize(current
->files
);
64 bytes
+= kobjsize(current
->files
);
66 if (current
->sighand
&& atomic_read(¤t
->sighand
->count
) > 1)
67 sbytes
+= kobjsize(current
->sighand
);
69 bytes
+= kobjsize(current
->sighand
);
71 bytes
+= kobjsize(current
); /* includes kernel stack */
75 "Slack:\t%8lu bytes\n"
76 "Shared:\t%8lu bytes\n",
77 bytes
, slack
, sbytes
);
79 up_read(&mm
->mmap_sem
);
82 unsigned long task_vsize(struct mm_struct
*mm
)
84 struct vm_area_struct
*vma
;
86 unsigned long vsize
= 0;
88 down_read(&mm
->mmap_sem
);
89 for (p
= rb_first(&mm
->mm_rb
); p
; p
= rb_next(p
)) {
90 vma
= rb_entry(p
, struct vm_area_struct
, vm_rb
);
91 vsize
+= vma
->vm_end
- vma
->vm_start
;
93 up_read(&mm
->mmap_sem
);
97 unsigned long task_statm(struct mm_struct
*mm
,
98 unsigned long *shared
, unsigned long *text
,
99 unsigned long *data
, unsigned long *resident
)
101 struct vm_area_struct
*vma
;
102 struct vm_region
*region
;
104 unsigned long size
= kobjsize(mm
);
106 down_read(&mm
->mmap_sem
);
107 for (p
= rb_first(&mm
->mm_rb
); p
; p
= rb_next(p
)) {
108 vma
= rb_entry(p
, struct vm_area_struct
, vm_rb
);
109 size
+= kobjsize(vma
);
110 region
= vma
->vm_region
;
112 size
+= kobjsize(region
);
113 size
+= region
->vm_end
- region
->vm_start
;
117 *text
= (PAGE_ALIGN(mm
->end_code
) - (mm
->start_code
& PAGE_MASK
))
119 *data
= (PAGE_ALIGN(mm
->start_stack
) - (mm
->start_data
& PAGE_MASK
))
121 up_read(&mm
->mmap_sem
);
123 size
+= *text
+ *data
;
128 static int is_stack(struct proc_maps_private
*priv
,
129 struct vm_area_struct
*vma
)
131 struct mm_struct
*mm
= vma
->vm_mm
;
134 * We make no effort to guess what a given thread considers to be
135 * its "stack". It's not even well-defined for programs written
138 return vma
->vm_start
<= mm
->start_stack
&&
139 vma
->vm_end
>= mm
->start_stack
;
143 * display a single VMA to a sequenced file
145 static int nommu_vma_show(struct seq_file
*m
, struct vm_area_struct
*vma
,
148 struct mm_struct
*mm
= vma
->vm_mm
;
149 struct proc_maps_private
*priv
= m
->private;
150 unsigned long ino
= 0;
154 unsigned long long pgoff
= 0;
156 flags
= vma
->vm_flags
;
162 file
= vma_pr_or_file(vma
);
163 inode
= file_inode(file
);
164 dev
= inode
->i_sb
->s_dev
;
166 pgoff
= (loff_t
)vma
->vm_pgoff
<< PAGE_SHIFT
;
169 seq_setwidth(m
, 25 + sizeof(void *) * 6 - 1);
171 "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
174 flags
& VM_READ
? 'r' : '-',
175 flags
& VM_WRITE
? 'w' : '-',
176 flags
& VM_EXEC
? 'x' : '-',
177 flags
& VM_MAYSHARE
? flags
& VM_SHARED
? 'S' : 's' : 'p',
179 MAJOR(dev
), MINOR(dev
), ino
);
183 seq_file_path(m
, file
, "");
184 } else if (mm
&& is_stack(priv
, vma
)) {
186 seq_printf(m
, "[stack]");
194 * display mapping lines for a particular process's /proc/pid/maps
196 static int show_map(struct seq_file
*m
, void *_p
, int is_pid
)
198 struct rb_node
*p
= _p
;
200 return nommu_vma_show(m
, rb_entry(p
, struct vm_area_struct
, vm_rb
),
204 static int show_pid_map(struct seq_file
*m
, void *_p
)
206 return show_map(m
, _p
, 1);
209 static int show_tid_map(struct seq_file
*m
, void *_p
)
211 return show_map(m
, _p
, 0);
214 static void *m_start(struct seq_file
*m
, loff_t
*pos
)
216 struct proc_maps_private
*priv
= m
->private;
217 struct mm_struct
*mm
;
221 /* pin the task and mm whilst we play with them */
222 priv
->task
= get_proc_task(priv
->inode
);
224 return ERR_PTR(-ESRCH
);
227 if (!mm
|| !mmget_not_zero(mm
))
230 down_read(&mm
->mmap_sem
);
231 /* start from the Nth VMA */
232 for (p
= rb_first(&mm
->mm_rb
); p
; p
= rb_next(p
))
236 up_read(&mm
->mmap_sem
);
241 static void m_stop(struct seq_file
*m
, void *_vml
)
243 struct proc_maps_private
*priv
= m
->private;
245 if (!IS_ERR_OR_NULL(_vml
)) {
246 up_read(&priv
->mm
->mmap_sem
);
250 put_task_struct(priv
->task
);
255 static void *m_next(struct seq_file
*m
, void *_p
, loff_t
*pos
)
257 struct rb_node
*p
= _p
;
260 return p
? rb_next(p
) : NULL
;
263 static const struct seq_operations proc_pid_maps_ops
= {
270 static const struct seq_operations proc_tid_maps_ops
= {
277 static int maps_open(struct inode
*inode
, struct file
*file
,
278 const struct seq_operations
*ops
)
280 struct proc_maps_private
*priv
;
282 priv
= __seq_open_private(file
, ops
, sizeof(*priv
));
287 priv
->mm
= proc_mem_open(inode
, PTRACE_MODE_READ
);
288 if (IS_ERR(priv
->mm
)) {
289 int err
= PTR_ERR(priv
->mm
);
291 seq_release_private(inode
, file
);
299 static int map_release(struct inode
*inode
, struct file
*file
)
301 struct seq_file
*seq
= file
->private_data
;
302 struct proc_maps_private
*priv
= seq
->private;
307 return seq_release_private(inode
, file
);
310 static int pid_maps_open(struct inode
*inode
, struct file
*file
)
312 return maps_open(inode
, file
, &proc_pid_maps_ops
);
315 static int tid_maps_open(struct inode
*inode
, struct file
*file
)
317 return maps_open(inode
, file
, &proc_tid_maps_ops
);
320 const struct file_operations proc_pid_maps_operations
= {
321 .open
= pid_maps_open
,
324 .release
= map_release
,
327 const struct file_operations proc_tid_maps_operations
= {
328 .open
= tid_maps_open
,
331 .release
= map_release
,