proc: maps protection
[linux-2.6.git] / fs / proc / task_nommu.c
1
2 #include <linux/mm.h>
3 #include <linux/file.h>
4 #include <linux/mount.h>
5 #include <linux/ptrace.h>
6 #include <linux/seq_file.h>
7 #include "internal.h"
8
9 /*
10  * Logic: we've got two memory sums for each process, "shared", and
11  * "non-shared". Shared memory may get counted more then once, for
12  * each process that owns it. Non-shared memory is counted
13  * accurately.
14  */
15 char *task_mem(struct mm_struct *mm, char *buffer)
16 {
17         struct vm_list_struct *vml;
18         unsigned long bytes = 0, sbytes = 0, slack = 0;
19         
20         down_read(&mm->mmap_sem);
21         for (vml = mm->context.vmlist; vml; vml = vml->next) {
22                 if (!vml->vma)
23                         continue;
24
25                 bytes += kobjsize(vml);
26                 if (atomic_read(&mm->mm_count) > 1 ||
27                     atomic_read(&vml->vma->vm_usage) > 1
28                     ) {
29                         sbytes += kobjsize((void *) vml->vma->vm_start);
30                         sbytes += kobjsize(vml->vma);
31                 } else {
32                         bytes += kobjsize((void *) vml->vma->vm_start);
33                         bytes += kobjsize(vml->vma);
34                         slack += kobjsize((void *) vml->vma->vm_start) -
35                                 (vml->vma->vm_end - vml->vma->vm_start);
36                 }
37         }
38
39         if (atomic_read(&mm->mm_count) > 1)
40                 sbytes += kobjsize(mm);
41         else
42                 bytes += kobjsize(mm);
43         
44         if (current->fs && atomic_read(&current->fs->count) > 1)
45                 sbytes += kobjsize(current->fs);
46         else
47                 bytes += kobjsize(current->fs);
48
49         if (current->files && atomic_read(&current->files->count) > 1)
50                 sbytes += kobjsize(current->files);
51         else
52                 bytes += kobjsize(current->files);
53
54         if (current->sighand && atomic_read(&current->sighand->count) > 1)
55                 sbytes += kobjsize(current->sighand);
56         else
57                 bytes += kobjsize(current->sighand);
58
59         bytes += kobjsize(current); /* includes kernel stack */
60
61         buffer += sprintf(buffer,
62                 "Mem:\t%8lu bytes\n"
63                 "Slack:\t%8lu bytes\n"
64                 "Shared:\t%8lu bytes\n",
65                 bytes, slack, sbytes);
66
67         up_read(&mm->mmap_sem);
68         return buffer;
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 int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
108 {
109         struct vm_list_struct *vml;
110         struct vm_area_struct *vma;
111         struct task_struct *task = get_proc_task(inode);
112         struct mm_struct *mm = get_task_mm(task);
113         int result = -ENOENT;
114
115         if (!mm)
116                 goto out;
117         down_read(&mm->mmap_sem);
118
119         vml = mm->context.vmlist;
120         vma = NULL;
121         while (vml) {
122                 if ((vml->vma->vm_flags & VM_EXECUTABLE) && vml->vma->vm_file) {
123                         vma = vml->vma;
124                         break;
125                 }
126                 vml = vml->next;
127         }
128
129         if (vma) {
130                 *mnt = mntget(vma->vm_file->f_path.mnt);
131                 *dentry = dget(vma->vm_file->f_path.dentry);
132                 result = 0;
133         }
134
135         up_read(&mm->mmap_sem);
136         mmput(mm);
137 out:
138         return result;
139 }
140
141 /*
142  * display mapping lines for a particular process's /proc/pid/maps
143  */
144 static int show_map(struct seq_file *m, void *_vml)
145 {
146         struct vm_list_struct *vml = _vml;
147         struct proc_maps_private *priv = m->private;
148         struct task_struct *task = priv->task;
149
150         if (maps_protect && !ptrace_may_attach(task))
151                 return -EACCES;
152
153         return nommu_vma_show(m, vml->vma);
154 }
155
156 static void *m_start(struct seq_file *m, loff_t *pos)
157 {
158         struct proc_maps_private *priv = m->private;
159         struct vm_list_struct *vml;
160         struct mm_struct *mm;
161         loff_t n = *pos;
162
163         /* pin the task and mm whilst we play with them */
164         priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
165         if (!priv->task)
166                 return NULL;
167
168         mm = get_task_mm(priv->task);
169         if (!mm) {
170                 put_task_struct(priv->task);
171                 priv->task = NULL;
172                 return NULL;
173         }
174
175         down_read(&mm->mmap_sem);
176
177         /* start from the Nth VMA */
178         for (vml = mm->context.vmlist; vml; vml = vml->next)
179                 if (n-- == 0)
180                         return vml;
181         return NULL;
182 }
183
184 static void m_stop(struct seq_file *m, void *_vml)
185 {
186         struct proc_maps_private *priv = m->private;
187
188         if (priv->task) {
189                 struct mm_struct *mm = priv->task->mm;
190                 up_read(&mm->mmap_sem);
191                 mmput(mm);
192                 put_task_struct(priv->task);
193         }
194 }
195
196 static void *m_next(struct seq_file *m, void *_vml, loff_t *pos)
197 {
198         struct vm_list_struct *vml = _vml;
199
200         (*pos)++;
201         return vml ? vml->next : NULL;
202 }
203
204 static struct seq_operations proc_pid_maps_ops = {
205         .start  = m_start,
206         .next   = m_next,
207         .stop   = m_stop,
208         .show   = show_map
209 };
210
211 static int maps_open(struct inode *inode, struct file *file)
212 {
213         struct proc_maps_private *priv;
214         int ret = -ENOMEM;
215
216         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
217         if (priv) {
218                 priv->pid = proc_pid(inode);
219                 ret = seq_open(file, &proc_pid_maps_ops);
220                 if (!ret) {
221                         struct seq_file *m = file->private_data;
222                         m->private = priv;
223                 } else {
224                         kfree(priv);
225                 }
226         }
227         return ret;
228 }
229
230 const struct file_operations proc_maps_operations = {
231         .open           = maps_open,
232         .read           = seq_read,
233         .llseek         = seq_lseek,
234         .release        = seq_release_private,
235 };
236