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 void task_mem(struct seq_file *m, struct mm_struct *mm) 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(¤t->fs->count) > 1) 45 sbytes += kobjsize(current->fs); 46 else 47 bytes += kobjsize(current->fs); 48 49 if (current->files && atomic_read(¤t->files->count) > 1) 50 sbytes += kobjsize(current->files); 51 else 52 bytes += kobjsize(current->files); 53 54 if (current->sighand && atomic_read(¤t->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 seq_printf(m, 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 } 69 70 unsigned long task_vsize(struct mm_struct *mm) 71 { 72 struct vm_list_struct *tbp; 73 unsigned long vsize = 0; 74 75 down_read(&mm->mmap_sem); 76 for (tbp = mm->context.vmlist; tbp; tbp = tbp->next) { 77 if (tbp->vma) 78 vsize += kobjsize((void *) tbp->vma->vm_start); 79 } 80 up_read(&mm->mmap_sem); 81 return vsize; 82 } 83 84 int task_statm(struct mm_struct *mm, int *shared, int *text, 85 int *data, int *resident) 86 { 87 struct vm_list_struct *tbp; 88 int size = kobjsize(mm); 89 90 down_read(&mm->mmap_sem); 91 for (tbp = mm->context.vmlist; tbp; tbp = tbp->next) { 92 size += kobjsize(tbp); 93 if (tbp->vma) { 94 size += kobjsize(tbp->vma); 95 size += kobjsize((void *) tbp->vma->vm_start); 96 } 97 } 98 99 size += (*text = mm->end_code - mm->start_code); 100 size += (*data = mm->start_stack - mm->start_data); 101 up_read(&mm->mmap_sem); 102 *resident = size; 103 return size; 104 } 105 106 int proc_exe_link(struct inode *inode, struct path *path) 107 { 108 struct vm_list_struct *vml; 109 struct vm_area_struct *vma; 110 struct task_struct *task = get_proc_task(inode); 111 struct mm_struct *mm = get_task_mm(task); 112 int result = -ENOENT; 113 114 if (!mm) 115 goto out; 116 down_read(&mm->mmap_sem); 117 118 vml = mm->context.vmlist; 119 vma = NULL; 120 while (vml) { 121 if ((vml->vma->vm_flags & VM_EXECUTABLE) && vml->vma->vm_file) { 122 vma = vml->vma; 123 break; 124 } 125 vml = vml->next; 126 } 127 128 if (vma) { 129 *path = vma->vm_file->f_path; 130 path_get(&vma->vm_file->f_path); 131 result = 0; 132 } 133 134 up_read(&mm->mmap_sem); 135 mmput(mm); 136 out: 137 return result; 138 } 139 140 /* 141 * display mapping lines for a particular process's /proc/pid/maps 142 */ 143 static int show_map(struct seq_file *m, void *_vml) 144 { 145 struct vm_list_struct *vml = _vml; 146 struct proc_maps_private *priv = m->private; 147 struct task_struct *task = priv->task; 148 149 if (maps_protect && !ptrace_may_attach(task)) 150 return -EACCES; 151 152 return nommu_vma_show(m, vml->vma); 153 } 154 155 static void *m_start(struct seq_file *m, loff_t *pos) 156 { 157 struct proc_maps_private *priv = m->private; 158 struct vm_list_struct *vml; 159 struct mm_struct *mm; 160 loff_t n = *pos; 161 162 /* pin the task and mm whilst we play with them */ 163 priv->task = get_pid_task(priv->pid, PIDTYPE_PID); 164 if (!priv->task) 165 return NULL; 166 167 mm = mm_for_maps(priv->task); 168 if (!mm) { 169 put_task_struct(priv->task); 170 priv->task = NULL; 171 return NULL; 172 } 173 174 /* start from the Nth VMA */ 175 for (vml = mm->context.vmlist; vml; vml = vml->next) 176 if (n-- == 0) 177 return vml; 178 return NULL; 179 } 180 181 static void m_stop(struct seq_file *m, void *_vml) 182 { 183 struct proc_maps_private *priv = m->private; 184 185 if (priv->task) { 186 struct mm_struct *mm = priv->task->mm; 187 up_read(&mm->mmap_sem); 188 mmput(mm); 189 put_task_struct(priv->task); 190 } 191 } 192 193 static void *m_next(struct seq_file *m, void *_vml, loff_t *pos) 194 { 195 struct vm_list_struct *vml = _vml; 196 197 (*pos)++; 198 return vml ? vml->next : NULL; 199 } 200 201 static const struct seq_operations proc_pid_maps_ops = { 202 .start = m_start, 203 .next = m_next, 204 .stop = m_stop, 205 .show = show_map 206 }; 207 208 static int maps_open(struct inode *inode, struct file *file) 209 { 210 struct proc_maps_private *priv; 211 int ret = -ENOMEM; 212 213 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 214 if (priv) { 215 priv->pid = proc_pid(inode); 216 ret = seq_open(file, &proc_pid_maps_ops); 217 if (!ret) { 218 struct seq_file *m = file->private_data; 219 m->private = priv; 220 } else { 221 kfree(priv); 222 } 223 } 224 return ret; 225 } 226 227 const struct file_operations proc_maps_operations = { 228 .open = maps_open, 229 .read = seq_read, 230 .llseek = seq_lseek, 231 .release = seq_release_private, 232 }; 233 234