Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | |
3 | #include <linux/mm.h> | |
4 | #include <linux/file.h> | |
eb28062f | 5 | #include <linux/fdtable.h> |
5ad4e53b | 6 | #include <linux/fs_struct.h> |
1da177e4 | 7 | #include <linux/mount.h> |
5096add8 | 8 | #include <linux/ptrace.h> |
5a0e3ad6 | 9 | #include <linux/slab.h> |
1da177e4 | 10 | #include <linux/seq_file.h> |
6e84f315 IM |
11 | #include <linux/sched/mm.h> |
12 | ||
1da177e4 LT |
13 | #include "internal.h" |
14 | ||
15 | /* | |
16 | * Logic: we've got two memory sums for each process, "shared", and | |
025dfdaf | 17 | * "non-shared". Shared memory may get counted more than once, for |
1da177e4 LT |
18 | * each process that owns it. Non-shared memory is counted |
19 | * accurately. | |
20 | */ | |
df5f8314 | 21 | void task_mem(struct seq_file *m, struct mm_struct *mm) |
1da177e4 | 22 | { |
0c563f14 | 23 | VMA_ITERATOR(vmi, mm, 0); |
8feae131 | 24 | struct vm_area_struct *vma; |
38f71479 | 25 | struct vm_region *region; |
38f71479 | 26 | unsigned long bytes = 0, sbytes = 0, slack = 0, size; |
1da177e4 | 27 | |
0c563f14 MWO |
28 | mmap_read_lock(mm); |
29 | for_each_vma(vmi, vma) { | |
8feae131 | 30 | bytes += kobjsize(vma); |
38f71479 DH |
31 | |
32 | region = vma->vm_region; | |
33 | if (region) { | |
34 | size = kobjsize(region); | |
35 | size += region->vm_end - region->vm_start; | |
36 | } else { | |
37 | size = vma->vm_end - vma->vm_start; | |
38 | } | |
39 | ||
1da177e4 | 40 | if (atomic_read(&mm->mm_count) > 1 || |
fc4f4be9 | 41 | is_nommu_shared_mapping(vma->vm_flags)) { |
38f71479 | 42 | sbytes += size; |
1da177e4 | 43 | } else { |
38f71479 DH |
44 | bytes += size; |
45 | if (region) | |
46 | slack = region->vm_end - vma->vm_end; | |
1da177e4 LT |
47 | } |
48 | } | |
49 | ||
50 | if (atomic_read(&mm->mm_count) > 1) | |
51 | sbytes += kobjsize(mm); | |
52 | else | |
53 | bytes += kobjsize(mm); | |
54 | ||
498052bb | 55 | if (current->fs && current->fs->users > 1) |
1da177e4 LT |
56 | sbytes += kobjsize(current->fs); |
57 | else | |
58 | bytes += kobjsize(current->fs); | |
59 | ||
60 | if (current->files && atomic_read(¤t->files->count) > 1) | |
61 | sbytes += kobjsize(current->files); | |
62 | else | |
63 | bytes += kobjsize(current->files); | |
64 | ||
d036bda7 | 65 | if (current->sighand && refcount_read(¤t->sighand->count) > 1) |
1da177e4 LT |
66 | sbytes += kobjsize(current->sighand); |
67 | else | |
68 | bytes += kobjsize(current->sighand); | |
69 | ||
70 | bytes += kobjsize(current); /* includes kernel stack */ | |
71 | ||
df5f8314 | 72 | seq_printf(m, |
1da177e4 LT |
73 | "Mem:\t%8lu bytes\n" |
74 | "Slack:\t%8lu bytes\n" | |
75 | "Shared:\t%8lu bytes\n", | |
76 | bytes, slack, sbytes); | |
77 | ||
d8ed45c5 | 78 | mmap_read_unlock(mm); |
1da177e4 LT |
79 | } |
80 | ||
81 | unsigned long task_vsize(struct mm_struct *mm) | |
82 | { | |
0c563f14 | 83 | VMA_ITERATOR(vmi, mm, 0); |
8feae131 | 84 | struct vm_area_struct *vma; |
1da177e4 LT |
85 | unsigned long vsize = 0; |
86 | ||
d8ed45c5 | 87 | mmap_read_lock(mm); |
0c563f14 | 88 | for_each_vma(vmi, vma) |
38f71479 | 89 | vsize += vma->vm_end - vma->vm_start; |
d8ed45c5 | 90 | mmap_read_unlock(mm); |
1da177e4 LT |
91 | return vsize; |
92 | } | |
93 | ||
a2ade7b6 AD |
94 | unsigned long task_statm(struct mm_struct *mm, |
95 | unsigned long *shared, unsigned long *text, | |
96 | unsigned long *data, unsigned long *resident) | |
1da177e4 | 97 | { |
0c563f14 | 98 | VMA_ITERATOR(vmi, mm, 0); |
8feae131 | 99 | struct vm_area_struct *vma; |
38f71479 | 100 | struct vm_region *region; |
a2ade7b6 | 101 | unsigned long size = kobjsize(mm); |
1da177e4 | 102 | |
d8ed45c5 | 103 | mmap_read_lock(mm); |
0c563f14 | 104 | for_each_vma(vmi, vma) { |
8feae131 | 105 | size += kobjsize(vma); |
38f71479 DH |
106 | region = vma->vm_region; |
107 | if (region) { | |
108 | size += kobjsize(region); | |
109 | size += region->vm_end - region->vm_start; | |
110 | } | |
1da177e4 LT |
111 | } |
112 | ||
7e1e0ef2 SM |
113 | *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) |
114 | >> PAGE_SHIFT; | |
115 | *data = (PAGE_ALIGN(mm->start_stack) - (mm->start_data & PAGE_MASK)) | |
116 | >> PAGE_SHIFT; | |
d8ed45c5 | 117 | mmap_read_unlock(mm); |
7e1e0ef2 SM |
118 | size >>= PAGE_SHIFT; |
119 | size += *text + *data; | |
1da177e4 LT |
120 | *resident = size; |
121 | return size; | |
122 | } | |
123 | ||
1240ea0d | 124 | static int is_stack(struct vm_area_struct *vma) |
58cb6548 | 125 | { |
65376df5 | 126 | struct mm_struct *mm = vma->vm_mm; |
b18cb64e AL |
127 | |
128 | /* | |
129 | * We make no effort to guess what a given thread considers to be | |
130 | * its "stack". It's not even well-defined for programs written | |
131 | * languages like Go. | |
132 | */ | |
133 | return vma->vm_start <= mm->start_stack && | |
134 | vma->vm_end >= mm->start_stack; | |
58cb6548 ON |
135 | } |
136 | ||
8feae131 DH |
137 | /* |
138 | * display a single VMA to a sequenced file | |
139 | */ | |
871305bb | 140 | static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma) |
8feae131 | 141 | { |
3c26c9d9 | 142 | struct mm_struct *mm = vma->vm_mm; |
8feae131 DH |
143 | unsigned long ino = 0; |
144 | struct file *file; | |
145 | dev_t dev = 0; | |
652586df | 146 | int flags; |
6260a4b0 | 147 | unsigned long long pgoff = 0; |
8feae131 DH |
148 | |
149 | flags = vma->vm_flags; | |
150 | file = vma->vm_file; | |
151 | ||
152 | if (file) { | |
496ad9aa | 153 | struct inode *inode = file_inode(vma->vm_file); |
8feae131 DH |
154 | dev = inode->i_sb->s_dev; |
155 | ino = inode->i_ino; | |
4c967291 | 156 | pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT; |
8feae131 DH |
157 | } |
158 | ||
652586df | 159 | seq_setwidth(m, 25 + sizeof(void *) * 6 - 1); |
8feae131 | 160 | seq_printf(m, |
652586df | 161 | "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ", |
8feae131 DH |
162 | vma->vm_start, |
163 | vma->vm_end, | |
164 | flags & VM_READ ? 'r' : '-', | |
165 | flags & VM_WRITE ? 'w' : '-', | |
166 | flags & VM_EXEC ? 'x' : '-', | |
167 | flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p', | |
6260a4b0 | 168 | pgoff, |
652586df | 169 | MAJOR(dev), MINOR(dev), ino); |
8feae131 DH |
170 | |
171 | if (file) { | |
652586df | 172 | seq_pad(m, ' '); |
2726d566 | 173 | seq_file_path(m, file, ""); |
1240ea0d | 174 | } else if (mm && is_stack(vma)) { |
65376df5 | 175 | seq_pad(m, ' '); |
08b55775 | 176 | seq_puts(m, "[stack]"); |
8feae131 DH |
177 | } |
178 | ||
179 | seq_putc(m, '\n'); | |
180 | return 0; | |
181 | } | |
182 | ||
1da177e4 | 183 | /* |
dbf8685c | 184 | * display mapping lines for a particular process's /proc/pid/maps |
1da177e4 | 185 | */ |
871305bb | 186 | static int show_map(struct seq_file *m, void *_p) |
1da177e4 | 187 | { |
0c563f14 | 188 | return nommu_vma_show(m, _p); |
1da177e4 | 189 | } |
dbf8685c | 190 | |
1da177e4 LT |
191 | static void *m_start(struct seq_file *m, loff_t *pos) |
192 | { | |
dbf8685c | 193 | struct proc_maps_private *priv = m->private; |
dbf8685c | 194 | struct mm_struct *mm; |
0c563f14 MWO |
195 | struct vm_area_struct *vma; |
196 | unsigned long addr = *pos; | |
197 | ||
198 | /* See m_next(). Zero at the start or after lseek. */ | |
199 | if (addr == -1UL) | |
200 | return NULL; | |
dbf8685c DH |
201 | |
202 | /* pin the task and mm whilst we play with them */ | |
2c03376d | 203 | priv->task = get_proc_task(priv->inode); |
dbf8685c | 204 | if (!priv->task) |
ec6fd8a4 | 205 | return ERR_PTR(-ESRCH); |
dbf8685c | 206 | |
27692cd5 | 207 | mm = priv->mm; |
388f7934 | 208 | if (!mm || !mmget_not_zero(mm)) |
27692cd5 | 209 | return NULL; |
dbf8685c | 210 | |
d8ed45c5 | 211 | if (mmap_read_lock_killable(mm)) { |
8a713e7d KK |
212 | mmput(mm); |
213 | return ERR_PTR(-EINTR); | |
214 | } | |
215 | ||
0c563f14 MWO |
216 | /* start the next element from addr */ |
217 | vma = find_vma(mm, addr); | |
218 | if (vma) | |
219 | return vma; | |
47fecca1 | 220 | |
d8ed45c5 | 221 | mmap_read_unlock(mm); |
47fecca1 | 222 | mmput(mm); |
1da177e4 LT |
223 | return NULL; |
224 | } | |
dbf8685c DH |
225 | |
226 | static void m_stop(struct seq_file *m, void *_vml) | |
1da177e4 | 227 | { |
dbf8685c DH |
228 | struct proc_maps_private *priv = m->private; |
229 | ||
47fecca1 | 230 | if (!IS_ERR_OR_NULL(_vml)) { |
d8ed45c5 | 231 | mmap_read_unlock(priv->mm); |
47fecca1 ON |
232 | mmput(priv->mm); |
233 | } | |
dbf8685c | 234 | if (priv->task) { |
dbf8685c | 235 | put_task_struct(priv->task); |
47fecca1 | 236 | priv->task = NULL; |
dbf8685c | 237 | } |
1da177e4 | 238 | } |
dbf8685c | 239 | |
8feae131 | 240 | static void *m_next(struct seq_file *m, void *_p, loff_t *pos) |
1da177e4 | 241 | { |
0c563f14 | 242 | struct vm_area_struct *vma = _p; |
dbf8685c | 243 | |
0c563f14 MWO |
244 | *pos = vma->vm_end; |
245 | return find_vma(vma->vm_mm, vma->vm_end); | |
1da177e4 | 246 | } |
dbf8685c | 247 | |
03a44825 | 248 | static const struct seq_operations proc_pid_maps_ops = { |
1da177e4 LT |
249 | .start = m_start, |
250 | .next = m_next, | |
251 | .stop = m_stop, | |
871305bb | 252 | .show = show_map |
1da177e4 | 253 | }; |
662795de | 254 | |
b7643757 SP |
255 | static int maps_open(struct inode *inode, struct file *file, |
256 | const struct seq_operations *ops) | |
662795de | 257 | { |
dbf8685c | 258 | struct proc_maps_private *priv; |
ce34fddb | 259 | |
27692cd5 | 260 | priv = __seq_open_private(file, ops, sizeof(*priv)); |
ce34fddb ON |
261 | if (!priv) |
262 | return -ENOMEM; | |
263 | ||
2c03376d | 264 | priv->inode = inode; |
27692cd5 ON |
265 | priv->mm = proc_mem_open(inode, PTRACE_MODE_READ); |
266 | if (IS_ERR(priv->mm)) { | |
267 | int err = PTR_ERR(priv->mm); | |
268 | ||
269 | seq_release_private(inode, file); | |
270 | return err; | |
271 | } | |
272 | ||
ce34fddb | 273 | return 0; |
662795de EB |
274 | } |
275 | ||
27692cd5 ON |
276 | |
277 | static int map_release(struct inode *inode, struct file *file) | |
278 | { | |
279 | struct seq_file *seq = file->private_data; | |
280 | struct proc_maps_private *priv = seq->private; | |
281 | ||
282 | if (priv->mm) | |
283 | mmdrop(priv->mm); | |
284 | ||
285 | return seq_release_private(inode, file); | |
286 | } | |
287 | ||
b7643757 SP |
288 | static int pid_maps_open(struct inode *inode, struct file *file) |
289 | { | |
290 | return maps_open(inode, file, &proc_pid_maps_ops); | |
291 | } | |
292 | ||
b7643757 SP |
293 | const struct file_operations proc_pid_maps_operations = { |
294 | .open = pid_maps_open, | |
295 | .read = seq_read, | |
296 | .llseek = seq_lseek, | |
27692cd5 | 297 | .release = map_release, |
b7643757 SP |
298 | }; |
299 |