Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | |
| 2 | #include <linux/mm.h> |
| 3 | #include <linux/file.h> |
Bryan Wu | eb28062 | 2008-05-04 23:12:55 +0800 | [diff] [blame] | 4 | #include <linux/fdtable.h> |
Al Viro | 5ad4e53 | 2009-03-29 19:50:06 -0400 | [diff] [blame] | 5 | #include <linux/fs_struct.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | #include <linux/mount.h> |
Kees Cook | 5096add | 2007-05-08 00:26:04 -0700 | [diff] [blame] | 7 | #include <linux/ptrace.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 8 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | #include <linux/seq_file.h> |
| 10 | #include "internal.h" |
| 11 | |
| 12 | /* |
| 13 | * Logic: we've got two memory sums for each process, "shared", and |
Frederik Schwarzer | 025dfda | 2008-10-16 19:02:37 +0200 | [diff] [blame] | 14 | * "non-shared". Shared memory may get counted more than once, for |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | * each process that owns it. Non-shared memory is counted |
| 16 | * accurately. |
| 17 | */ |
Eric W. Biederman | df5f831 | 2008-02-08 04:18:33 -0800 | [diff] [blame] | 18 | void task_mem(struct seq_file *m, struct mm_struct *mm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | { |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 20 | struct vm_area_struct *vma; |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 21 | struct vm_region *region; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 22 | struct rb_node *p; |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 23 | unsigned long bytes = 0, sbytes = 0, slack = 0, size; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | |
| 25 | down_read(&mm->mmap_sem); |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 26 | for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) { |
| 27 | vma = rb_entry(p, struct vm_area_struct, vm_rb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 29 | bytes += kobjsize(vma); |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 30 | |
| 31 | region = vma->vm_region; |
| 32 | if (region) { |
| 33 | size = kobjsize(region); |
| 34 | size += region->vm_end - region->vm_start; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | } else { |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 36 | size = vma->vm_end - vma->vm_start; |
| 37 | } |
| 38 | |
| 39 | if (atomic_read(&mm->mm_count) > 1 || |
| 40 | vma->vm_flags & VM_MAYSHARE) { |
| 41 | sbytes += size; |
| 42 | } else { |
| 43 | bytes += size; |
| 44 | if (region) |
| 45 | slack = region->vm_end - vma->vm_end; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | } |
| 47 | } |
| 48 | |
| 49 | if (atomic_read(&mm->mm_count) > 1) |
| 50 | sbytes += kobjsize(mm); |
| 51 | else |
| 52 | bytes += kobjsize(mm); |
| 53 | |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 54 | if (current->fs && current->fs->users > 1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | sbytes += kobjsize(current->fs); |
| 56 | else |
| 57 | bytes += kobjsize(current->fs); |
| 58 | |
| 59 | if (current->files && atomic_read(¤t->files->count) > 1) |
| 60 | sbytes += kobjsize(current->files); |
| 61 | else |
| 62 | bytes += kobjsize(current->files); |
| 63 | |
| 64 | if (current->sighand && atomic_read(¤t->sighand->count) > 1) |
| 65 | sbytes += kobjsize(current->sighand); |
| 66 | else |
| 67 | bytes += kobjsize(current->sighand); |
| 68 | |
| 69 | bytes += kobjsize(current); /* includes kernel stack */ |
| 70 | |
Eric W. Biederman | df5f831 | 2008-02-08 04:18:33 -0800 | [diff] [blame] | 71 | seq_printf(m, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | "Mem:\t%8lu bytes\n" |
| 73 | "Slack:\t%8lu bytes\n" |
| 74 | "Shared:\t%8lu bytes\n", |
| 75 | bytes, slack, sbytes); |
| 76 | |
| 77 | up_read(&mm->mmap_sem); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | } |
| 79 | |
| 80 | unsigned long task_vsize(struct mm_struct *mm) |
| 81 | { |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 82 | struct vm_area_struct *vma; |
| 83 | struct rb_node *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | unsigned long vsize = 0; |
| 85 | |
| 86 | down_read(&mm->mmap_sem); |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 87 | for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) { |
| 88 | vma = rb_entry(p, struct vm_area_struct, vm_rb); |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 89 | vsize += vma->vm_end - vma->vm_start; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | } |
| 91 | up_read(&mm->mmap_sem); |
| 92 | return vsize; |
| 93 | } |
| 94 | |
Alexey Dobriyan | a2ade7b | 2011-01-12 17:00:32 -0800 | [diff] [blame] | 95 | unsigned long task_statm(struct mm_struct *mm, |
| 96 | unsigned long *shared, unsigned long *text, |
| 97 | unsigned long *data, unsigned long *resident) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | { |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 99 | struct vm_area_struct *vma; |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 100 | struct vm_region *region; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 101 | struct rb_node *p; |
Alexey Dobriyan | a2ade7b | 2011-01-12 17:00:32 -0800 | [diff] [blame] | 102 | unsigned long size = kobjsize(mm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | |
| 104 | down_read(&mm->mmap_sem); |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 105 | for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) { |
| 106 | vma = rb_entry(p, struct vm_area_struct, vm_rb); |
| 107 | size += kobjsize(vma); |
David Howells | 38f7147 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 108 | region = vma->vm_region; |
| 109 | if (region) { |
| 110 | size += kobjsize(region); |
| 111 | size += region->vm_end - region->vm_start; |
| 112 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | } |
| 114 | |
Steven J. Magnani | 7e1e0ef | 2009-12-14 18:00:04 -0800 | [diff] [blame] | 115 | *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) |
| 116 | >> PAGE_SHIFT; |
| 117 | *data = (PAGE_ALIGN(mm->start_stack) - (mm->start_data & PAGE_MASK)) |
| 118 | >> PAGE_SHIFT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | up_read(&mm->mmap_sem); |
Steven J. Magnani | 7e1e0ef | 2009-12-14 18:00:04 -0800 | [diff] [blame] | 120 | size >>= PAGE_SHIFT; |
| 121 | size += *text + *data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | *resident = size; |
| 123 | return size; |
| 124 | } |
| 125 | |
Mike Frysinger | 3c26c9d | 2010-06-29 15:05:17 -0700 | [diff] [blame] | 126 | static void pad_len_spaces(struct seq_file *m, int len) |
| 127 | { |
| 128 | len = 25 + sizeof(void*) * 6 - len; |
| 129 | if (len < 1) |
| 130 | len = 1; |
| 131 | seq_printf(m, "%*c", len, ' '); |
| 132 | } |
| 133 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | /* |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 135 | * display a single VMA to a sequenced file |
| 136 | */ |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 137 | static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma, |
| 138 | int is_pid) |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 139 | { |
Mike Frysinger | 3c26c9d | 2010-06-29 15:05:17 -0700 | [diff] [blame] | 140 | struct mm_struct *mm = vma->vm_mm; |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 141 | struct proc_maps_private *priv = m->private; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 142 | unsigned long ino = 0; |
| 143 | struct file *file; |
| 144 | dev_t dev = 0; |
| 145 | int flags, len; |
KAMEZAWA Hiroyuki | 6260a4b | 2009-04-06 19:00:30 -0700 | [diff] [blame] | 146 | unsigned long long pgoff = 0; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 147 | |
| 148 | flags = vma->vm_flags; |
| 149 | file = vma->vm_file; |
| 150 | |
| 151 | if (file) { |
| 152 | struct inode *inode = vma->vm_file->f_path.dentry->d_inode; |
| 153 | dev = inode->i_sb->s_dev; |
| 154 | ino = inode->i_ino; |
Nobuhiro Iwamatsu | 4c96729 | 2009-04-07 21:21:43 -0700 | [diff] [blame] | 155 | pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | seq_printf(m, |
David Howells | 33e5d769 | 2009-04-02 16:56:32 -0700 | [diff] [blame] | 159 | "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n", |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 160 | vma->vm_start, |
| 161 | vma->vm_end, |
| 162 | flags & VM_READ ? 'r' : '-', |
| 163 | flags & VM_WRITE ? 'w' : '-', |
| 164 | flags & VM_EXEC ? 'x' : '-', |
| 165 | flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p', |
KAMEZAWA Hiroyuki | 6260a4b | 2009-04-06 19:00:30 -0700 | [diff] [blame] | 166 | pgoff, |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 167 | MAJOR(dev), MINOR(dev), ino, &len); |
| 168 | |
| 169 | if (file) { |
Mike Frysinger | 3c26c9d | 2010-06-29 15:05:17 -0700 | [diff] [blame] | 170 | pad_len_spaces(m, len); |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 171 | seq_path(m, &file->f_path, ""); |
Mike Frysinger | 3c26c9d | 2010-06-29 15:05:17 -0700 | [diff] [blame] | 172 | } else if (mm) { |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 173 | pid_t tid = vm_is_stack(priv->task, vma, is_pid); |
| 174 | |
| 175 | if (tid != 0) { |
Mike Frysinger | 3c26c9d | 2010-06-29 15:05:17 -0700 | [diff] [blame] | 176 | pad_len_spaces(m, len); |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 177 | /* |
| 178 | * Thread stack in /proc/PID/task/TID/maps or |
| 179 | * the main process stack. |
| 180 | */ |
| 181 | if (!is_pid || (vma->vm_start <= mm->start_stack && |
| 182 | vma->vm_end >= mm->start_stack)) |
| 183 | seq_printf(m, "[stack]"); |
| 184 | else |
| 185 | seq_printf(m, "[stack:%d]", tid); |
Mike Frysinger | 3c26c9d | 2010-06-29 15:05:17 -0700 | [diff] [blame] | 186 | } |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | seq_putc(m, '\n'); |
| 190 | return 0; |
| 191 | } |
| 192 | |
| 193 | /* |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 194 | * display mapping lines for a particular process's /proc/pid/maps |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | */ |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 196 | static int show_map(struct seq_file *m, void *_p, int is_pid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | { |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 198 | struct rb_node *p = _p; |
Kees Cook | 5096add | 2007-05-08 00:26:04 -0700 | [diff] [blame] | 199 | |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 200 | return nommu_vma_show(m, rb_entry(p, struct vm_area_struct, vm_rb), |
| 201 | is_pid); |
| 202 | } |
| 203 | |
| 204 | static int show_pid_map(struct seq_file *m, void *_p) |
| 205 | { |
| 206 | return show_map(m, _p, 1); |
| 207 | } |
| 208 | |
| 209 | static int show_tid_map(struct seq_file *m, void *_p) |
| 210 | { |
| 211 | return show_map(m, _p, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | } |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 213 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | static void *m_start(struct seq_file *m, loff_t *pos) |
| 215 | { |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 216 | struct proc_maps_private *priv = m->private; |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 217 | struct mm_struct *mm; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 218 | struct rb_node *p; |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 219 | loff_t n = *pos; |
| 220 | |
| 221 | /* pin the task and mm whilst we play with them */ |
| 222 | priv->task = get_pid_task(priv->pid, PIDTYPE_PID); |
| 223 | if (!priv->task) |
Al Viro | ec6fd8a | 2011-02-15 22:22:54 -0500 | [diff] [blame] | 224 | return ERR_PTR(-ESRCH); |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 225 | |
Cong Wang | e7dcd99 | 2012-05-31 16:26:17 -0700 | [diff] [blame] | 226 | mm = mm_access(priv->task, PTRACE_MODE_READ); |
Al Viro | ec6fd8a | 2011-02-15 22:22:54 -0500 | [diff] [blame] | 227 | if (!mm || IS_ERR(mm)) { |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 228 | put_task_struct(priv->task); |
| 229 | priv->task = NULL; |
Al Viro | ec6fd8a | 2011-02-15 22:22:54 -0500 | [diff] [blame] | 230 | return mm; |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 231 | } |
Oleg Nesterov | 00f89d2 | 2009-07-10 03:27:38 +0200 | [diff] [blame] | 232 | down_read(&mm->mmap_sem); |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 233 | |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 234 | /* start from the Nth VMA */ |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 235 | for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 236 | if (n-- == 0) |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 237 | return p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | return NULL; |
| 239 | } |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 240 | |
| 241 | static void m_stop(struct seq_file *m, void *_vml) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | { |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 243 | struct proc_maps_private *priv = m->private; |
| 244 | |
| 245 | if (priv->task) { |
| 246 | struct mm_struct *mm = priv->task->mm; |
| 247 | up_read(&mm->mmap_sem); |
| 248 | mmput(mm); |
| 249 | put_task_struct(priv->task); |
| 250 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | } |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 252 | |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 253 | static void *m_next(struct seq_file *m, void *_p, loff_t *pos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | { |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 255 | struct rb_node *p = _p; |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 256 | |
| 257 | (*pos)++; |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 258 | return p ? rb_next(p) : NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | } |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 260 | |
Jan Engelhardt | 03a4482 | 2008-02-08 04:21:19 -0800 | [diff] [blame] | 261 | static const struct seq_operations proc_pid_maps_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | .start = m_start, |
| 263 | .next = m_next, |
| 264 | .stop = m_stop, |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 265 | .show = show_pid_map |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | }; |
Eric W. Biederman | 662795d | 2006-06-26 00:25:48 -0700 | [diff] [blame] | 267 | |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 268 | static const struct seq_operations proc_tid_maps_ops = { |
| 269 | .start = m_start, |
| 270 | .next = m_next, |
| 271 | .stop = m_stop, |
| 272 | .show = show_tid_map |
| 273 | }; |
| 274 | |
| 275 | static int maps_open(struct inode *inode, struct file *file, |
| 276 | const struct seq_operations *ops) |
Eric W. Biederman | 662795d | 2006-06-26 00:25:48 -0700 | [diff] [blame] | 277 | { |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 278 | struct proc_maps_private *priv; |
| 279 | int ret = -ENOMEM; |
| 280 | |
| 281 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
| 282 | if (priv) { |
| 283 | priv->pid = proc_pid(inode); |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 284 | ret = seq_open(file, ops); |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 285 | if (!ret) { |
| 286 | struct seq_file *m = file->private_data; |
| 287 | m->private = priv; |
| 288 | } else { |
| 289 | kfree(priv); |
| 290 | } |
Eric W. Biederman | 662795d | 2006-06-26 00:25:48 -0700 | [diff] [blame] | 291 | } |
| 292 | return ret; |
| 293 | } |
| 294 | |
Siddhesh Poyarekar | b764375 | 2012-03-21 16:34:04 -0700 | [diff] [blame] | 295 | static int pid_maps_open(struct inode *inode, struct file *file) |
| 296 | { |
| 297 | return maps_open(inode, file, &proc_pid_maps_ops); |
| 298 | } |
| 299 | |
| 300 | static int tid_maps_open(struct inode *inode, struct file *file) |
| 301 | { |
| 302 | return maps_open(inode, file, &proc_tid_maps_ops); |
| 303 | } |
| 304 | |
| 305 | const struct file_operations proc_pid_maps_operations = { |
| 306 | .open = pid_maps_open, |
| 307 | .read = seq_read, |
| 308 | .llseek = seq_lseek, |
| 309 | .release = seq_release_private, |
| 310 | }; |
| 311 | |
| 312 | const struct file_operations proc_tid_maps_operations = { |
| 313 | .open = tid_maps_open, |
Eric W. Biederman | 662795d | 2006-06-26 00:25:48 -0700 | [diff] [blame] | 314 | .read = seq_read, |
| 315 | .llseek = seq_lseek, |
David Howells | dbf8685 | 2006-09-27 01:50:19 -0700 | [diff] [blame] | 316 | .release = seq_release_private, |
Eric W. Biederman | 662795d | 2006-06-26 00:25:48 -0700 | [diff] [blame] | 317 | }; |
| 318 | |