Security: split proc ptrace checking into read vs. attach
[kernel.git] / fs / proc / task_nommu.c
1
2 #include <linux/mm.h>
3 #include <linux/file.h>
4 #include <linux/fdtable.h>
5 #include <linux/mount.h>
6 #include <linux/ptrace.h>
7 #include <linux/seq_file.h>
8 #include "internal.h"
9
10 /*
11  * Logic: we've got two memory sums for each process, "shared", and
12  * "non-shared". Shared memory may get counted more then once, for
13  * each process that owns it. Non-shared memory is counted
14  * accurately.
15  */
16 void task_mem(struct seq_file *m, struct mm_struct *mm)
17 {
18         struct vm_list_struct *vml;
19         unsigned long bytes = 0, sbytes = 0, slack = 0;
20         
21         down_read(&mm->mmap_sem);
22         for (vml = mm->context.vmlist; vml; vml = vml->next) {
23                 if (!vml->vma)
24                         continue;
25
26                 bytes += kobjsize(vml);
27                 if (atomic_read(&mm->mm_count) > 1 ||
28                     atomic_read(&vml->vma->vm_usage) > 1
29                     ) {
30                         sbytes += kobjsize((void *) vml->vma->vm_start);
31                         sbytes += kobjsize(vml->vma);
32                 } else {
33                         bytes += kobjsize((void *) vml->vma->vm_start);
34                         bytes += kobjsize(vml->vma);
35                         slack += kobjsize((void *) vml->vma->vm_start) -
36                                 (vml->vma->vm_end - vml->vma->vm_start);
37                 }
38         }
39
40         if (atomic_read(&mm->mm_count) > 1)
41                 sbytes += kobjsize(mm);
42         else
43                 bytes += kobjsize(mm);
44         
45         if (current->fs && atomic_read(&current->fs->count) > 1)
46                 sbytes += kobjsize(current->fs);
47         else
48                 bytes += kobjsize(current->fs);
49
50         if (current->files && atomic_read(&current->files->count) > 1)
51                 sbytes += kobjsize(current->files);
52         else
53                 bytes += kobjsize(current->files);
54
55         if (current->sighand && atomic_read(&current->sighand->count) > 1)
56                 sbytes += kobjsize(current->sighand);
57         else
58                 bytes += kobjsize(current->sighand);
59
60         bytes += kobjsize(current); /* includes kernel stack */
61
62         seq_printf(m,
63                 "Mem:\t%8lu bytes\n"
64                 "Slack:\t%8lu bytes\n"
65                 "Shared:\t%8lu bytes\n",
66                 bytes, slack, sbytes);
67
68         up_read(&mm->mmap_sem);
69 }
70
71 unsigned long task_vsize(struct mm_struct *mm)
72 {
73         struct vm_list_struct *tbp;
74         unsigned long vsize = 0;
75
76         down_read(&mm->mmap_sem);
77         for (tbp = mm->context.vmlist; tbp; tbp = tbp->next) {
78                 if (tbp->vma)
79                         vsize += kobjsize((void *) tbp->vma->vm_start);
80         }
81         up_read(&mm->mmap_sem);
82         return vsize;
83 }
84
85 int task_statm(struct mm_struct *mm, int *shared, int *text,
86                int *data, int *resident)
87 {
88         struct vm_list_struct *tbp;
89         int size = kobjsize(mm);
90
91         down_read(&mm->mmap_sem);
92         for (tbp = mm->context.vmlist; tbp; tbp = tbp->next) {
93                 size += kobjsize(tbp);
94                 if (tbp->vma) {
95                         size += kobjsize(tbp->vma);
96                         size += kobjsize((void *) tbp->vma->vm_start);
97                 }
98         }
99
100         size += (*text = mm->end_code - mm->start_code);
101         size += (*data = mm->start_stack - mm->start_data);
102         up_read(&mm->mmap_sem);
103         *resident = size;
104         return size;
105 }
106
107 /*
108  * display mapping lines for a particular process's /proc/pid/maps
109  */
110 static int show_map(struct seq_file *m, void *_vml)
111 {
112         struct vm_list_struct *vml = _vml;
113         struct proc_maps_private *priv = m->private;
114         struct task_struct *task = priv->task;
115
116         if (maps_protect && !ptrace_may_access(task, PTRACE_MODE_READ))
117                 return -EACCES;
118
119         return nommu_vma_show(m, vml->vma);
120 }
121
122 static void *m_start(struct seq_file *m, loff_t *pos)
123 {
124         struct proc_maps_private *priv = m->private;
125         struct vm_list_struct *vml;
126         struct mm_struct *mm;
127         loff_t n = *pos;
128
129         /* pin the task and mm whilst we play with them */
130         priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
131         if (!priv->task)
132                 return NULL;
133
134         mm = mm_for_maps(priv->task);
135         if (!mm) {
136                 put_task_struct(priv->task);
137                 priv->task = NULL;
138                 return NULL;
139         }
140
141         /* start from the Nth VMA */
142         for (vml = mm->context.vmlist; vml; vml = vml->next)
143                 if (n-- == 0)
144                         return vml;
145         return NULL;
146 }
147
148 static void m_stop(struct seq_file *m, void *_vml)
149 {
150         struct proc_maps_private *priv = m->private;
151
152         if (priv->task) {
153                 struct mm_struct *mm = priv->task->mm;
154                 up_read(&mm->mmap_sem);
155                 mmput(mm);
156                 put_task_struct(priv->task);
157         }
158 }
159
160 static void *m_next(struct seq_file *m, void *_vml, loff_t *pos)
161 {
162         struct vm_list_struct *vml = _vml;
163
164         (*pos)++;
165         return vml ? vml->next : NULL;
166 }
167
168 static const struct seq_operations proc_pid_maps_ops = {
169         .start  = m_start,
170         .next   = m_next,
171         .stop   = m_stop,
172         .show   = show_map
173 };
174
175 static int maps_open(struct inode *inode, struct file *file)
176 {
177         struct proc_maps_private *priv;
178         int ret = -ENOMEM;
179
180         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
181         if (priv) {
182                 priv->pid = proc_pid(inode);
183                 ret = seq_open(file, &proc_pid_maps_ops);
184                 if (!ret) {
185                         struct seq_file *m = file->private_data;
186                         m->private = priv;
187                 } else {
188                         kfree(priv);
189                 }
190         }
191         return ret;
192 }
193
194 const struct file_operations proc_maps_operations = {
195         .open           = maps_open,
196         .read           = seq_read,
197         .llseek         = seq_lseek,
198         .release        = seq_release_private,
199 };
200