blob: e0d64c92e4f6576c38a8a4a7cc9b8d13a2b3362e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001
2#include <linux/mm.h>
3#include <linux/file.h>
Bryan Wueb280622008-05-04 23:12:55 +08004#include <linux/fdtable.h>
Al Viro5ad4e532009-03-29 19:50:06 -04005#include <linux/fs_struct.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/mount.h>
Kees Cook5096add2007-05-08 00:26:04 -07007#include <linux/ptrace.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09008#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/seq_file.h>
10#include "internal.h"
11
12/*
13 * Logic: we've got two memory sums for each process, "shared", and
Frederik Schwarzer025dfda2008-10-16 19:02:37 +020014 * "non-shared". Shared memory may get counted more than once, for
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * each process that owns it. Non-shared memory is counted
16 * accurately.
17 */
Eric W. Biedermandf5f8312008-02-08 04:18:33 -080018void task_mem(struct seq_file *m, struct mm_struct *mm)
Linus Torvalds1da177e2005-04-16 15:20:36 -070019{
David Howells8feae132009-01-08 12:04:47 +000020 struct vm_area_struct *vma;
David Howells38f71472009-01-08 12:04:47 +000021 struct vm_region *region;
David Howells8feae132009-01-08 12:04:47 +000022 struct rb_node *p;
David Howells38f71472009-01-08 12:04:47 +000023 unsigned long bytes = 0, sbytes = 0, slack = 0, size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25 down_read(&mm->mmap_sem);
David Howells8feae132009-01-08 12:04:47 +000026 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
27 vma = rb_entry(p, struct vm_area_struct, vm_rb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
David Howells8feae132009-01-08 12:04:47 +000029 bytes += kobjsize(vma);
David Howells38f71472009-01-08 12:04:47 +000030
31 region = vma->vm_region;
32 if (region) {
33 size = kobjsize(region);
34 size += region->vm_end - region->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 } else {
David Howells38f71472009-01-08 12:04:47 +000036 size = vma->vm_end - vma->vm_start;
37 }
38
39 if (atomic_read(&mm->mm_count) > 1 ||
40 vma->vm_flags & VM_MAYSHARE) {
41 sbytes += size;
42 } else {
43 bytes += size;
44 if (region)
45 slack = region->vm_end - vma->vm_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 }
47 }
48
49 if (atomic_read(&mm->mm_count) > 1)
50 sbytes += kobjsize(mm);
51 else
52 bytes += kobjsize(mm);
53
Al Viro498052b2009-03-30 07:20:30 -040054 if (current->fs && current->fs->users > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 sbytes += kobjsize(current->fs);
56 else
57 bytes += kobjsize(current->fs);
58
59 if (current->files && atomic_read(&current->files->count) > 1)
60 sbytes += kobjsize(current->files);
61 else
62 bytes += kobjsize(current->files);
63
64 if (current->sighand && atomic_read(&current->sighand->count) > 1)
65 sbytes += kobjsize(current->sighand);
66 else
67 bytes += kobjsize(current->sighand);
68
69 bytes += kobjsize(current); /* includes kernel stack */
70
Eric W. Biedermandf5f8312008-02-08 04:18:33 -080071 seq_printf(m,
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 "Mem:\t%8lu bytes\n"
73 "Slack:\t%8lu bytes\n"
74 "Shared:\t%8lu bytes\n",
75 bytes, slack, sbytes);
76
77 up_read(&mm->mmap_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078}
79
80unsigned long task_vsize(struct mm_struct *mm)
81{
David Howells8feae132009-01-08 12:04:47 +000082 struct vm_area_struct *vma;
83 struct rb_node *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 unsigned long vsize = 0;
85
86 down_read(&mm->mmap_sem);
David Howells8feae132009-01-08 12:04:47 +000087 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
88 vma = rb_entry(p, struct vm_area_struct, vm_rb);
David Howells38f71472009-01-08 12:04:47 +000089 vsize += vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 }
91 up_read(&mm->mmap_sem);
92 return vsize;
93}
94
Alexey Dobriyana2ade7b2011-01-12 17:00:32 -080095unsigned long task_statm(struct mm_struct *mm,
96 unsigned long *shared, unsigned long *text,
97 unsigned long *data, unsigned long *resident)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
David Howells8feae132009-01-08 12:04:47 +000099 struct vm_area_struct *vma;
David Howells38f71472009-01-08 12:04:47 +0000100 struct vm_region *region;
David Howells8feae132009-01-08 12:04:47 +0000101 struct rb_node *p;
Alexey Dobriyana2ade7b2011-01-12 17:00:32 -0800102 unsigned long size = kobjsize(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104 down_read(&mm->mmap_sem);
David Howells8feae132009-01-08 12:04:47 +0000105 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
106 vma = rb_entry(p, struct vm_area_struct, vm_rb);
107 size += kobjsize(vma);
David Howells38f71472009-01-08 12:04:47 +0000108 region = vma->vm_region;
109 if (region) {
110 size += kobjsize(region);
111 size += region->vm_end - region->vm_start;
112 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 }
114
Steven J. Magnani7e1e0ef2009-12-14 18:00:04 -0800115 *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
116 >> PAGE_SHIFT;
117 *data = (PAGE_ALIGN(mm->start_stack) - (mm->start_data & PAGE_MASK))
118 >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 up_read(&mm->mmap_sem);
Steven J. Magnani7e1e0ef2009-12-14 18:00:04 -0800120 size >>= PAGE_SHIFT;
121 size += *text + *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 *resident = size;
123 return size;
124}
125
Oleg Nesterov58cb6542014-10-09 15:25:54 -0700126static pid_t pid_of_stack(struct proc_maps_private *priv,
127 struct vm_area_struct *vma, bool is_pid)
128{
129 struct inode *inode = priv->inode;
130 struct task_struct *task;
131 pid_t ret = 0;
132
133 rcu_read_lock();
134 task = pid_task(proc_pid(inode), PIDTYPE_PID);
135 if (task) {
136 task = task_of_stack(task, vma, is_pid);
137 if (task)
138 ret = task_pid_nr_ns(task, inode->i_sb->s_fs_info);
139 }
140 rcu_read_unlock();
141
142 return ret;
143}
144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145/*
David Howells8feae132009-01-08 12:04:47 +0000146 * display a single VMA to a sequenced file
147 */
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700148static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
149 int is_pid)
David Howells8feae132009-01-08 12:04:47 +0000150{
Mike Frysinger3c26c9d2010-06-29 15:05:17 -0700151 struct mm_struct *mm = vma->vm_mm;
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700152 struct proc_maps_private *priv = m->private;
David Howells8feae132009-01-08 12:04:47 +0000153 unsigned long ino = 0;
154 struct file *file;
155 dev_t dev = 0;
Tetsuo Handa652586d2013-11-14 14:31:57 -0800156 int flags;
KAMEZAWA Hiroyuki6260a4b2009-04-06 19:00:30 -0700157 unsigned long long pgoff = 0;
David Howells8feae132009-01-08 12:04:47 +0000158
159 flags = vma->vm_flags;
160 file = vma->vm_file;
161
162 if (file) {
Al Viro496ad9a2013-01-23 17:07:38 -0500163 struct inode *inode = file_inode(vma->vm_file);
David Howells8feae132009-01-08 12:04:47 +0000164 dev = inode->i_sb->s_dev;
165 ino = inode->i_ino;
Nobuhiro Iwamatsu4c967292009-04-07 21:21:43 -0700166 pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
David Howells8feae132009-01-08 12:04:47 +0000167 }
168
Tetsuo Handa652586d2013-11-14 14:31:57 -0800169 seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
David Howells8feae132009-01-08 12:04:47 +0000170 seq_printf(m,
Tetsuo Handa652586d2013-11-14 14:31:57 -0800171 "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
David Howells8feae132009-01-08 12:04:47 +0000172 vma->vm_start,
173 vma->vm_end,
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',
KAMEZAWA Hiroyuki6260a4b2009-04-06 19:00:30 -0700178 pgoff,
Tetsuo Handa652586d2013-11-14 14:31:57 -0800179 MAJOR(dev), MINOR(dev), ino);
David Howells8feae132009-01-08 12:04:47 +0000180
181 if (file) {
Tetsuo Handa652586d2013-11-14 14:31:57 -0800182 seq_pad(m, ' ');
Miklos Szeredi2726d562015-06-19 10:30:28 +0200183 seq_file_path(m, file, "");
Mike Frysinger3c26c9d2010-06-29 15:05:17 -0700184 } else if (mm) {
Oleg Nesterov58cb6542014-10-09 15:25:54 -0700185 pid_t tid = pid_of_stack(priv, vma, is_pid);
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700186
187 if (tid != 0) {
Tetsuo Handa652586d2013-11-14 14:31:57 -0800188 seq_pad(m, ' ');
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700189 /*
190 * Thread stack in /proc/PID/task/TID/maps or
191 * the main process stack.
192 */
193 if (!is_pid || (vma->vm_start <= mm->start_stack &&
194 vma->vm_end >= mm->start_stack))
195 seq_printf(m, "[stack]");
196 else
197 seq_printf(m, "[stack:%d]", tid);
Mike Frysinger3c26c9d2010-06-29 15:05:17 -0700198 }
David Howells8feae132009-01-08 12:04:47 +0000199 }
200
201 seq_putc(m, '\n');
202 return 0;
203}
204
205/*
David Howellsdbf86852006-09-27 01:50:19 -0700206 * display mapping lines for a particular process's /proc/pid/maps
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 */
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700208static int show_map(struct seq_file *m, void *_p, int is_pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
David Howells8feae132009-01-08 12:04:47 +0000210 struct rb_node *p = _p;
Kees Cook5096add2007-05-08 00:26:04 -0700211
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700212 return nommu_vma_show(m, rb_entry(p, struct vm_area_struct, vm_rb),
213 is_pid);
214}
215
216static int show_pid_map(struct seq_file *m, void *_p)
217{
218 return show_map(m, _p, 1);
219}
220
221static int show_tid_map(struct seq_file *m, void *_p)
222{
223 return show_map(m, _p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224}
David Howellsdbf86852006-09-27 01:50:19 -0700225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226static void *m_start(struct seq_file *m, loff_t *pos)
227{
David Howellsdbf86852006-09-27 01:50:19 -0700228 struct proc_maps_private *priv = m->private;
David Howellsdbf86852006-09-27 01:50:19 -0700229 struct mm_struct *mm;
David Howells8feae132009-01-08 12:04:47 +0000230 struct rb_node *p;
David Howellsdbf86852006-09-27 01:50:19 -0700231 loff_t n = *pos;
232
233 /* pin the task and mm whilst we play with them */
Oleg Nesterov2c033762014-10-09 15:25:51 -0700234 priv->task = get_proc_task(priv->inode);
David Howellsdbf86852006-09-27 01:50:19 -0700235 if (!priv->task)
Al Viroec6fd8a2011-02-15 22:22:54 -0500236 return ERR_PTR(-ESRCH);
David Howellsdbf86852006-09-27 01:50:19 -0700237
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700238 mm = priv->mm;
Oleg Nesterov47fecca2014-10-09 15:25:49 -0700239 if (!mm || !atomic_inc_not_zero(&mm->mm_users))
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700240 return NULL;
David Howellsdbf86852006-09-27 01:50:19 -0700241
Oleg Nesterov47fecca2014-10-09 15:25:49 -0700242 down_read(&mm->mmap_sem);
David Howellsdbf86852006-09-27 01:50:19 -0700243 /* start from the Nth VMA */
David Howells8feae132009-01-08 12:04:47 +0000244 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p))
David Howellsdbf86852006-09-27 01:50:19 -0700245 if (n-- == 0)
David Howells8feae132009-01-08 12:04:47 +0000246 return p;
Oleg Nesterov47fecca2014-10-09 15:25:49 -0700247
248 up_read(&mm->mmap_sem);
249 mmput(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 return NULL;
251}
David Howellsdbf86852006-09-27 01:50:19 -0700252
253static void m_stop(struct seq_file *m, void *_vml)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
David Howellsdbf86852006-09-27 01:50:19 -0700255 struct proc_maps_private *priv = m->private;
256
Oleg Nesterov47fecca2014-10-09 15:25:49 -0700257 if (!IS_ERR_OR_NULL(_vml)) {
258 up_read(&priv->mm->mmap_sem);
259 mmput(priv->mm);
260 }
David Howellsdbf86852006-09-27 01:50:19 -0700261 if (priv->task) {
David Howellsdbf86852006-09-27 01:50:19 -0700262 put_task_struct(priv->task);
Oleg Nesterov47fecca2014-10-09 15:25:49 -0700263 priv->task = NULL;
David Howellsdbf86852006-09-27 01:50:19 -0700264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265}
David Howellsdbf86852006-09-27 01:50:19 -0700266
David Howells8feae132009-01-08 12:04:47 +0000267static void *m_next(struct seq_file *m, void *_p, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268{
David Howells8feae132009-01-08 12:04:47 +0000269 struct rb_node *p = _p;
David Howellsdbf86852006-09-27 01:50:19 -0700270
271 (*pos)++;
David Howells8feae132009-01-08 12:04:47 +0000272 return p ? rb_next(p) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
David Howellsdbf86852006-09-27 01:50:19 -0700274
Jan Engelhardt03a44822008-02-08 04:21:19 -0800275static const struct seq_operations proc_pid_maps_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 .start = m_start,
277 .next = m_next,
278 .stop = m_stop,
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700279 .show = show_pid_map
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280};
Eric W. Biederman662795d2006-06-26 00:25:48 -0700281
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700282static const struct seq_operations proc_tid_maps_ops = {
283 .start = m_start,
284 .next = m_next,
285 .stop = m_stop,
286 .show = show_tid_map
287};
288
289static int maps_open(struct inode *inode, struct file *file,
290 const struct seq_operations *ops)
Eric W. Biederman662795d2006-06-26 00:25:48 -0700291{
David Howellsdbf86852006-09-27 01:50:19 -0700292 struct proc_maps_private *priv;
David Howellsdbf86852006-09-27 01:50:19 -0700293
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700294 priv = __seq_open_private(file, ops, sizeof(*priv));
Oleg Nesterovce34fdd2014-10-09 15:25:45 -0700295 if (!priv)
296 return -ENOMEM;
297
Oleg Nesterov2c033762014-10-09 15:25:51 -0700298 priv->inode = inode;
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700299 priv->mm = proc_mem_open(inode, PTRACE_MODE_READ);
300 if (IS_ERR(priv->mm)) {
301 int err = PTR_ERR(priv->mm);
302
303 seq_release_private(inode, file);
304 return err;
305 }
306
Oleg Nesterovce34fdd2014-10-09 15:25:45 -0700307 return 0;
Eric W. Biederman662795d2006-06-26 00:25:48 -0700308}
309
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700310
311static int map_release(struct inode *inode, struct file *file)
312{
313 struct seq_file *seq = file->private_data;
314 struct proc_maps_private *priv = seq->private;
315
316 if (priv->mm)
317 mmdrop(priv->mm);
318
319 return seq_release_private(inode, file);
320}
321
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700322static int pid_maps_open(struct inode *inode, struct file *file)
323{
324 return maps_open(inode, file, &proc_pid_maps_ops);
325}
326
327static int tid_maps_open(struct inode *inode, struct file *file)
328{
329 return maps_open(inode, file, &proc_tid_maps_ops);
330}
331
332const struct file_operations proc_pid_maps_operations = {
333 .open = pid_maps_open,
334 .read = seq_read,
335 .llseek = seq_lseek,
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700336 .release = map_release,
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -0700337};
338
339const struct file_operations proc_tid_maps_operations = {
340 .open = tid_maps_open,
Eric W. Biederman662795d2006-06-26 00:25:48 -0700341 .read = seq_read,
342 .llseek = seq_lseek,
Oleg Nesterov27692cd2014-10-09 15:25:47 -0700343 .release = map_release,
Eric W. Biederman662795d2006-06-26 00:25:48 -0700344};
345