1 2 #include <linux/mm.h> 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/seq_file.h> 9 #include "internal.h" 10 11 /* 12 * Logic: we've got two memory sums for each process, "shared", and 13 * "non-shared". Shared memory may get counted more than once, for 14 * each process that owns it. Non-shared memory is counted 15 * accurately. 16 */ 17 void task_mem(struct seq_file *m, struct mm_struct *mm) 18 { 19 struct vm_area_struct *vma; 20 struct vm_region *region; 21 struct rb_node *p; 22 unsigned long bytes = 0, sbytes = 0, slack = 0, size; 23 24 down_read(&mm->mmap_sem); 25 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) { 26 vma = rb_entry(p, struct vm_area_struct, vm_rb); 27 28 bytes += kobjsize(vma); 29 30 region = vma->vm_region; 31 if (region) { 32 size = kobjsize(region); 33 size += region->vm_end - region->vm_start; 34 } else { 35 size = vma->vm_end - vma->vm_start; 36 } 37 38 if (atomic_read(&mm->mm_count) > 1 || 39 vma->vm_flags & VM_MAYSHARE) { 40 sbytes += size; 41 } else { 42 bytes += size; 43 if (region) 44 slack = region->vm_end - vma->vm_end; 45 } 46 } 47 48 if (atomic_read(&mm->mm_count) > 1) 49 sbytes += kobjsize(mm); 50 else 51 bytes += kobjsize(mm); 52 53 if (current->fs && current->fs->users > 1) 54 sbytes += kobjsize(current->fs); 55 else 56 bytes += kobjsize(current->fs); 57 58 if (current->files && atomic_read(¤t->files->count) > 1) 59 sbytes += kobjsize(current->files); 60 else 61 bytes += kobjsize(current->files); 62 63 if (current->sighand && atomic_read(¤t->sighand->count) > 1) 64 sbytes += kobjsize(current->sighand); 65 else 66 bytes += kobjsize(current->sighand); 67 68 bytes += kobjsize(current); /* includes kernel stack */ 69 70 seq_printf(m, 71 "Mem:\t%8lu bytes\n" 72 "Slack:\t%8lu bytes\n" 73 "Shared:\t%8lu bytes\n", 74 bytes, slack, sbytes); 75 76 up_read(&mm->mmap_sem); 77 } 78 79 unsigned long task_vsize(struct mm_struct *mm) 80 { 81 struct vm_area_struct *vma; 82 struct rb_node *p; 83 unsigned long vsize = 0; 84 85 down_read(&mm->mmap_sem); 86 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) { 87 vma = rb_entry(p, struct vm_area_struct, vm_rb); 88 vsize += vma->vm_end - vma->vm_start; 89 } 90 up_read(&mm->mmap_sem); 91 return vsize; 92 } 93 94 int task_statm(struct mm_struct *mm, int *shared, int *text, 95 int *data, int *resident) 96 { 97 struct vm_area_struct *vma; 98 struct vm_region *region; 99 struct rb_node *p; 100 int size = kobjsize(mm); 101 102 down_read(&mm->mmap_sem); 103 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) { 104 vma = rb_entry(p, struct vm_area_struct, vm_rb); 105 size += kobjsize(vma); 106 region = vma->vm_region; 107 if (region) { 108 size += kobjsize(region); 109 size += region->vm_end - region->vm_start; 110 } 111 } 112 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; 117 up_read(&mm->mmap_sem); 118 size >>= PAGE_SHIFT; 119 size += *text + *data; 120 *resident = size; 121 return size; 122 } 123 124 /* 125 * display a single VMA to a sequenced file 126 */ 127 static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma) 128 { 129 unsigned long ino = 0; 130 struct file *file; 131 dev_t dev = 0; 132 int flags, len; 133 unsigned long long pgoff = 0; 134 135 flags = vma->vm_flags; 136 file = vma->vm_file; 137 138 if (file) { 139 struct inode *inode = vma->vm_file->f_path.dentry->d_inode; 140 dev = inode->i_sb->s_dev; 141 ino = inode->i_ino; 142 pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT; 143 } 144 145 seq_printf(m, 146 "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n", 147 vma->vm_start, 148 vma->vm_end, 149 flags & VM_READ ? 'r' : '-', 150 flags & VM_WRITE ? 'w' : '-', 151 flags & VM_EXEC ? 'x' : '-', 152 flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p', 153 pgoff, 154 MAJOR(dev), MINOR(dev), ino, &len); 155 156 if (file) { 157 len = 25 + sizeof(void *) * 6 - len; 158 if (len < 1) 159 len = 1; 160 seq_printf(m, "%*c", len, ' '); 161 seq_path(m, &file->f_path, ""); 162 } 163 164 seq_putc(m, '\n'); 165 return 0; 166 } 167 168 /* 169 * display mapping lines for a particular process's /proc/pid/maps 170 */ 171 static int show_map(struct seq_file *m, void *_p) 172 { 173 struct rb_node *p = _p; 174 175 return nommu_vma_show(m, rb_entry(p, struct vm_area_struct, vm_rb)); 176 } 177 178 static void *m_start(struct seq_file *m, loff_t *pos) 179 { 180 struct proc_maps_private *priv = m->private; 181 struct mm_struct *mm; 182 struct rb_node *p; 183 loff_t n = *pos; 184 185 /* pin the task and mm whilst we play with them */ 186 priv->task = get_pid_task(priv->pid, PIDTYPE_PID); 187 if (!priv->task) 188 return NULL; 189 190 mm = mm_for_maps(priv->task); 191 if (!mm) { 192 put_task_struct(priv->task); 193 priv->task = NULL; 194 return NULL; 195 } 196 down_read(&mm->mmap_sem); 197 198 /* start from the Nth VMA */ 199 for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) 200 if (n-- == 0) 201 return p; 202 return NULL; 203 } 204 205 static void m_stop(struct seq_file *m, void *_vml) 206 { 207 struct proc_maps_private *priv = m->private; 208 209 if (priv->task) { 210 struct mm_struct *mm = priv->task->mm; 211 up_read(&mm->mmap_sem); 212 mmput(mm); 213 put_task_struct(priv->task); 214 } 215 } 216 217 static void *m_next(struct seq_file *m, void *_p, loff_t *pos) 218 { 219 struct rb_node *p = _p; 220 221 (*pos)++; 222 return p ? rb_next(p) : NULL; 223 } 224 225 static const struct seq_operations proc_pid_maps_ops = { 226 .start = m_start, 227 .next = m_next, 228 .stop = m_stop, 229 .show = show_map 230 }; 231 232 static int maps_open(struct inode *inode, struct file *file) 233 { 234 struct proc_maps_private *priv; 235 int ret = -ENOMEM; 236 237 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 238 if (priv) { 239 priv->pid = proc_pid(inode); 240 ret = seq_open(file, &proc_pid_maps_ops); 241 if (!ret) { 242 struct seq_file *m = file->private_data; 243 m->private = priv; 244 } else { 245 kfree(priv); 246 } 247 } 248 return ret; 249 } 250 251 const struct file_operations proc_maps_operations = { 252 .open = maps_open, 253 .read = seq_read, 254 .llseek = seq_lseek, 255 .release = seq_release_private, 256 }; 257 258