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>
13 * Logic: we've got two memory sums for each process, "shared", and
14 * "non-shared". Shared memory may get counted more than once, for
15 * each process that owns it. Non-shared memory is counted
18 void task_mem(struct seq_file *m, struct mm_struct *mm)
20 struct vm_area_struct *vma;
21 struct vm_region *region;
23 unsigned long bytes = 0, sbytes = 0, slack = 0, size;
25 down_read(&mm->mmap_sem);
26 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
27 vma = rb_entry(p, struct vm_area_struct, vm_rb);
29 bytes += kobjsize(vma);
31 region = vma->vm_region;
33 size = kobjsize(region);
34 size += region->vm_end - region->vm_start;
36 size = vma->vm_end - vma->vm_start;
39 if (atomic_read(&mm->mm_count) > 1 ||
40 vma->vm_flags & VM_MAYSHARE) {
45 slack = region->vm_end - vma->vm_end;
49 if (atomic_read(&mm->mm_count) > 1)
50 sbytes += kobjsize(mm);
52 bytes += kobjsize(mm);
54 if (current->fs && current->fs->users > 1)
55 sbytes += kobjsize(current->fs);
57 bytes += kobjsize(current->fs);
59 if (current->files && atomic_read(¤t->files->count) > 1)
60 sbytes += kobjsize(current->files);
62 bytes += kobjsize(current->files);
64 if (current->sighand && atomic_read(¤t->sighand->count) > 1)
65 sbytes += kobjsize(current->sighand);
67 bytes += kobjsize(current->sighand);
69 bytes += kobjsize(current); /* includes kernel stack */
73 "Slack:\t%8lu bytes\n"
74 "Shared:\t%8lu bytes\n",
75 bytes, slack, sbytes);
77 up_read(&mm->mmap_sem);
80 unsigned long task_vsize(struct mm_struct *mm)
82 struct vm_area_struct *vma;
84 unsigned long vsize = 0;
86 down_read(&mm->mmap_sem);
87 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
88 vma = rb_entry(p, struct vm_area_struct, vm_rb);
89 vsize += vma->vm_end - vma->vm_start;
91 up_read(&mm->mmap_sem);
95 int task_statm(struct mm_struct *mm, int *shared, int *text,
96 int *data, int *resident)
98 struct vm_area_struct *vma;
99 struct vm_region *region;
101 int size = kobjsize(mm);
103 down_read(&mm->mmap_sem);
104 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
105 vma = rb_entry(p, struct vm_area_struct, vm_rb);
106 size += kobjsize(vma);
107 region = vma->vm_region;
109 size += kobjsize(region);
110 size += region->vm_end - region->vm_start;
114 *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
116 *data = (PAGE_ALIGN(mm->start_stack) - (mm->start_data & PAGE_MASK))
118 up_read(&mm->mmap_sem);
120 size += *text + *data;
126 * display a single VMA to a sequenced file
128 static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma)
130 unsigned long ino = 0;
134 unsigned long long pgoff = 0;
136 flags = vma->vm_flags;
140 struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
141 dev = inode->i_sb->s_dev;
143 pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
147 "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n",
150 flags & VM_READ ? 'r' : '-',
151 flags & VM_WRITE ? 'w' : '-',
152 flags & VM_EXEC ? 'x' : '-',
153 flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p',
155 MAJOR(dev), MINOR(dev), ino, &len);
158 len = 25 + sizeof(void *) * 6 - len;
161 seq_printf(m, "%*c", len, ' ');
162 seq_path(m, &file->f_path, "");
170 * display mapping lines for a particular process's /proc/pid/maps
172 static int show_map(struct seq_file *m, void *_p)
174 struct rb_node *p = _p;
176 return nommu_vma_show(m, rb_entry(p, struct vm_area_struct, vm_rb));
179 static void *m_start(struct seq_file *m, loff_t *pos)
181 struct proc_maps_private *priv = m->private;
182 struct mm_struct *mm;
186 /* pin the task and mm whilst we play with them */
187 priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
191 mm = mm_for_maps(priv->task);
193 put_task_struct(priv->task);
197 down_read(&mm->mmap_sem);
199 /* start from the Nth VMA */
200 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p))
206 static void m_stop(struct seq_file *m, void *_vml)
208 struct proc_maps_private *priv = m->private;
211 struct mm_struct *mm = priv->task->mm;
212 up_read(&mm->mmap_sem);
214 put_task_struct(priv->task);
218 static void *m_next(struct seq_file *m, void *_p, loff_t *pos)
220 struct rb_node *p = _p;
223 return p ? rb_next(p) : NULL;
226 static const struct seq_operations proc_pid_maps_ops = {
233 static int maps_open(struct inode *inode, struct file *file)
235 struct proc_maps_private *priv;
238 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
240 priv->pid = proc_pid(inode);
241 ret = seq_open(file, &proc_pid_maps_ops);
243 struct seq_file *m = file->private_data;
252 const struct file_operations proc_maps_operations = {
256 .release = seq_release_private,