blob: 9b43ff77a51ed3b0383f3e96489e1e542331555a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/proc/base.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * proc base directory handling functions
7 *
8 * 1999, Al Viro. Rewritten. Now it covers the whole per-process part.
9 * Instead of using magical inumbers to determine the kind of object
10 * we allocate and fill in-core inodes upon lookup. They don't even
11 * go into icache. We cache the reference to task_struct upon lookup too.
12 * Eventually it should become a filesystem in its own. We don't use the
13 * rest of procfs anymore.
Mauricio Line070ad42005-09-03 15:55:10 -070014 *
15 *
16 * Changelog:
17 * 17-Jan-2005
18 * Allan Bezerra
19 * Bruna Moreira <bruna.moreira@indt.org.br>
20 * Edjard Mota <edjard.mota@indt.org.br>
21 * Ilias Biris <ilias.biris@indt.org.br>
22 * Mauricio Lin <mauricio.lin@indt.org.br>
23 *
24 * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
25 *
26 * A new process specific entry (smaps) included in /proc. It shows the
27 * size of rss for each memory area. The maps entry lacks information
28 * about physical memory size (rss) for each mapped file, i.e.,
29 * rss information for executables and library files.
30 * This additional information is useful for any tools that need to know
31 * about physical memory consumption for a process specific library.
32 *
33 * Changelog:
34 * 21-Feb-2005
35 * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
36 * Pud inclusion in the page table walking.
37 *
38 * ChangeLog:
39 * 10-Mar-2005
40 * 10LE Instituto Nokia de Tecnologia - INdT:
41 * A better way to walks through the page table as suggested by Hugh Dickins.
42 *
43 * Simo Piiroinen <simo.piiroinen@nokia.com>:
44 * Smaps information related to shared, private, clean and dirty pages.
45 *
46 * Paul Mundt <paul.mundt@nokia.com>:
47 * Overall revision about smaps.
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 */
49
50#include <asm/uaccess.h>
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/errno.h>
53#include <linux/time.h>
54#include <linux/proc_fs.h>
55#include <linux/stat.h>
Andrea Righi59954772008-07-27 17:29:15 +020056#include <linux/task_io_accounting_ops.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <linux/init.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080058#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040060#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <linux/string.h>
62#include <linux/seq_file.h>
63#include <linux/namei.h>
Kirill Korotaev6b3286e2006-12-08 02:37:56 -080064#include <linux/mnt_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#include <linux/mm.h>
David Rientjesa63d83f2010-08-09 17:19:46 -070066#include <linux/swap.h>
Dipankar Sarmab8359962005-09-09 13:04:14 -070067#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/kallsyms.h>
Ken Chen2ec220e2008-11-10 11:26:08 +030069#include <linux/stacktrace.h>
Neil Hormand85f50d2007-10-18 23:40:37 -070070#include <linux/resource.h>
Kees Cook5096add2007-05-08 00:26:04 -070071#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <linux/mount.h>
73#include <linux/security.h>
74#include <linux/ptrace.h>
Roland McGrath0d094ef2008-07-25 19:45:49 -070075#include <linux/tracehook.h>
Paul Menagea4243162007-10-18 23:39:35 -070076#include <linux/cgroup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#include <linux/cpuset.h>
78#include <linux/audit.h>
Al Viro5addc5d2005-11-07 17:15:49 -050079#include <linux/poll.h>
Serge E. Hallyn1651e142006-10-02 02:18:08 -070080#include <linux/nsproxy.h>
Alexey Dobriyan8ac773b2006-10-19 23:28:32 -070081#include <linux/oom.h>
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -070082#include <linux/elf.h>
Pavel Emelyanov60347f62007-10-18 23:40:03 -070083#include <linux/pid_namespace.h>
Eric W. Biederman22d917d2011-11-17 00:11:58 -080084#include <linux/user_namespace.h>
Al Viro5ad4e532009-03-29 19:50:06 -040085#include <linux/fs_struct.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090086#include <linux/slab.h>
Pavel Emelyanov640708a2012-01-10 15:11:23 -080087#include <linux/flex_array.h>
Chris Metcalff133ecc2011-05-26 12:40:09 -040088#ifdef CONFIG_HARDWALL
89#include <asm/hardwall.h>
90#endif
KAMEZAWA Hiroyuki43d2b112012-01-10 15:08:09 -080091#include <trace/events/oom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070092#include "internal.h"
Cyrill Gorcunovfaf60af2012-08-23 14:43:24 +040093#include "fd.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Eric W. Biederman0f2fe202006-06-26 00:25:46 -070095/* NOTE:
96 * Implementing inode permission operations in /proc is almost
97 * certainly an error. Permission checks need to happen during
98 * each system call not at open time. The reason is that most of
99 * what we wish to check for permissions in /proc varies at runtime.
100 *
101 * The classic example of a problem is opening file descriptors
102 * in /proc for a task before it execs a suid executable.
103 */
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105struct pid_entry {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 char *name;
Eric Dumazetc5141e62007-05-08 00:26:15 -0700107 int len;
Al Virod161a132011-07-24 03:36:29 -0400108 umode_t mode;
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800109 const struct inode_operations *iop;
Arjan van de Ven00977a52007-02-12 00:55:34 -0800110 const struct file_operations *fop;
Eric W. Biederman20cdc892006-10-02 02:17:07 -0700111 union proc_op op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112};
113
Eric W. Biederman61a28782006-10-02 02:18:49 -0700114#define NOD(NAME, MODE, IOP, FOP, OP) { \
Eric W. Biederman20cdc892006-10-02 02:17:07 -0700115 .name = (NAME), \
Eric Dumazetc5141e62007-05-08 00:26:15 -0700116 .len = sizeof(NAME) - 1, \
Eric W. Biederman20cdc892006-10-02 02:17:07 -0700117 .mode = MODE, \
118 .iop = IOP, \
119 .fop = FOP, \
120 .op = OP, \
121}
122
Alexey Dobriyan631f9c12008-11-10 01:32:52 +0300123#define DIR(NAME, MODE, iops, fops) \
124 NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} )
125#define LNK(NAME, get_link) \
Eric W. Biederman61a28782006-10-02 02:18:49 -0700126 NOD(NAME, (S_IFLNK|S_IRWXUGO), \
Eric W. Biederman20cdc892006-10-02 02:17:07 -0700127 &proc_pid_link_inode_operations, NULL, \
Alexey Dobriyan631f9c12008-11-10 01:32:52 +0300128 { .proc_get_link = get_link } )
129#define REG(NAME, MODE, fops) \
130 NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {})
131#define INF(NAME, MODE, read) \
Eric W. Biederman61a28782006-10-02 02:18:49 -0700132 NOD(NAME, (S_IFREG|(MODE)), \
Eric W. Biederman20cdc892006-10-02 02:17:07 -0700133 NULL, &proc_info_file_operations, \
Alexey Dobriyan631f9c12008-11-10 01:32:52 +0300134 { .proc_read = read } )
135#define ONE(NAME, MODE, show) \
Eric W. Biedermanbe614082008-02-08 04:18:30 -0800136 NOD(NAME, (S_IFREG|(MODE)), \
137 NULL, &proc_single_file_operations, \
Alexey Dobriyan631f9c12008-11-10 01:32:52 +0300138 { .proc_show = show } )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Vegard Nossumaed54172008-06-05 22:46:53 -0700140/*
141 * Count the number of hardlinks for the pid_entry table, excluding the .
142 * and .. links.
143 */
144static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
145 unsigned int n)
146{
147 unsigned int i;
148 unsigned int count;
149
150 count = 0;
151 for (i = 0; i < n; ++i) {
152 if (S_ISDIR(entries[i].mode))
153 ++count;
154 }
155
156 return count;
157}
158
Miklos Szeredif7ad3c62010-08-10 11:41:36 +0200159static int get_task_root(struct task_struct *task, struct path *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
Hugh Dickins7c2c7d92009-03-28 23:21:27 +0000161 int result = -ENOENT;
162
Miklos Szeredi0494f6e2005-09-06 15:18:22 -0700163 task_lock(task);
Miklos Szeredif7ad3c62010-08-10 11:41:36 +0200164 if (task->fs) {
165 get_fs_root(task->fs, root);
Hugh Dickins7c2c7d92009-03-28 23:21:27 +0000166 result = 0;
167 }
Miklos Szeredi0494f6e2005-09-06 15:18:22 -0700168 task_unlock(task);
Hugh Dickins7c2c7d92009-03-28 23:21:27 +0000169 return result;
Miklos Szeredi0494f6e2005-09-06 15:18:22 -0700170}
171
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -0800172static int proc_cwd_link(struct dentry *dentry, struct path *path)
Miklos Szeredi0494f6e2005-09-06 15:18:22 -0700173{
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -0800174 struct task_struct *task = get_proc_task(dentry->d_inode);
Miklos Szeredi0494f6e2005-09-06 15:18:22 -0700175 int result = -ENOENT;
Eric W. Biederman99f89552006-06-26 00:25:55 -0700176
177 if (task) {
Miklos Szeredif7ad3c62010-08-10 11:41:36 +0200178 task_lock(task);
179 if (task->fs) {
180 get_fs_pwd(task->fs, path);
181 result = 0;
182 }
183 task_unlock(task);
Eric W. Biederman99f89552006-06-26 00:25:55 -0700184 put_task_struct(task);
185 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 return result;
187}
188
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -0800189static int proc_root_link(struct dentry *dentry, struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -0800191 struct task_struct *task = get_proc_task(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 int result = -ENOENT;
Eric W. Biederman99f89552006-06-26 00:25:55 -0700193
194 if (task) {
Miklos Szeredif7ad3c62010-08-10 11:41:36 +0200195 result = get_task_root(task, path);
Eric W. Biederman99f89552006-06-26 00:25:55 -0700196 put_task_struct(task);
197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return result;
199}
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201static int proc_pid_cmdline(struct task_struct *task, char * buffer)
202{
203 int res = 0;
204 unsigned int len;
205 struct mm_struct *mm = get_task_mm(task);
206 if (!mm)
207 goto out;
208 if (!mm->arg_end)
209 goto out_mm; /* Shh! No looking before we're done */
210
211 len = mm->arg_end - mm->arg_start;
212
213 if (len > PAGE_SIZE)
214 len = PAGE_SIZE;
215
216 res = access_process_vm(task, mm->arg_start, buffer, len, 0);
217
218 // If the nul at the end of args has been overwritten, then
219 // assume application is using setproctitle(3).
220 if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
221 len = strnlen(buffer, res);
222 if (len < res) {
223 res = len;
224 } else {
225 len = mm->env_end - mm->env_start;
226 if (len > PAGE_SIZE - res)
227 len = PAGE_SIZE - res;
228 res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
229 res = strnlen(buffer, res);
230 }
231 }
232out_mm:
233 mmput(mm);
234out:
235 return res;
236}
237
238static int proc_pid_auxv(struct task_struct *task, char *buffer)
239{
Cong Wange7dcd992012-05-31 16:26:17 -0700240 struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ);
Al Viro2fadaef2011-02-15 22:52:11 -0500241 int res = PTR_ERR(mm);
242 if (mm && !IS_ERR(mm)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 unsigned int nwords = 0;
Hannes Ederdfe6b7d2008-12-30 18:49:13 +0300244 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 nwords += 2;
Hannes Ederdfe6b7d2008-12-30 18:49:13 +0300246 } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 res = nwords * sizeof(mm->saved_auxv[0]);
248 if (res > PAGE_SIZE)
249 res = PAGE_SIZE;
250 memcpy(buffer, mm->saved_auxv, res);
251 mmput(mm);
252 }
253 return res;
254}
255
256
257#ifdef CONFIG_KALLSYMS
258/*
259 * Provides a wchan file via kallsyms in a proper one-value-per-file format.
260 * Returns the resolved symbol. If that fails, simply return the address.
261 */
262static int proc_pid_wchan(struct task_struct *task, char *buffer)
263{
Alexey Dobriyanffb45122007-05-08 00:28:41 -0700264 unsigned long wchan;
Tejun Heo9281ace2007-07-17 04:03:51 -0700265 char symname[KSYM_NAME_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
267 wchan = get_wchan(task);
268
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -0700269 if (lookup_symbol_name(wchan, symname) < 0)
Jake Edgef83ce3e2009-05-04 12:51:14 -0600270 if (!ptrace_may_access(task, PTRACE_MODE_READ))
271 return 0;
272 else
273 return sprintf(buffer, "%lu", wchan);
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -0700274 else
275 return sprintf(buffer, "%s", symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277#endif /* CONFIG_KALLSYMS */
278
Al Viroa9712bc2011-03-23 15:52:50 -0400279static int lock_trace(struct task_struct *task)
280{
281 int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
282 if (err)
283 return err;
284 if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
285 mutex_unlock(&task->signal->cred_guard_mutex);
286 return -EPERM;
287 }
288 return 0;
289}
290
291static void unlock_trace(struct task_struct *task)
292{
293 mutex_unlock(&task->signal->cred_guard_mutex);
294}
295
Ken Chen2ec220e2008-11-10 11:26:08 +0300296#ifdef CONFIG_STACKTRACE
297
298#define MAX_STACK_TRACE_DEPTH 64
299
300static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
301 struct pid *pid, struct task_struct *task)
302{
303 struct stack_trace trace;
304 unsigned long *entries;
Al Viroa9712bc2011-03-23 15:52:50 -0400305 int err;
Ken Chen2ec220e2008-11-10 11:26:08 +0300306 int i;
307
308 entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL);
309 if (!entries)
310 return -ENOMEM;
311
312 trace.nr_entries = 0;
313 trace.max_entries = MAX_STACK_TRACE_DEPTH;
314 trace.entries = entries;
315 trace.skip = 0;
Ken Chen2ec220e2008-11-10 11:26:08 +0300316
Al Viroa9712bc2011-03-23 15:52:50 -0400317 err = lock_trace(task);
318 if (!err) {
319 save_stack_trace_tsk(task, &trace);
320
321 for (i = 0; i < trace.nr_entries; i++) {
Linus Torvaldsb81a6182011-03-23 20:51:42 -0700322 seq_printf(m, "[<%pK>] %pS\n",
Al Viroa9712bc2011-03-23 15:52:50 -0400323 (void *)entries[i], (void *)entries[i]);
324 }
325 unlock_trace(task);
Ken Chen2ec220e2008-11-10 11:26:08 +0300326 }
327 kfree(entries);
328
Al Viroa9712bc2011-03-23 15:52:50 -0400329 return err;
Ken Chen2ec220e2008-11-10 11:26:08 +0300330}
331#endif
332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333#ifdef CONFIG_SCHEDSTATS
334/*
335 * Provides /proc/PID/schedstat
336 */
337static int proc_pid_schedstat(struct task_struct *task, char *buffer)
338{
Balbir Singh172ba842007-07-09 18:52:00 +0200339 return sprintf(buffer, "%llu %llu %lu\n",
Ingo Molnar826e08b2008-12-22 07:37:41 +0100340 (unsigned long long)task->se.sum_exec_runtime,
341 (unsigned long long)task->sched_info.run_delay,
Ingo Molnar2d723762007-10-15 17:00:12 +0200342 task->sched_info.pcount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344#endif
345
Arjan van de Ven97455122008-01-25 21:08:34 +0100346#ifdef CONFIG_LATENCYTOP
347static int lstats_show_proc(struct seq_file *m, void *v)
348{
349 int i;
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800350 struct inode *inode = m->private;
351 struct task_struct *task = get_proc_task(inode);
Arjan van de Ven97455122008-01-25 21:08:34 +0100352
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800353 if (!task)
354 return -ESRCH;
355 seq_puts(m, "Latency Top version : v0.1\n");
Arjan van de Ven97455122008-01-25 21:08:34 +0100356 for (i = 0; i < 32; i++) {
Joe Perches34e49d42011-01-12 17:00:30 -0800357 struct latency_record *lr = &task->latency_record[i];
358 if (lr->backtrace[0]) {
Arjan van de Ven97455122008-01-25 21:08:34 +0100359 int q;
Joe Perches34e49d42011-01-12 17:00:30 -0800360 seq_printf(m, "%i %li %li",
361 lr->count, lr->time, lr->max);
Arjan van de Ven97455122008-01-25 21:08:34 +0100362 for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
Joe Perches34e49d42011-01-12 17:00:30 -0800363 unsigned long bt = lr->backtrace[q];
364 if (!bt)
Arjan van de Ven97455122008-01-25 21:08:34 +0100365 break;
Joe Perches34e49d42011-01-12 17:00:30 -0800366 if (bt == ULONG_MAX)
Arjan van de Ven97455122008-01-25 21:08:34 +0100367 break;
Joe Perches34e49d42011-01-12 17:00:30 -0800368 seq_printf(m, " %ps", (void *)bt);
Arjan van de Ven97455122008-01-25 21:08:34 +0100369 }
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800370 seq_putc(m, '\n');
Arjan van de Ven97455122008-01-25 21:08:34 +0100371 }
372
373 }
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800374 put_task_struct(task);
Arjan van de Ven97455122008-01-25 21:08:34 +0100375 return 0;
376}
377
378static int lstats_open(struct inode *inode, struct file *file)
379{
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800380 return single_open(file, lstats_show_proc, inode);
Hiroshi Shimamotod6643d12008-02-14 10:27:00 -0800381}
382
Arjan van de Ven97455122008-01-25 21:08:34 +0100383static ssize_t lstats_write(struct file *file, const char __user *buf,
384 size_t count, loff_t *offs)
385{
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800386 struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
Arjan van de Ven97455122008-01-25 21:08:34 +0100387
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800388 if (!task)
389 return -ESRCH;
Arjan van de Ven97455122008-01-25 21:08:34 +0100390 clear_all_latency_tracing(task);
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800391 put_task_struct(task);
Arjan van de Ven97455122008-01-25 21:08:34 +0100392
393 return count;
394}
395
396static const struct file_operations proc_lstats_operations = {
397 .open = lstats_open,
398 .read = seq_read,
399 .write = lstats_write,
400 .llseek = seq_lseek,
Hiroshi Shimamoto13d77c32008-02-20 16:53:29 -0800401 .release = single_release,
Arjan van de Ven97455122008-01-25 21:08:34 +0100402};
403
404#endif
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406static int proc_oom_score(struct task_struct *task, char *buffer)
407{
David Rientjesa7f638f2012-05-29 15:06:47 -0700408 unsigned long totalpages = totalram_pages + total_swap_pages;
Oleg Nesterovb95c35e2010-04-01 15:13:57 +0200409 unsigned long points = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Alexey Dobriyan19c5d452007-05-08 00:26:46 -0700411 read_lock(&tasklist_lock);
Oleg Nesterovb95c35e2010-04-01 15:13:57 +0200412 if (pid_alive(task))
David Rientjesa7f638f2012-05-29 15:06:47 -0700413 points = oom_badness(task, NULL, NULL, totalpages) *
414 1000 / totalpages;
Alexey Dobriyan19c5d452007-05-08 00:26:46 -0700415 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return sprintf(buffer, "%lu\n", points);
417}
418
Neil Hormand85f50d2007-10-18 23:40:37 -0700419struct limit_names {
420 char *name;
421 char *unit;
422};
423
424static const struct limit_names lnames[RLIM_NLIMITS] = {
Kees Cookcff4edb2009-09-22 16:45:32 -0700425 [RLIMIT_CPU] = {"Max cpu time", "seconds"},
Neil Hormand85f50d2007-10-18 23:40:37 -0700426 [RLIMIT_FSIZE] = {"Max file size", "bytes"},
427 [RLIMIT_DATA] = {"Max data size", "bytes"},
428 [RLIMIT_STACK] = {"Max stack size", "bytes"},
429 [RLIMIT_CORE] = {"Max core file size", "bytes"},
430 [RLIMIT_RSS] = {"Max resident set", "bytes"},
431 [RLIMIT_NPROC] = {"Max processes", "processes"},
432 [RLIMIT_NOFILE] = {"Max open files", "files"},
433 [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
434 [RLIMIT_AS] = {"Max address space", "bytes"},
435 [RLIMIT_LOCKS] = {"Max file locks", "locks"},
436 [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
437 [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
438 [RLIMIT_NICE] = {"Max nice priority", NULL},
439 [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
Eugene Teo88081172008-02-23 15:23:52 -0800440 [RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
Neil Hormand85f50d2007-10-18 23:40:37 -0700441};
442
443/* Display limits for a process */
444static int proc_pid_limits(struct task_struct *task, char *buffer)
445{
446 unsigned int i;
447 int count = 0;
448 unsigned long flags;
449 char *bufptr = buffer;
450
451 struct rlimit rlim[RLIM_NLIMITS];
452
Lai Jiangshana6bebbc2008-10-05 00:51:15 +0400453 if (!lock_task_sighand(task, &flags))
Neil Hormand85f50d2007-10-18 23:40:37 -0700454 return 0;
Neil Hormand85f50d2007-10-18 23:40:37 -0700455 memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
456 unlock_task_sighand(task, &flags);
Neil Hormand85f50d2007-10-18 23:40:37 -0700457
458 /*
459 * print the file header
460 */
461 count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n",
462 "Limit", "Soft Limit", "Hard Limit", "Units");
463
464 for (i = 0; i < RLIM_NLIMITS; i++) {
465 if (rlim[i].rlim_cur == RLIM_INFINITY)
466 count += sprintf(&bufptr[count], "%-25s %-20s ",
467 lnames[i].name, "unlimited");
468 else
469 count += sprintf(&bufptr[count], "%-25s %-20lu ",
470 lnames[i].name, rlim[i].rlim_cur);
471
472 if (rlim[i].rlim_max == RLIM_INFINITY)
473 count += sprintf(&bufptr[count], "%-20s ", "unlimited");
474 else
475 count += sprintf(&bufptr[count], "%-20lu ",
476 rlim[i].rlim_max);
477
478 if (lnames[i].unit)
479 count += sprintf(&bufptr[count], "%-10s\n",
480 lnames[i].unit);
481 else
482 count += sprintf(&bufptr[count], "\n");
483 }
484
485 return count;
486}
487
Roland McGrathebcb6732008-07-25 19:46:00 -0700488#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
489static int proc_pid_syscall(struct task_struct *task, char *buffer)
490{
491 long nr;
492 unsigned long args[6], sp, pc;
Al Viroa9712bc2011-03-23 15:52:50 -0400493 int res = lock_trace(task);
494 if (res)
495 return res;
Roland McGrathebcb6732008-07-25 19:46:00 -0700496
497 if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
Al Viroa9712bc2011-03-23 15:52:50 -0400498 res = sprintf(buffer, "running\n");
499 else if (nr < 0)
500 res = sprintf(buffer, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
501 else
502 res = sprintf(buffer,
Roland McGrathebcb6732008-07-25 19:46:00 -0700503 "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
504 nr,
505 args[0], args[1], args[2], args[3], args[4], args[5],
506 sp, pc);
Al Viroa9712bc2011-03-23 15:52:50 -0400507 unlock_trace(task);
508 return res;
Roland McGrathebcb6732008-07-25 19:46:00 -0700509}
510#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
511
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512/************************************************************************/
513/* Here the fs part begins */
514/************************************************************************/
515
516/* permission checks */
Eric W. Biederman778c1142006-06-26 00:25:58 -0700517static int proc_fd_access_allowed(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518{
Eric W. Biederman778c1142006-06-26 00:25:58 -0700519 struct task_struct *task;
520 int allowed = 0;
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700521 /* Allow access to a task's file descriptors if it is us or we
522 * may use ptrace attach to the process and find out that
523 * information.
Eric W. Biederman778c1142006-06-26 00:25:58 -0700524 */
525 task = get_proc_task(inode);
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700526 if (task) {
Stephen Smalley006ebb42008-05-19 08:32:49 -0400527 allowed = ptrace_may_access(task, PTRACE_MODE_READ);
Eric W. Biederman778c1142006-06-26 00:25:58 -0700528 put_task_struct(task);
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700529 }
Eric W. Biederman778c1142006-06-26 00:25:58 -0700530 return allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
Eric W. Biederman6b4e3062010-03-07 16:41:34 -0800533int proc_setattr(struct dentry *dentry, struct iattr *attr)
Linus Torvalds6d76fa52006-07-15 12:26:45 -0700534{
535 int error;
536 struct inode *inode = dentry->d_inode;
537
538 if (attr->ia_valid & ATTR_MODE)
539 return -EPERM;
540
541 error = inode_change_ok(inode, attr);
Christoph Hellwig10257742010-06-04 11:30:02 +0200542 if (error)
543 return error;
544
Christoph Hellwig10257742010-06-04 11:30:02 +0200545 setattr_copy(inode, attr);
546 mark_inode_dirty(inode);
547 return 0;
Linus Torvalds6d76fa52006-07-15 12:26:45 -0700548}
549
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800550/*
551 * May current process learn task's sched/cmdline info (for hide_pid_min=1)
552 * or euid/egid (for hide_pid_min=2)?
553 */
554static bool has_pid_permissions(struct pid_namespace *pid,
555 struct task_struct *task,
556 int hide_pid_min)
557{
558 if (pid->hide_pid < hide_pid_min)
559 return true;
560 if (in_group_p(pid->pid_gid))
561 return true;
562 return ptrace_may_access(task, PTRACE_MODE_READ);
563}
564
565
566static int proc_pid_permission(struct inode *inode, int mask)
567{
568 struct pid_namespace *pid = inode->i_sb->s_fs_info;
569 struct task_struct *task;
570 bool has_perms;
571
572 task = get_proc_task(inode);
Xiaotian Fenga2ef9902012-01-12 17:17:08 -0800573 if (!task)
574 return -ESRCH;
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800575 has_perms = has_pid_permissions(pid, task, 1);
576 put_task_struct(task);
577
578 if (!has_perms) {
579 if (pid->hide_pid == 2) {
580 /*
581 * Let's make getdents(), stat(), and open()
582 * consistent with each other. If a process
583 * may not stat() a file, it shouldn't be seen
584 * in procfs at all.
585 */
586 return -ENOENT;
587 }
588
589 return -EPERM;
590 }
591 return generic_permission(inode, mask);
592}
593
594
595
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800596static const struct inode_operations proc_def_inode_operations = {
Linus Torvalds6d76fa52006-07-15 12:26:45 -0700597 .setattr = proc_setattr,
598};
599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600#define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */
601
602static ssize_t proc_info_read(struct file * file, char __user * buf,
603 size_t count, loff_t *ppos)
604{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -0800605 struct inode * inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 unsigned long page;
607 ssize_t length;
Eric W. Biederman99f89552006-06-26 00:25:55 -0700608 struct task_struct *task = get_proc_task(inode);
609
610 length = -ESRCH;
611 if (!task)
612 goto out_no_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614 if (count > PROC_BLOCK_SIZE)
615 count = PROC_BLOCK_SIZE;
Eric W. Biederman99f89552006-06-26 00:25:55 -0700616
617 length = -ENOMEM;
Mel Gormane12ba742007-10-16 01:25:52 -0700618 if (!(page = __get_free_page(GFP_TEMPORARY)))
Eric W. Biederman99f89552006-06-26 00:25:55 -0700619 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 length = PROC_I(inode)->op.proc_read(task, (char*)page);
622
623 if (length >= 0)
624 length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
625 free_page(page);
Eric W. Biederman99f89552006-06-26 00:25:55 -0700626out:
627 put_task_struct(task);
628out_no_task:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 return length;
630}
631
Arjan van de Ven00977a52007-02-12 00:55:34 -0800632static const struct file_operations proc_info_file_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 .read = proc_info_read,
Arnd Bergmann87df8422010-03-17 23:06:02 +0100634 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635};
636
Eric W. Biedermanbe614082008-02-08 04:18:30 -0800637static int proc_single_show(struct seq_file *m, void *v)
638{
639 struct inode *inode = m->private;
640 struct pid_namespace *ns;
641 struct pid *pid;
642 struct task_struct *task;
643 int ret;
644
645 ns = inode->i_sb->s_fs_info;
646 pid = proc_pid(inode);
647 task = get_pid_task(pid, PIDTYPE_PID);
648 if (!task)
649 return -ESRCH;
650
651 ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);
652
653 put_task_struct(task);
654 return ret;
655}
656
657static int proc_single_open(struct inode *inode, struct file *filp)
658{
Jovi Zhangc6a34052011-01-12 17:00:34 -0800659 return single_open(filp, proc_single_show, inode);
Eric W. Biedermanbe614082008-02-08 04:18:30 -0800660}
661
662static const struct file_operations proc_single_file_operations = {
663 .open = proc_single_open,
664 .read = seq_read,
665 .llseek = seq_lseek,
666 .release = single_release,
667};
668
Cong Wangb409e572012-05-31 16:26:17 -0700669static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
Linus Torvaldse2683372012-01-17 15:21:19 -0800671 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
672 struct mm_struct *mm;
673
674 if (!task)
675 return -ESRCH;
676
Cong Wangb409e572012-05-31 16:26:17 -0700677 mm = mm_access(task, mode);
Linus Torvaldse2683372012-01-17 15:21:19 -0800678 put_task_struct(task);
679
680 if (IS_ERR(mm))
681 return PTR_ERR(mm);
682
Oleg Nesterov6d08f2c2012-01-31 17:15:11 +0100683 if (mm) {
684 /* ensure this mm_struct can't be freed */
685 atomic_inc(&mm->mm_count);
686 /* but do not pin its memory */
687 mmput(mm);
688 }
689
Linus Torvaldse2683372012-01-17 15:21:19 -0800690 file->private_data = mm;
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return 0;
693}
694
Cong Wangb409e572012-05-31 16:26:17 -0700695static int mem_open(struct inode *inode, struct file *file)
696{
Djalal Harounibc452b42012-07-30 14:42:28 -0700697 int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH);
698
699 /* OK to pass negative loff_t, we can catch out-of-range */
700 file->f_mode |= FMODE_UNSIGNED_OFFSET;
701
702 return ret;
Cong Wangb409e572012-05-31 16:26:17 -0700703}
704
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100705static ssize_t mem_rw(struct file *file, char __user *buf,
706 size_t count, loff_t *ppos, int write)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
Linus Torvaldse2683372012-01-17 15:21:19 -0800708 struct mm_struct *mm = file->private_data;
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100709 unsigned long addr = *ppos;
710 ssize_t copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 char *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Linus Torvaldse2683372012-01-17 15:21:19 -0800713 if (!mm)
714 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Mel Gormane12ba742007-10-16 01:25:52 -0700716 page = (char *)__get_free_page(GFP_TEMPORARY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 if (!page)
Linus Torvaldse2683372012-01-17 15:21:19 -0800718 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
Frederik Deweerdtf7ca54f2006-09-29 02:01:02 -0700720 copied = 0;
Oleg Nesterov6d08f2c2012-01-31 17:15:11 +0100721 if (!atomic_inc_not_zero(&mm->mm_users))
722 goto free;
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 while (count > 0) {
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100725 int this_len = min_t(int, count, PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100727 if (write && copy_from_user(page, buf, this_len)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 copied = -EFAULT;
729 break;
730 }
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100731
732 this_len = access_remote_vm(mm, addr, page, this_len, write);
733 if (!this_len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 if (!copied)
735 copied = -EIO;
736 break;
737 }
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100738
739 if (!write && copy_to_user(buf, page, this_len)) {
740 copied = -EFAULT;
741 break;
742 }
743
744 buf += this_len;
745 addr += this_len;
746 copied += this_len;
747 count -= this_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100749 *ppos = addr;
KOSAKI Motohiro30cd8902011-05-26 16:25:52 -0700750
Oleg Nesterov6d08f2c2012-01-31 17:15:11 +0100751 mmput(mm);
752free:
KOSAKI Motohiro30cd8902011-05-26 16:25:52 -0700753 free_page((unsigned long) page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 return copied;
755}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Oleg Nesterov572d34b2012-01-31 17:14:54 +0100757static ssize_t mem_read(struct file *file, char __user *buf,
758 size_t count, loff_t *ppos)
759{
760 return mem_rw(file, buf, count, ppos, 0);
761}
762
763static ssize_t mem_write(struct file *file, const char __user *buf,
764 size_t count, loff_t *ppos)
765{
766 return mem_rw(file, (char __user*)buf, count, ppos, 1);
767}
768
Matt Mackall85863e42008-02-04 22:29:04 -0800769loff_t mem_lseek(struct file *file, loff_t offset, int orig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770{
771 switch (orig) {
772 case 0:
773 file->f_pos = offset;
774 break;
775 case 1:
776 file->f_pos += offset;
777 break;
778 default:
779 return -EINVAL;
780 }
781 force_successful_syscall_return();
782 return file->f_pos;
783}
784
Linus Torvaldse2683372012-01-17 15:21:19 -0800785static int mem_release(struct inode *inode, struct file *file)
786{
787 struct mm_struct *mm = file->private_data;
Oleg Nesterov71879d32012-01-31 17:14:38 +0100788 if (mm)
Oleg Nesterov6d08f2c2012-01-31 17:15:11 +0100789 mmdrop(mm);
Linus Torvaldse2683372012-01-17 15:21:19 -0800790 return 0;
791}
792
Arjan van de Ven00977a52007-02-12 00:55:34 -0800793static const struct file_operations proc_mem_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 .llseek = mem_lseek,
795 .read = mem_read,
796 .write = mem_write,
797 .open = mem_open,
Linus Torvaldse2683372012-01-17 15:21:19 -0800798 .release = mem_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799};
800
Cong Wangb409e572012-05-31 16:26:17 -0700801static int environ_open(struct inode *inode, struct file *file)
802{
803 return __mem_open(inode, file, PTRACE_MODE_READ);
804}
805
James Pearson315e28c2007-10-16 23:30:17 -0700806static ssize_t environ_read(struct file *file, char __user *buf,
807 size_t count, loff_t *ppos)
808{
James Pearson315e28c2007-10-16 23:30:17 -0700809 char *page;
810 unsigned long src = *ppos;
Cong Wangb409e572012-05-31 16:26:17 -0700811 int ret = 0;
812 struct mm_struct *mm = file->private_data;
James Pearson315e28c2007-10-16 23:30:17 -0700813
Cong Wangb409e572012-05-31 16:26:17 -0700814 if (!mm)
815 return 0;
James Pearson315e28c2007-10-16 23:30:17 -0700816
James Pearson315e28c2007-10-16 23:30:17 -0700817 page = (char *)__get_free_page(GFP_TEMPORARY);
818 if (!page)
Cong Wangb409e572012-05-31 16:26:17 -0700819 return -ENOMEM;
James Pearson315e28c2007-10-16 23:30:17 -0700820
Al Virod6f64b82011-02-15 22:26:01 -0500821 ret = 0;
Cong Wangb409e572012-05-31 16:26:17 -0700822 if (!atomic_inc_not_zero(&mm->mm_users))
823 goto free;
James Pearson315e28c2007-10-16 23:30:17 -0700824 while (count > 0) {
Djalal Harounie8905ec2012-07-30 14:42:26 -0700825 size_t this_len, max_len;
826 int retval;
827
828 if (src >= (mm->env_end - mm->env_start))
829 break;
James Pearson315e28c2007-10-16 23:30:17 -0700830
831 this_len = mm->env_end - (mm->env_start + src);
832
Djalal Harounie8905ec2012-07-30 14:42:26 -0700833 max_len = min_t(size_t, PAGE_SIZE, count);
834 this_len = min(max_len, this_len);
James Pearson315e28c2007-10-16 23:30:17 -0700835
Cong Wangb409e572012-05-31 16:26:17 -0700836 retval = access_remote_vm(mm, (mm->env_start + src),
James Pearson315e28c2007-10-16 23:30:17 -0700837 page, this_len, 0);
838
839 if (retval <= 0) {
840 ret = retval;
841 break;
842 }
843
844 if (copy_to_user(buf, page, retval)) {
845 ret = -EFAULT;
846 break;
847 }
848
849 ret += retval;
850 src += retval;
851 buf += retval;
852 count -= retval;
853 }
854 *ppos = src;
James Pearson315e28c2007-10-16 23:30:17 -0700855 mmput(mm);
Cong Wangb409e572012-05-31 16:26:17 -0700856
857free:
James Pearson315e28c2007-10-16 23:30:17 -0700858 free_page((unsigned long) page);
James Pearson315e28c2007-10-16 23:30:17 -0700859 return ret;
860}
861
862static const struct file_operations proc_environ_operations = {
Cong Wangb409e572012-05-31 16:26:17 -0700863 .open = environ_open,
James Pearson315e28c2007-10-16 23:30:17 -0700864 .read = environ_read,
Arnd Bergmann87df8422010-03-17 23:06:02 +0100865 .llseek = generic_file_llseek,
Cong Wangb409e572012-05-31 16:26:17 -0700866 .release = mem_release,
James Pearson315e28c2007-10-16 23:30:17 -0700867};
868
David Rientjesfa0cbbf2012-11-12 17:53:04 -0800869static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,
870 loff_t *ppos)
871{
872 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
873 char buffer[PROC_NUMBUF];
874 int oom_adj = OOM_ADJUST_MIN;
875 size_t len;
876 unsigned long flags;
877
878 if (!task)
879 return -ESRCH;
880 if (lock_task_sighand(task, &flags)) {
881 if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX)
882 oom_adj = OOM_ADJUST_MAX;
883 else
884 oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) /
885 OOM_SCORE_ADJ_MAX;
886 unlock_task_sighand(task, &flags);
887 }
888 put_task_struct(task);
889 len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj);
890 return simple_read_from_buffer(buf, count, ppos, buffer, len);
891}
892
893static ssize_t oom_adj_write(struct file *file, const char __user *buf,
894 size_t count, loff_t *ppos)
895{
896 struct task_struct *task;
897 char buffer[PROC_NUMBUF];
898 int oom_adj;
899 unsigned long flags;
900 int err;
901
902 memset(buffer, 0, sizeof(buffer));
903 if (count > sizeof(buffer) - 1)
904 count = sizeof(buffer) - 1;
905 if (copy_from_user(buffer, buf, count)) {
906 err = -EFAULT;
907 goto out;
908 }
909
910 err = kstrtoint(strstrip(buffer), 0, &oom_adj);
911 if (err)
912 goto out;
913 if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) &&
914 oom_adj != OOM_DISABLE) {
915 err = -EINVAL;
916 goto out;
917 }
918
919 task = get_proc_task(file->f_path.dentry->d_inode);
920 if (!task) {
921 err = -ESRCH;
922 goto out;
923 }
924
925 task_lock(task);
926 if (!task->mm) {
927 err = -EINVAL;
928 goto err_task_lock;
929 }
930
931 if (!lock_task_sighand(task, &flags)) {
932 err = -ESRCH;
933 goto err_task_lock;
934 }
935
936 /*
937 * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
938 * value is always attainable.
939 */
940 if (oom_adj == OOM_ADJUST_MAX)
941 oom_adj = OOM_SCORE_ADJ_MAX;
942 else
943 oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
944
945 if (oom_adj < task->signal->oom_score_adj &&
946 !capable(CAP_SYS_RESOURCE)) {
947 err = -EACCES;
948 goto err_sighand;
949 }
950
951 /*
952 * /proc/pid/oom_adj is provided for legacy purposes, ask users to use
953 * /proc/pid/oom_score_adj instead.
954 */
955 printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
956 current->comm, task_pid_nr(current), task_pid_nr(task),
957 task_pid_nr(task));
958
959 task->signal->oom_score_adj = oom_adj;
960 trace_oom_score_adj_update(task);
961err_sighand:
962 unlock_task_sighand(task, &flags);
963err_task_lock:
964 task_unlock(task);
965 put_task_struct(task);
966out:
967 return err < 0 ? err : count;
968}
969
970static const struct file_operations proc_oom_adj_operations = {
971 .read = oom_adj_read,
972 .write = oom_adj_write,
973 .llseek = generic_file_llseek,
974};
975
David Rientjesa63d83f2010-08-09 17:19:46 -0700976static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
977 size_t count, loff_t *ppos)
978{
979 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
980 char buffer[PROC_NUMBUF];
David Rientjesa9c58b902012-12-11 16:02:54 -0800981 short oom_score_adj = OOM_SCORE_ADJ_MIN;
David Rientjesa63d83f2010-08-09 17:19:46 -0700982 unsigned long flags;
983 size_t len;
984
985 if (!task)
986 return -ESRCH;
987 if (lock_task_sighand(task, &flags)) {
988 oom_score_adj = task->signal->oom_score_adj;
989 unlock_task_sighand(task, &flags);
990 }
991 put_task_struct(task);
David Rientjesa9c58b902012-12-11 16:02:54 -0800992 len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj);
David Rientjesa63d83f2010-08-09 17:19:46 -0700993 return simple_read_from_buffer(buf, count, ppos, buffer, len);
994}
995
996static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
997 size_t count, loff_t *ppos)
998{
999 struct task_struct *task;
1000 char buffer[PROC_NUMBUF];
1001 unsigned long flags;
Alexey Dobriyan0a8cb8e2011-05-26 16:25:50 -07001002 int oom_score_adj;
David Rientjesa63d83f2010-08-09 17:19:46 -07001003 int err;
1004
1005 memset(buffer, 0, sizeof(buffer));
1006 if (count > sizeof(buffer) - 1)
1007 count = sizeof(buffer) - 1;
David Rientjes723548b2010-10-26 14:21:25 -07001008 if (copy_from_user(buffer, buf, count)) {
1009 err = -EFAULT;
1010 goto out;
1011 }
David Rientjesa63d83f2010-08-09 17:19:46 -07001012
Alexey Dobriyan0a8cb8e2011-05-26 16:25:50 -07001013 err = kstrtoint(strstrip(buffer), 0, &oom_score_adj);
David Rientjesa63d83f2010-08-09 17:19:46 -07001014 if (err)
David Rientjes723548b2010-10-26 14:21:25 -07001015 goto out;
David Rientjesa63d83f2010-08-09 17:19:46 -07001016 if (oom_score_adj < OOM_SCORE_ADJ_MIN ||
David Rientjes723548b2010-10-26 14:21:25 -07001017 oom_score_adj > OOM_SCORE_ADJ_MAX) {
1018 err = -EINVAL;
1019 goto out;
1020 }
David Rientjesa63d83f2010-08-09 17:19:46 -07001021
1022 task = get_proc_task(file->f_path.dentry->d_inode);
David Rientjes723548b2010-10-26 14:21:25 -07001023 if (!task) {
1024 err = -ESRCH;
1025 goto out;
1026 }
David Rientjesa63d83f2010-08-09 17:19:46 -07001027
Ying Han3d5992d2010-10-26 14:21:23 -07001028 task_lock(task);
1029 if (!task->mm) {
David Rientjes723548b2010-10-26 14:21:25 -07001030 err = -EINVAL;
1031 goto err_task_lock;
Ying Han3d5992d2010-10-26 14:21:23 -07001032 }
David Rientjesd19d5472010-10-26 14:21:26 -07001033
1034 if (!lock_task_sighand(task, &flags)) {
1035 err = -ESRCH;
1036 goto err_task_lock;
1037 }
1038
David Rientjesa9c58b902012-12-11 16:02:54 -08001039 if ((short)oom_score_adj < task->signal->oom_score_adj_min &&
David Rientjesd19d5472010-10-26 14:21:26 -07001040 !capable(CAP_SYS_RESOURCE)) {
1041 err = -EACCES;
1042 goto err_sighand;
1043 }
1044
David Rientjesa9c58b902012-12-11 16:02:54 -08001045 task->signal->oom_score_adj = (short)oom_score_adj;
Mandeep Singh Bainesdabb16f2011-01-13 15:46:05 -08001046 if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
David Rientjesa9c58b902012-12-11 16:02:54 -08001047 task->signal->oom_score_adj_min = (short)oom_score_adj;
KAMEZAWA Hiroyuki43d2b112012-01-10 15:08:09 -08001048 trace_oom_score_adj_update(task);
Davidlohr Bueso01dc52e2012-10-08 16:29:30 -07001049
David Rientjes723548b2010-10-26 14:21:25 -07001050err_sighand:
David Rientjesa63d83f2010-08-09 17:19:46 -07001051 unlock_task_sighand(task, &flags);
David Rientjesd19d5472010-10-26 14:21:26 -07001052err_task_lock:
1053 task_unlock(task);
David Rientjesa63d83f2010-08-09 17:19:46 -07001054 put_task_struct(task);
David Rientjes723548b2010-10-26 14:21:25 -07001055out:
1056 return err < 0 ? err : count;
David Rientjesa63d83f2010-08-09 17:19:46 -07001057}
1058
1059static const struct file_operations proc_oom_score_adj_operations = {
1060 .read = oom_score_adj_read,
1061 .write = oom_score_adj_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001062 .llseek = default_llseek,
David Rientjesa63d83f2010-08-09 17:19:46 -07001063};
1064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065#ifdef CONFIG_AUDITSYSCALL
1066#define TMPBUFLEN 21
1067static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
1068 size_t count, loff_t *ppos)
1069{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08001070 struct inode * inode = file->f_path.dentry->d_inode;
Eric W. Biederman99f89552006-06-26 00:25:55 -07001071 struct task_struct *task = get_proc_task(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 ssize_t length;
1073 char tmpbuf[TMPBUFLEN];
1074
Eric W. Biederman99f89552006-06-26 00:25:55 -07001075 if (!task)
1076 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
Eric W. Biedermane1760bd2012-09-10 22:39:43 -07001078 from_kuid(file->f_cred->user_ns,
1079 audit_get_loginuid(task)));
Eric W. Biederman99f89552006-06-26 00:25:55 -07001080 put_task_struct(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1082}
1083
1084static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
1085 size_t count, loff_t *ppos)
1086{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08001087 struct inode * inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 char *page, *tmp;
1089 ssize_t length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 uid_t loginuid;
Eric W. Biedermane1760bd2012-09-10 22:39:43 -07001091 kuid_t kloginuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Paul E. McKenney7dc52152010-02-22 17:04:52 -08001093 rcu_read_lock();
1094 if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {
1095 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 return -EPERM;
Paul E. McKenney7dc52152010-02-22 17:04:52 -08001097 }
1098 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Al Viroe0182902006-05-18 08:28:02 -04001100 if (count >= PAGE_SIZE)
1101 count = PAGE_SIZE - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
1103 if (*ppos != 0) {
1104 /* No partial writes. */
1105 return -EINVAL;
1106 }
Mel Gormane12ba742007-10-16 01:25:52 -07001107 page = (char*)__get_free_page(GFP_TEMPORARY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 if (!page)
1109 return -ENOMEM;
1110 length = -EFAULT;
1111 if (copy_from_user(page, buf, count))
1112 goto out_free_page;
1113
Al Viroe0182902006-05-18 08:28:02 -04001114 page[count] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 loginuid = simple_strtoul(page, &tmp, 10);
1116 if (tmp == page) {
1117 length = -EINVAL;
1118 goto out_free_page;
1119
1120 }
Eric W. Biedermane1760bd2012-09-10 22:39:43 -07001121 kloginuid = make_kuid(file->f_cred->user_ns, loginuid);
1122 if (!uid_valid(kloginuid)) {
1123 length = -EINVAL;
1124 goto out_free_page;
1125 }
1126
1127 length = audit_set_loginuid(kloginuid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 if (likely(length == 0))
1129 length = count;
1130
1131out_free_page:
1132 free_page((unsigned long) page);
1133 return length;
1134}
1135
Arjan van de Ven00977a52007-02-12 00:55:34 -08001136static const struct file_operations proc_loginuid_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 .read = proc_loginuid_read,
1138 .write = proc_loginuid_write,
Arnd Bergmann87df8422010-03-17 23:06:02 +01001139 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140};
Eric Paris1e0bd752008-03-13 08:15:31 -04001141
1142static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
1143 size_t count, loff_t *ppos)
1144{
1145 struct inode * inode = file->f_path.dentry->d_inode;
1146 struct task_struct *task = get_proc_task(inode);
1147 ssize_t length;
1148 char tmpbuf[TMPBUFLEN];
1149
1150 if (!task)
1151 return -ESRCH;
1152 length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1153 audit_get_sessionid(task));
1154 put_task_struct(task);
1155 return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1156}
1157
1158static const struct file_operations proc_sessionid_operations = {
1159 .read = proc_sessionid_read,
Arnd Bergmann87df8422010-03-17 23:06:02 +01001160 .llseek = generic_file_llseek,
Eric Paris1e0bd752008-03-13 08:15:31 -04001161};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162#endif
1163
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001164#ifdef CONFIG_FAULT_INJECTION
1165static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
1166 size_t count, loff_t *ppos)
1167{
1168 struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
1169 char buffer[PROC_NUMBUF];
1170 size_t len;
1171 int make_it_fail;
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001172
1173 if (!task)
1174 return -ESRCH;
1175 make_it_fail = task->make_it_fail;
1176 put_task_struct(task);
1177
1178 len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
Akinobu Mita0c28f282007-05-08 00:31:41 -07001179
1180 return simple_read_from_buffer(buf, count, ppos, buffer, len);
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001181}
1182
1183static ssize_t proc_fault_inject_write(struct file * file,
1184 const char __user * buf, size_t count, loff_t *ppos)
1185{
1186 struct task_struct *task;
1187 char buffer[PROC_NUMBUF], *end;
1188 int make_it_fail;
1189
1190 if (!capable(CAP_SYS_RESOURCE))
1191 return -EPERM;
1192 memset(buffer, 0, sizeof(buffer));
1193 if (count > sizeof(buffer) - 1)
1194 count = sizeof(buffer) - 1;
1195 if (copy_from_user(buffer, buf, count))
1196 return -EFAULT;
Vincent Licba8aaf2009-09-22 16:45:38 -07001197 make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
1198 if (*end)
1199 return -EINVAL;
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001200 task = get_proc_task(file->f_dentry->d_inode);
1201 if (!task)
1202 return -ESRCH;
1203 task->make_it_fail = make_it_fail;
1204 put_task_struct(task);
Vincent Licba8aaf2009-09-22 16:45:38 -07001205
1206 return count;
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001207}
1208
Arjan van de Ven00977a52007-02-12 00:55:34 -08001209static const struct file_operations proc_fault_inject_operations = {
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001210 .read = proc_fault_inject_read,
1211 .write = proc_fault_inject_write,
Arnd Bergmann87df8422010-03-17 23:06:02 +01001212 .llseek = generic_file_llseek,
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001213};
1214#endif
1215
Arjan van de Ven97455122008-01-25 21:08:34 +01001216
Ingo Molnar43ae34c2007-07-09 18:52:00 +02001217#ifdef CONFIG_SCHED_DEBUG
1218/*
1219 * Print out various scheduling related per-task fields:
1220 */
1221static int sched_show(struct seq_file *m, void *v)
1222{
1223 struct inode *inode = m->private;
1224 struct task_struct *p;
1225
Ingo Molnar43ae34c2007-07-09 18:52:00 +02001226 p = get_proc_task(inode);
1227 if (!p)
1228 return -ESRCH;
1229 proc_sched_show_task(p, m);
1230
1231 put_task_struct(p);
1232
1233 return 0;
1234}
1235
1236static ssize_t
1237sched_write(struct file *file, const char __user *buf,
1238 size_t count, loff_t *offset)
1239{
1240 struct inode *inode = file->f_path.dentry->d_inode;
1241 struct task_struct *p;
1242
Ingo Molnar43ae34c2007-07-09 18:52:00 +02001243 p = get_proc_task(inode);
1244 if (!p)
1245 return -ESRCH;
1246 proc_sched_set_task(p);
1247
1248 put_task_struct(p);
1249
1250 return count;
1251}
1252
1253static int sched_open(struct inode *inode, struct file *filp)
1254{
Jovi Zhangc6a34052011-01-12 17:00:34 -08001255 return single_open(filp, sched_show, inode);
Ingo Molnar43ae34c2007-07-09 18:52:00 +02001256}
1257
1258static const struct file_operations proc_pid_sched_operations = {
1259 .open = sched_open,
1260 .read = seq_read,
1261 .write = sched_write,
1262 .llseek = seq_lseek,
Alexey Dobriyan5ea473a2007-07-31 00:38:50 -07001263 .release = single_release,
Ingo Molnar43ae34c2007-07-09 18:52:00 +02001264};
1265
1266#endif
1267
Mike Galbraith5091faa2010-11-30 14:18:03 +01001268#ifdef CONFIG_SCHED_AUTOGROUP
1269/*
1270 * Print out autogroup related information:
1271 */
1272static int sched_autogroup_show(struct seq_file *m, void *v)
1273{
1274 struct inode *inode = m->private;
1275 struct task_struct *p;
1276
1277 p = get_proc_task(inode);
1278 if (!p)
1279 return -ESRCH;
1280 proc_sched_autogroup_show_task(p, m);
1281
1282 put_task_struct(p);
1283
1284 return 0;
1285}
1286
1287static ssize_t
1288sched_autogroup_write(struct file *file, const char __user *buf,
1289 size_t count, loff_t *offset)
1290{
1291 struct inode *inode = file->f_path.dentry->d_inode;
1292 struct task_struct *p;
1293 char buffer[PROC_NUMBUF];
Alexey Dobriyan0a8cb8e2011-05-26 16:25:50 -07001294 int nice;
Mike Galbraith5091faa2010-11-30 14:18:03 +01001295 int err;
1296
1297 memset(buffer, 0, sizeof(buffer));
1298 if (count > sizeof(buffer) - 1)
1299 count = sizeof(buffer) - 1;
1300 if (copy_from_user(buffer, buf, count))
1301 return -EFAULT;
1302
Alexey Dobriyan0a8cb8e2011-05-26 16:25:50 -07001303 err = kstrtoint(strstrip(buffer), 0, &nice);
1304 if (err < 0)
1305 return err;
Mike Galbraith5091faa2010-11-30 14:18:03 +01001306
1307 p = get_proc_task(inode);
1308 if (!p)
1309 return -ESRCH;
1310
Hiroshi Shimamoto2e5b5b32012-02-23 17:41:27 +09001311 err = proc_sched_autogroup_set_nice(p, nice);
Mike Galbraith5091faa2010-11-30 14:18:03 +01001312 if (err)
1313 count = err;
1314
1315 put_task_struct(p);
1316
1317 return count;
1318}
1319
1320static int sched_autogroup_open(struct inode *inode, struct file *filp)
1321{
1322 int ret;
1323
1324 ret = single_open(filp, sched_autogroup_show, NULL);
1325 if (!ret) {
1326 struct seq_file *m = filp->private_data;
1327
1328 m->private = inode;
1329 }
1330 return ret;
1331}
1332
1333static const struct file_operations proc_pid_sched_autogroup_operations = {
1334 .open = sched_autogroup_open,
1335 .read = seq_read,
1336 .write = sched_autogroup_write,
1337 .llseek = seq_lseek,
1338 .release = single_release,
1339};
1340
1341#endif /* CONFIG_SCHED_AUTOGROUP */
1342
john stultz4614a696b2009-12-14 18:00:05 -08001343static ssize_t comm_write(struct file *file, const char __user *buf,
1344 size_t count, loff_t *offset)
1345{
1346 struct inode *inode = file->f_path.dentry->d_inode;
1347 struct task_struct *p;
1348 char buffer[TASK_COMM_LEN];
1349
1350 memset(buffer, 0, sizeof(buffer));
1351 if (count > sizeof(buffer) - 1)
1352 count = sizeof(buffer) - 1;
1353 if (copy_from_user(buffer, buf, count))
1354 return -EFAULT;
1355
1356 p = get_proc_task(inode);
1357 if (!p)
1358 return -ESRCH;
1359
1360 if (same_thread_group(current, p))
1361 set_task_comm(p, buffer);
1362 else
1363 count = -EINVAL;
1364
1365 put_task_struct(p);
1366
1367 return count;
1368}
1369
1370static int comm_show(struct seq_file *m, void *v)
1371{
1372 struct inode *inode = m->private;
1373 struct task_struct *p;
1374
1375 p = get_proc_task(inode);
1376 if (!p)
1377 return -ESRCH;
1378
1379 task_lock(p);
1380 seq_printf(m, "%s\n", p->comm);
1381 task_unlock(p);
1382
1383 put_task_struct(p);
1384
1385 return 0;
1386}
1387
1388static int comm_open(struct inode *inode, struct file *filp)
1389{
Jovi Zhangc6a34052011-01-12 17:00:34 -08001390 return single_open(filp, comm_show, inode);
john stultz4614a696b2009-12-14 18:00:05 -08001391}
1392
1393static const struct file_operations proc_pid_set_comm_operations = {
1394 .open = comm_open,
1395 .read = seq_read,
1396 .write = comm_write,
1397 .llseek = seq_lseek,
1398 .release = single_release,
1399};
1400
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -08001401static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
Matt Helsley925d1c42008-04-29 01:01:36 -07001402{
1403 struct task_struct *task;
1404 struct mm_struct *mm;
1405 struct file *exe_file;
1406
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -08001407 task = get_proc_task(dentry->d_inode);
Matt Helsley925d1c42008-04-29 01:01:36 -07001408 if (!task)
1409 return -ENOENT;
1410 mm = get_task_mm(task);
1411 put_task_struct(task);
1412 if (!mm)
1413 return -ENOENT;
1414 exe_file = get_mm_exe_file(mm);
1415 mmput(mm);
1416 if (exe_file) {
1417 *exe_path = exe_file->f_path;
1418 path_get(&exe_file->f_path);
1419 fput(exe_file);
1420 return 0;
1421 } else
1422 return -ENOENT;
1423}
1424
Al Viro008b1502005-08-20 00:17:39 +01001425static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426{
1427 struct inode *inode = dentry->d_inode;
Christoph Hellwig408ef012012-06-18 10:47:03 -04001428 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 int error = -EACCES;
1430
Eric W. Biederman778c1142006-06-26 00:25:58 -07001431 /* Are we allowed to snoop on the tasks file descriptors? */
1432 if (!proc_fd_access_allowed(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Christoph Hellwig408ef012012-06-18 10:47:03 -04001435 error = PROC_I(inode)->op.proc_get_link(dentry, &path);
1436 if (error)
1437 goto out;
1438
Christoph Hellwigb5fb63c12012-06-18 10:47:04 -04001439 nd_jump_link(nd, &path);
Christoph Hellwig408ef012012-06-18 10:47:03 -04001440 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441out:
Al Viro008b1502005-08-20 00:17:39 +01001442 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443}
1444
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001445static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446{
Mel Gormane12ba742007-10-16 01:25:52 -07001447 char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001448 char *pathname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 int len;
1450
1451 if (!tmp)
1452 return -ENOMEM;
Akinobu Mita0c28f282007-05-08 00:31:41 -07001453
Eric W. Biederman7b2a69b2010-12-05 15:51:21 -08001454 pathname = d_path(path, tmp, PAGE_SIZE);
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001455 len = PTR_ERR(pathname);
1456 if (IS_ERR(pathname))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 goto out;
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001458 len = tmp + PAGE_SIZE - 1 - pathname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460 if (len > buflen)
1461 len = buflen;
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001462 if (copy_to_user(buffer, pathname, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 len = -EFAULT;
1464 out:
1465 free_page((unsigned long)tmp);
1466 return len;
1467}
1468
1469static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
1470{
1471 int error = -EACCES;
1472 struct inode *inode = dentry->d_inode;
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001473 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Eric W. Biederman778c1142006-06-26 00:25:58 -07001475 /* Are we allowed to snoop on the tasks file descriptors? */
1476 if (!proc_fd_access_allowed(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
Cyrill Gorcunov7773fbc2012-01-10 15:11:20 -08001479 error = PROC_I(inode)->op.proc_get_link(dentry, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 if (error)
1481 goto out;
1482
Jan Blunck3dcd25f2008-02-14 19:38:35 -08001483 error = do_proc_readlink(&path, buffer, buflen);
1484 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 return error;
1487}
1488
Cyrill Gorcunovfaf60af2012-08-23 14:43:24 +04001489const struct inode_operations proc_pid_link_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 .readlink = proc_pid_readlink,
Linus Torvalds6d76fa52006-07-15 12:26:45 -07001491 .follow_link = proc_pid_follow_link,
1492 .setattr = proc_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493};
1494
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001495
1496/* building an inode */
1497
Eric W. Biederman6b4e3062010-03-07 16:41:34 -08001498struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001499{
1500 struct inode * inode;
1501 struct proc_inode *ei;
David Howellsc69e8d92008-11-14 10:39:19 +11001502 const struct cred *cred;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001503
1504 /* We need a new inode */
1505
1506 inode = new_inode(sb);
1507 if (!inode)
1508 goto out;
1509
1510 /* Common stuff */
1511 ei = PROC_I(inode);
Christoph Hellwig85fe4022010-10-23 11:19:54 -04001512 inode->i_ino = get_next_ino();
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001513 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001514 inode->i_op = &proc_def_inode_operations;
1515
1516 /*
1517 * grab the reference to task.
1518 */
Oleg Nesterov1a657f782006-10-02 02:18:59 -07001519 ei->pid = get_task_pid(task, PIDTYPE_PID);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001520 if (!ei->pid)
1521 goto out_unlock;
1522
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001523 if (task_dumpable(task)) {
David Howellsc69e8d92008-11-14 10:39:19 +11001524 rcu_read_lock();
1525 cred = __task_cred(task);
1526 inode->i_uid = cred->euid;
1527 inode->i_gid = cred->egid;
1528 rcu_read_unlock();
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001529 }
1530 security_task_to_inode(task, inode);
1531
1532out:
1533 return inode;
1534
1535out_unlock:
1536 iput(inode);
1537 return NULL;
1538}
1539
Eric W. Biederman6b4e3062010-03-07 16:41:34 -08001540int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001541{
1542 struct inode *inode = dentry->d_inode;
1543 struct task_struct *task;
David Howellsc69e8d92008-11-14 10:39:19 +11001544 const struct cred *cred;
Vasiliy Kulikov04996802012-01-10 15:11:31 -08001545 struct pid_namespace *pid = dentry->d_sb->s_fs_info;
David Howellsc69e8d92008-11-14 10:39:19 +11001546
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001547 generic_fillattr(inode, stat);
1548
1549 rcu_read_lock();
Eric W. Biedermandcb0f222012-02-09 08:48:21 -08001550 stat->uid = GLOBAL_ROOT_UID;
1551 stat->gid = GLOBAL_ROOT_GID;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001552 task = pid_task(proc_pid(inode), PIDTYPE_PID);
1553 if (task) {
Vasiliy Kulikov04996802012-01-10 15:11:31 -08001554 if (!has_pid_permissions(pid, task, 2)) {
1555 rcu_read_unlock();
1556 /*
1557 * This doesn't prevent learning whether PID exists,
1558 * it only makes getattr() consistent with readdir().
1559 */
1560 return -ENOENT;
1561 }
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001562 if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1563 task_dumpable(task)) {
David Howellsc69e8d92008-11-14 10:39:19 +11001564 cred = __task_cred(task);
1565 stat->uid = cred->euid;
1566 stat->gid = cred->egid;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001567 }
1568 }
1569 rcu_read_unlock();
1570 return 0;
1571}
1572
1573/* dentry stuff */
1574
1575/*
1576 * Exceptional case: normally we are not allowed to unhash a busy
1577 * directory. In this case, however, we can do it - no aliasing problems
1578 * due to the way we treat inodes.
1579 *
1580 * Rewrite the inode's ownerships here because the owning task may have
1581 * performed a setuid(), etc.
1582 *
1583 * Before the /proc/pid/status file was created the only way to read
1584 * the effective uid of a /process was to stat /proc/pid. Reading
1585 * /proc/pid/status is slow enough that procps and other packages
1586 * kept stating /proc/pid. To keep the rules in /proc simple I have
1587 * made this apply to all per process world readable and executable
1588 * directories.
1589 */
Al Viro0b728e12012-06-10 16:03:43 -04001590int pid_revalidate(struct dentry *dentry, unsigned int flags)
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001591{
Nick Piggin34286d62011-01-07 17:49:57 +11001592 struct inode *inode;
1593 struct task_struct *task;
David Howellsc69e8d92008-11-14 10:39:19 +11001594 const struct cred *cred;
1595
Al Viro0b728e12012-06-10 16:03:43 -04001596 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +11001597 return -ECHILD;
1598
1599 inode = dentry->d_inode;
1600 task = get_proc_task(inode);
1601
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001602 if (task) {
1603 if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1604 task_dumpable(task)) {
David Howellsc69e8d92008-11-14 10:39:19 +11001605 rcu_read_lock();
1606 cred = __task_cred(task);
1607 inode->i_uid = cred->euid;
1608 inode->i_gid = cred->egid;
1609 rcu_read_unlock();
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001610 } else {
Eric W. Biedermandcb0f222012-02-09 08:48:21 -08001611 inode->i_uid = GLOBAL_ROOT_UID;
1612 inode->i_gid = GLOBAL_ROOT_GID;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001613 }
1614 inode->i_mode &= ~(S_ISUID | S_ISGID);
1615 security_task_to_inode(task, inode);
1616 put_task_struct(task);
1617 return 1;
1618 }
1619 d_drop(dentry);
1620 return 0;
1621}
1622
Eric W. Biederman6b4e3062010-03-07 16:41:34 -08001623const struct dentry_operations pid_dentry_operations =
Eric W. Biederman28a6d672006-10-02 02:17:05 -07001624{
1625 .d_revalidate = pid_revalidate,
1626 .d_delete = pid_delete_dentry,
1627};
1628
1629/* Lookups */
1630
Eric W. Biederman1c0d04c2006-10-02 02:18:57 -07001631/*
1632 * Fill a directory entry.
1633 *
1634 * If possible create the dcache entry and derive our inode number and
1635 * file type from dcache entry.
1636 *
1637 * Since all of the proc inode numbers are dynamically generated, the inode
1638 * numbers do not exist until the inode is cache. This means creating the
1639 * the dcache entry in readdir is necessary to keep the inode numbers
1640 * reported by readdir in sync with the inode numbers reported
1641 * by stat.
1642 */
Eric W. Biederman6b4e3062010-03-07 16:41:34 -08001643int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
1644 const char *name, int len,
Eric Dumazetc5141e62007-05-08 00:26:15 -07001645 instantiate_t instantiate, struct task_struct *task, const void *ptr)
Eric W. Biederman61a28782006-10-02 02:18:49 -07001646{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08001647 struct dentry *child, *dir = filp->f_path.dentry;
Eric W. Biederman61a28782006-10-02 02:18:49 -07001648 struct inode *inode;
1649 struct qstr qname;
1650 ino_t ino = 0;
1651 unsigned type = DT_UNKNOWN;
1652
1653 qname.name = name;
1654 qname.len = len;
1655 qname.hash = full_name_hash(name, len);
1656
1657 child = d_lookup(dir, &qname);
1658 if (!child) {
1659 struct dentry *new;
1660 new = d_alloc(dir, &qname);
1661 if (new) {
1662 child = instantiate(dir->d_inode, new, task, ptr);
1663 if (child)
1664 dput(new);
1665 else
1666 child = new;
1667 }
1668 }
1669 if (!child || IS_ERR(child) || !child->d_inode)
1670 goto end_instantiate;
1671 inode = child->d_inode;
1672 if (inode) {
1673 ino = inode->i_ino;
1674 type = inode->i_mode >> 12;
1675 }
1676 dput(child);
1677end_instantiate:
1678 if (!ino)
1679 ino = find_inode_number(dir, &qname);
1680 if (!ino)
1681 ino = 1;
1682 return filldir(dirent, name, len, filp->f_pos, ino, type);
1683}
1684
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001685#ifdef CONFIG_CHECKPOINT_RESTORE
1686
1687/*
1688 * dname_to_vma_addr - maps a dentry name into two unsigned longs
1689 * which represent vma start and end addresses.
1690 */
1691static int dname_to_vma_addr(struct dentry *dentry,
1692 unsigned long *start, unsigned long *end)
1693{
1694 if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2)
1695 return -EINVAL;
1696
1697 return 0;
1698}
1699
Al Viro0b728e12012-06-10 16:03:43 -04001700static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001701{
1702 unsigned long vm_start, vm_end;
1703 bool exact_vma_exists = false;
1704 struct mm_struct *mm = NULL;
1705 struct task_struct *task;
1706 const struct cred *cred;
1707 struct inode *inode;
1708 int status = 0;
1709
Al Viro0b728e12012-06-10 16:03:43 -04001710 if (flags & LOOKUP_RCU)
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001711 return -ECHILD;
1712
1713 if (!capable(CAP_SYS_ADMIN)) {
1714 status = -EACCES;
1715 goto out_notask;
1716 }
1717
1718 inode = dentry->d_inode;
1719 task = get_proc_task(inode);
1720 if (!task)
1721 goto out_notask;
1722
Cong Wang2344bec2012-05-31 16:26:18 -07001723 mm = mm_access(task, PTRACE_MODE_READ);
1724 if (IS_ERR_OR_NULL(mm))
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001725 goto out;
1726
1727 if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
1728 down_read(&mm->mmap_sem);
1729 exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end);
1730 up_read(&mm->mmap_sem);
1731 }
1732
1733 mmput(mm);
1734
1735 if (exact_vma_exists) {
1736 if (task_dumpable(task)) {
1737 rcu_read_lock();
1738 cred = __task_cred(task);
1739 inode->i_uid = cred->euid;
1740 inode->i_gid = cred->egid;
1741 rcu_read_unlock();
1742 } else {
Eric W. Biedermandcb0f222012-02-09 08:48:21 -08001743 inode->i_uid = GLOBAL_ROOT_UID;
1744 inode->i_gid = GLOBAL_ROOT_GID;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001745 }
1746 security_task_to_inode(task, inode);
1747 status = 1;
1748 }
1749
1750out:
1751 put_task_struct(task);
1752
1753out_notask:
1754 if (status <= 0)
1755 d_drop(dentry);
1756
1757 return status;
1758}
1759
1760static const struct dentry_operations tid_map_files_dentry_operations = {
1761 .d_revalidate = map_files_d_revalidate,
1762 .d_delete = pid_delete_dentry,
1763};
1764
1765static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
1766{
1767 unsigned long vm_start, vm_end;
1768 struct vm_area_struct *vma;
1769 struct task_struct *task;
1770 struct mm_struct *mm;
1771 int rc;
1772
1773 rc = -ENOENT;
1774 task = get_proc_task(dentry->d_inode);
1775 if (!task)
1776 goto out;
1777
1778 mm = get_task_mm(task);
1779 put_task_struct(task);
1780 if (!mm)
1781 goto out;
1782
1783 rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);
1784 if (rc)
1785 goto out_mmput;
1786
1787 down_read(&mm->mmap_sem);
1788 vma = find_exact_vma(mm, vm_start, vm_end);
1789 if (vma && vma->vm_file) {
1790 *path = vma->vm_file->f_path;
1791 path_get(path);
1792 rc = 0;
1793 }
1794 up_read(&mm->mmap_sem);
1795
1796out_mmput:
1797 mmput(mm);
1798out:
1799 return rc;
1800}
1801
1802struct map_files_info {
Al Viro7b540d02012-08-27 14:55:26 -04001803 fmode_t mode;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001804 unsigned long len;
1805 unsigned char name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
1806};
1807
1808static struct dentry *
1809proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
1810 struct task_struct *task, const void *ptr)
1811{
Al Viro7b540d02012-08-27 14:55:26 -04001812 fmode_t mode = (fmode_t)(unsigned long)ptr;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001813 struct proc_inode *ei;
1814 struct inode *inode;
1815
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001816 inode = proc_pid_make_inode(dir->i_sb, task);
1817 if (!inode)
1818 return ERR_PTR(-ENOENT);
1819
1820 ei = PROC_I(inode);
1821 ei->op.proc_get_link = proc_map_files_get_link;
1822
1823 inode->i_op = &proc_pid_link_inode_operations;
1824 inode->i_size = 64;
1825 inode->i_mode = S_IFLNK;
1826
Al Viro7b540d02012-08-27 14:55:26 -04001827 if (mode & FMODE_READ)
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001828 inode->i_mode |= S_IRUSR;
Al Viro7b540d02012-08-27 14:55:26 -04001829 if (mode & FMODE_WRITE)
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001830 inode->i_mode |= S_IWUSR;
1831
1832 d_set_d_op(dentry, &tid_map_files_dentry_operations);
1833 d_add(dentry, inode);
1834
1835 return NULL;
1836}
1837
1838static struct dentry *proc_map_files_lookup(struct inode *dir,
Al Viro00cd8dd2012-06-10 17:13:09 -04001839 struct dentry *dentry, unsigned int flags)
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001840{
1841 unsigned long vm_start, vm_end;
1842 struct vm_area_struct *vma;
1843 struct task_struct *task;
1844 struct dentry *result;
1845 struct mm_struct *mm;
1846
1847 result = ERR_PTR(-EACCES);
1848 if (!capable(CAP_SYS_ADMIN))
1849 goto out;
1850
1851 result = ERR_PTR(-ENOENT);
1852 task = get_proc_task(dir);
1853 if (!task)
1854 goto out;
1855
1856 result = ERR_PTR(-EACCES);
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001857 if (!ptrace_may_access(task, PTRACE_MODE_READ))
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001858 goto out_put_task;
1859
1860 result = ERR_PTR(-ENOENT);
1861 if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001862 goto out_put_task;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001863
1864 mm = get_task_mm(task);
1865 if (!mm)
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001866 goto out_put_task;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001867
1868 down_read(&mm->mmap_sem);
1869 vma = find_exact_vma(mm, vm_start, vm_end);
1870 if (!vma)
1871 goto out_no_vma;
1872
Stanislav Kinsbursky05f56482012-11-26 16:29:42 -08001873 if (vma->vm_file)
1874 result = proc_map_files_instantiate(dir, dentry, task,
1875 (void *)(unsigned long)vma->vm_file->f_mode);
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001876
1877out_no_vma:
1878 up_read(&mm->mmap_sem);
1879 mmput(mm);
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001880out_put_task:
1881 put_task_struct(task);
1882out:
1883 return result;
1884}
1885
1886static const struct inode_operations proc_map_files_inode_operations = {
1887 .lookup = proc_map_files_lookup,
1888 .permission = proc_fd_permission,
1889 .setattr = proc_setattr,
1890};
1891
1892static int
1893proc_map_files_readdir(struct file *filp, void *dirent, filldir_t filldir)
1894{
1895 struct dentry *dentry = filp->f_path.dentry;
1896 struct inode *inode = dentry->d_inode;
1897 struct vm_area_struct *vma;
1898 struct task_struct *task;
1899 struct mm_struct *mm;
1900 ino_t ino;
1901 int ret;
1902
1903 ret = -EACCES;
1904 if (!capable(CAP_SYS_ADMIN))
1905 goto out;
1906
1907 ret = -ENOENT;
1908 task = get_proc_task(inode);
1909 if (!task)
1910 goto out;
1911
1912 ret = -EACCES;
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001913 if (!ptrace_may_access(task, PTRACE_MODE_READ))
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001914 goto out_put_task;
1915
1916 ret = 0;
1917 switch (filp->f_pos) {
1918 case 0:
1919 ino = inode->i_ino;
1920 if (filldir(dirent, ".", 1, 0, ino, DT_DIR) < 0)
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001921 goto out_put_task;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001922 filp->f_pos++;
1923 case 1:
1924 ino = parent_ino(dentry);
1925 if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001926 goto out_put_task;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001927 filp->f_pos++;
1928 default:
1929 {
1930 unsigned long nr_files, pos, i;
1931 struct flex_array *fa = NULL;
1932 struct map_files_info info;
1933 struct map_files_info *p;
1934
1935 mm = get_task_mm(task);
1936 if (!mm)
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001937 goto out_put_task;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001938 down_read(&mm->mmap_sem);
1939
1940 nr_files = 0;
1941
1942 /*
1943 * We need two passes here:
1944 *
1945 * 1) Collect vmas of mapped files with mmap_sem taken
1946 * 2) Release mmap_sem and instantiate entries
1947 *
1948 * otherwise we get lockdep complained, since filldir()
1949 * routine might require mmap_sem taken in might_fault().
1950 */
1951
1952 for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
1953 if (vma->vm_file && ++pos > filp->f_pos)
1954 nr_files++;
1955 }
1956
1957 if (nr_files) {
1958 fa = flex_array_alloc(sizeof(info), nr_files,
1959 GFP_KERNEL);
1960 if (!fa || flex_array_prealloc(fa, 0, nr_files,
1961 GFP_KERNEL)) {
1962 ret = -ENOMEM;
1963 if (fa)
1964 flex_array_free(fa);
1965 up_read(&mm->mmap_sem);
1966 mmput(mm);
Cyrill Gorcunoveb94cd92012-05-17 17:03:25 -07001967 goto out_put_task;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001968 }
1969 for (i = 0, vma = mm->mmap, pos = 2; vma;
1970 vma = vma->vm_next) {
1971 if (!vma->vm_file)
1972 continue;
1973 if (++pos <= filp->f_pos)
1974 continue;
1975
Al Viro7b540d02012-08-27 14:55:26 -04001976 info.mode = vma->vm_file->f_mode;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001977 info.len = snprintf(info.name,
1978 sizeof(info.name), "%lx-%lx",
1979 vma->vm_start, vma->vm_end);
1980 if (flex_array_put(fa, i++, &info, GFP_KERNEL))
1981 BUG();
1982 }
1983 }
1984 up_read(&mm->mmap_sem);
1985
1986 for (i = 0; i < nr_files; i++) {
1987 p = flex_array_get(fa, i);
1988 ret = proc_fill_cache(filp, dirent, filldir,
1989 p->name, p->len,
1990 proc_map_files_instantiate,
Al Viro7b540d02012-08-27 14:55:26 -04001991 task,
1992 (void *)(unsigned long)p->mode);
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001993 if (ret)
1994 break;
1995 filp->f_pos++;
Pavel Emelyanov640708a2012-01-10 15:11:23 -08001996 }
1997 if (fa)
1998 flex_array_free(fa);
1999 mmput(mm);
2000 }
2001 }
2002
Pavel Emelyanov640708a2012-01-10 15:11:23 -08002003out_put_task:
2004 put_task_struct(task);
2005out:
2006 return ret;
2007}
2008
2009static const struct file_operations proc_map_files_operations = {
2010 .read = generic_read_dir,
2011 .readdir = proc_map_files_readdir,
2012 .llseek = default_llseek,
2013};
2014
2015#endif /* CONFIG_CHECKPOINT_RESTORE */
2016
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002017static struct dentry *proc_pident_instantiate(struct inode *dir,
Eric Dumazetc5141e62007-05-08 00:26:15 -07002018 struct dentry *dentry, struct task_struct *task, const void *ptr)
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002019{
Eric Dumazetc5141e62007-05-08 00:26:15 -07002020 const struct pid_entry *p = ptr;
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002021 struct inode *inode;
2022 struct proc_inode *ei;
KOSAKI Motohirobd6daba2009-05-28 14:34:21 -07002023 struct dentry *error = ERR_PTR(-ENOENT);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002024
Eric W. Biederman61a28782006-10-02 02:18:49 -07002025 inode = proc_pid_make_inode(dir->i_sb, task);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002026 if (!inode)
2027 goto out;
2028
2029 ei = PROC_I(inode);
2030 inode->i_mode = p->mode;
2031 if (S_ISDIR(inode->i_mode))
Miklos Szeredibfe86842011-10-28 14:13:29 +02002032 set_nlink(inode, 2); /* Use getattr to fix if necessary */
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002033 if (p->iop)
2034 inode->i_op = p->iop;
2035 if (p->fop)
2036 inode->i_fop = p->fop;
2037 ei->op = p->op;
Nick Pigginfb045ad2011-01-07 17:49:55 +11002038 d_set_d_op(dentry, &pid_dentry_operations);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002039 d_add(dentry, inode);
2040 /* Close the race of the process dying before we return the dentry */
Al Viro0b728e12012-06-10 16:03:43 -04002041 if (pid_revalidate(dentry, 0))
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002042 error = NULL;
2043out:
2044 return error;
2045}
2046
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047static struct dentry *proc_pident_lookup(struct inode *dir,
2048 struct dentry *dentry,
Eric Dumazetc5141e62007-05-08 00:26:15 -07002049 const struct pid_entry *ents,
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002050 unsigned int nents)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051{
Eric W. Biedermancd6a3ce2006-06-26 00:25:49 -07002052 struct dentry *error;
Eric W. Biederman99f89552006-06-26 00:25:55 -07002053 struct task_struct *task = get_proc_task(dir);
Eric Dumazetc5141e62007-05-08 00:26:15 -07002054 const struct pid_entry *p, *last;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055
Eric W. Biedermancd6a3ce2006-06-26 00:25:49 -07002056 error = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057
Eric W. Biederman99f89552006-06-26 00:25:55 -07002058 if (!task)
2059 goto out_no_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
Eric W. Biederman20cdc892006-10-02 02:17:07 -07002061 /*
2062 * Yes, it does not scale. And it should not. Don't add
2063 * new entries into /proc/<tgid>/ without very good reasons.
2064 */
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002065 last = &ents[nents - 1];
2066 for (p = ents; p <= last; p++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 if (p->len != dentry->d_name.len)
2068 continue;
2069 if (!memcmp(dentry->d_name.name, p->name, p->len))
2070 break;
2071 }
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002072 if (p > last)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 goto out;
2074
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002075 error = proc_pident_instantiate(dir, dentry, task, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076out:
Eric W. Biederman99f89552006-06-26 00:25:55 -07002077 put_task_struct(task);
2078out_no_task:
Eric W. Biedermancd6a3ce2006-06-26 00:25:49 -07002079 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080}
2081
Eric Dumazetc5141e62007-05-08 00:26:15 -07002082static int proc_pident_fill_cache(struct file *filp, void *dirent,
2083 filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
Eric W. Biederman61a28782006-10-02 02:18:49 -07002084{
2085 return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
2086 proc_pident_instantiate, task, p);
2087}
2088
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002089static int proc_pident_readdir(struct file *filp,
2090 void *dirent, filldir_t filldir,
Eric Dumazetc5141e62007-05-08 00:26:15 -07002091 const struct pid_entry *ents, unsigned int nents)
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002092{
2093 int i;
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08002094 struct dentry *dentry = filp->f_path.dentry;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002095 struct inode *inode = dentry->d_inode;
2096 struct task_struct *task = get_proc_task(inode);
Eric Dumazetc5141e62007-05-08 00:26:15 -07002097 const struct pid_entry *p, *last;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002098 ino_t ino;
2099 int ret;
2100
2101 ret = -ENOENT;
2102 if (!task)
Eric W. Biederman61a28782006-10-02 02:18:49 -07002103 goto out_no_task;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002104
2105 ret = 0;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002106 i = filp->f_pos;
2107 switch (i) {
2108 case 0:
2109 ino = inode->i_ino;
2110 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
2111 goto out;
2112 i++;
2113 filp->f_pos++;
2114 /* fall through */
2115 case 1:
2116 ino = parent_ino(dentry);
2117 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
2118 goto out;
2119 i++;
2120 filp->f_pos++;
2121 /* fall through */
2122 default:
2123 i -= 2;
2124 if (i >= nents) {
2125 ret = 1;
2126 goto out;
2127 }
2128 p = ents + i;
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002129 last = &ents[nents - 1];
2130 while (p <= last) {
Eric W. Biederman61a28782006-10-02 02:18:49 -07002131 if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002132 goto out;
2133 filp->f_pos++;
2134 p++;
2135 }
2136 }
2137
2138 ret = 1;
2139out:
Eric W. Biederman61a28782006-10-02 02:18:49 -07002140 put_task_struct(task);
2141out_no_task:
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002142 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143}
2144
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145#ifdef CONFIG_SECURITY
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002146static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
2147 size_t count, loff_t *ppos)
2148{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08002149 struct inode * inode = file->f_path.dentry->d_inode;
Al Viro04ff9702007-03-12 16:17:58 +00002150 char *p = NULL;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002151 ssize_t length;
2152 struct task_struct *task = get_proc_task(inode);
2153
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002154 if (!task)
Al Viro04ff9702007-03-12 16:17:58 +00002155 return -ESRCH;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002156
2157 length = security_getprocattr(task,
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08002158 (char*)file->f_path.dentry->d_name.name,
Al Viro04ff9702007-03-12 16:17:58 +00002159 &p);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002160 put_task_struct(task);
Al Viro04ff9702007-03-12 16:17:58 +00002161 if (length > 0)
2162 length = simple_read_from_buffer(buf, count, ppos, p, length);
2163 kfree(p);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002164 return length;
2165}
2166
2167static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
2168 size_t count, loff_t *ppos)
2169{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08002170 struct inode * inode = file->f_path.dentry->d_inode;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002171 char *page;
2172 ssize_t length;
2173 struct task_struct *task = get_proc_task(inode);
2174
2175 length = -ESRCH;
2176 if (!task)
2177 goto out_no_task;
2178 if (count > PAGE_SIZE)
2179 count = PAGE_SIZE;
2180
2181 /* No partial writes. */
2182 length = -EINVAL;
2183 if (*ppos != 0)
2184 goto out;
2185
2186 length = -ENOMEM;
Mel Gormane12ba742007-10-16 01:25:52 -07002187 page = (char*)__get_free_page(GFP_TEMPORARY);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002188 if (!page)
2189 goto out;
2190
2191 length = -EFAULT;
2192 if (copy_from_user(page, buf, count))
2193 goto out_free;
2194
David Howells107db7c2009-05-08 13:55:27 +01002195 /* Guard against adverse ptrace interaction */
KOSAKI Motohiro9b1bf122010-10-27 15:34:08 -07002196 length = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
David Howells107db7c2009-05-08 13:55:27 +01002197 if (length < 0)
2198 goto out_free;
2199
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002200 length = security_setprocattr(task,
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08002201 (char*)file->f_path.dentry->d_name.name,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002202 (void*)page, count);
KOSAKI Motohiro9b1bf122010-10-27 15:34:08 -07002203 mutex_unlock(&task->signal->cred_guard_mutex);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002204out_free:
2205 free_page((unsigned long) page);
2206out:
2207 put_task_struct(task);
2208out_no_task:
2209 return length;
2210}
2211
Arjan van de Ven00977a52007-02-12 00:55:34 -08002212static const struct file_operations proc_pid_attr_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002213 .read = proc_pid_attr_read,
2214 .write = proc_pid_attr_write,
Arnd Bergmann87df8422010-03-17 23:06:02 +01002215 .llseek = generic_file_llseek,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002216};
2217
Eric Dumazetc5141e62007-05-08 00:26:15 -07002218static const struct pid_entry attr_dir_stuff[] = {
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002219 REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2220 REG("prev", S_IRUGO, proc_pid_attr_operations),
2221 REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2222 REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2223 REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2224 REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002225};
2226
Eric W. Biederman72d9dcf2006-10-02 02:18:50 -07002227static int proc_attr_dir_readdir(struct file * filp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 void * dirent, filldir_t filldir)
2229{
2230 return proc_pident_readdir(filp,dirent,filldir,
Eric W. Biederman72d9dcf2006-10-02 02:18:50 -07002231 attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232}
2233
Arjan van de Ven00977a52007-02-12 00:55:34 -08002234static const struct file_operations proc_attr_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 .read = generic_read_dir,
Eric W. Biederman72d9dcf2006-10-02 02:18:50 -07002236 .readdir = proc_attr_dir_readdir,
Arnd Bergmann6038f372010-08-15 18:52:59 +02002237 .llseek = default_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238};
2239
Eric W. Biederman72d9dcf2006-10-02 02:18:50 -07002240static struct dentry *proc_attr_dir_lookup(struct inode *dir,
Al Viro00cd8dd2012-06-10 17:13:09 -04002241 struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242{
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002243 return proc_pident_lookup(dir, dentry,
2244 attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245}
2246
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08002247static const struct inode_operations proc_attr_dir_inode_operations = {
Eric W. Biederman72d9dcf2006-10-02 02:18:50 -07002248 .lookup = proc_attr_dir_lookup,
Eric W. Biederman99f89552006-06-26 00:25:55 -07002249 .getattr = pid_getattr,
Linus Torvalds6d76fa52006-07-15 12:26:45 -07002250 .setattr = proc_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251};
2252
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253#endif
2254
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002255#ifdef CONFIG_ELF_CORE
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -07002256static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
2257 size_t count, loff_t *ppos)
2258{
2259 struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
2260 struct mm_struct *mm;
2261 char buffer[PROC_NUMBUF];
2262 size_t len;
2263 int ret;
2264
2265 if (!task)
2266 return -ESRCH;
2267
2268 ret = 0;
2269 mm = get_task_mm(task);
2270 if (mm) {
2271 len = snprintf(buffer, sizeof(buffer), "%08lx\n",
2272 ((mm->flags & MMF_DUMP_FILTER_MASK) >>
2273 MMF_DUMP_FILTER_SHIFT));
2274 mmput(mm);
2275 ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
2276 }
2277
2278 put_task_struct(task);
2279
2280 return ret;
2281}
2282
2283static ssize_t proc_coredump_filter_write(struct file *file,
2284 const char __user *buf,
2285 size_t count,
2286 loff_t *ppos)
2287{
2288 struct task_struct *task;
2289 struct mm_struct *mm;
2290 char buffer[PROC_NUMBUF], *end;
2291 unsigned int val;
2292 int ret;
2293 int i;
2294 unsigned long mask;
2295
2296 ret = -EFAULT;
2297 memset(buffer, 0, sizeof(buffer));
2298 if (count > sizeof(buffer) - 1)
2299 count = sizeof(buffer) - 1;
2300 if (copy_from_user(buffer, buf, count))
2301 goto out_no_task;
2302
2303 ret = -EINVAL;
2304 val = (unsigned int)simple_strtoul(buffer, &end, 0);
2305 if (*end == '\n')
2306 end++;
2307 if (end - buffer == 0)
2308 goto out_no_task;
2309
2310 ret = -ESRCH;
2311 task = get_proc_task(file->f_dentry->d_inode);
2312 if (!task)
2313 goto out_no_task;
2314
2315 ret = end - buffer;
2316 mm = get_task_mm(task);
2317 if (!mm)
2318 goto out_no_mm;
2319
2320 for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
2321 if (val & mask)
2322 set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2323 else
2324 clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2325 }
2326
2327 mmput(mm);
2328 out_no_mm:
2329 put_task_struct(task);
2330 out_no_task:
2331 return ret;
2332}
2333
2334static const struct file_operations proc_coredump_filter_operations = {
2335 .read = proc_coredump_filter_read,
2336 .write = proc_coredump_filter_write,
Arnd Bergmann87df8422010-03-17 23:06:02 +01002337 .llseek = generic_file_llseek,
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -07002338};
2339#endif
2340
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002341#ifdef CONFIG_TASK_IO_ACCOUNTING
Andrea Righi297c5d92008-07-25 01:48:49 -07002342static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002343{
Andrea Righi940389b2008-07-28 00:48:12 +02002344 struct task_io_accounting acct = task->ioac;
Andrea Righi59954772008-07-27 17:29:15 +02002345 unsigned long flags;
Vasiliy Kulikov293eb1e2011-07-26 16:08:38 -07002346 int result;
Andrea Righi297c5d92008-07-25 01:48:49 -07002347
Vasiliy Kulikov293eb1e2011-07-26 16:08:38 -07002348 result = mutex_lock_killable(&task->signal->cred_guard_mutex);
2349 if (result)
2350 return result;
2351
2352 if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
2353 result = -EACCES;
2354 goto out_unlock;
2355 }
Vasiliy Kulikov1d1221f2011-06-24 16:08:38 +04002356
Andrea Righi59954772008-07-27 17:29:15 +02002357 if (whole && lock_task_sighand(task, &flags)) {
2358 struct task_struct *t = task;
Andrea Righib2d002d2008-07-26 15:22:27 -07002359
Andrea Righi59954772008-07-27 17:29:15 +02002360 task_io_accounting_add(&acct, &task->signal->ioac);
2361 while_each_thread(task, t)
2362 task_io_accounting_add(&acct, &t->ioac);
Andrea Righi297c5d92008-07-25 01:48:49 -07002363
Andrea Righi59954772008-07-27 17:29:15 +02002364 unlock_task_sighand(task, &flags);
Andrea Righi297c5d92008-07-25 01:48:49 -07002365 }
Vasiliy Kulikov293eb1e2011-07-26 16:08:38 -07002366 result = sprintf(buffer,
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002367 "rchar: %llu\n"
2368 "wchar: %llu\n"
2369 "syscr: %llu\n"
2370 "syscw: %llu\n"
2371 "read_bytes: %llu\n"
2372 "write_bytes: %llu\n"
2373 "cancelled_write_bytes: %llu\n",
Alexander Beregalov7c443192008-08-05 13:01:34 -07002374 (unsigned long long)acct.rchar,
2375 (unsigned long long)acct.wchar,
2376 (unsigned long long)acct.syscr,
2377 (unsigned long long)acct.syscw,
2378 (unsigned long long)acct.read_bytes,
2379 (unsigned long long)acct.write_bytes,
2380 (unsigned long long)acct.cancelled_write_bytes);
Vasiliy Kulikov293eb1e2011-07-26 16:08:38 -07002381out_unlock:
2382 mutex_unlock(&task->signal->cred_guard_mutex);
2383 return result;
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002384}
Andrea Righi297c5d92008-07-25 01:48:49 -07002385
2386static int proc_tid_io_accounting(struct task_struct *task, char *buffer)
2387{
2388 return do_io_accounting(task, buffer, 0);
2389}
2390
2391static int proc_tgid_io_accounting(struct task_struct *task, char *buffer)
2392{
2393 return do_io_accounting(task, buffer, 1);
2394}
2395#endif /* CONFIG_TASK_IO_ACCOUNTING */
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002396
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002397#ifdef CONFIG_USER_NS
2398static int proc_id_map_open(struct inode *inode, struct file *file,
2399 struct seq_operations *seq_ops)
2400{
2401 struct user_namespace *ns = NULL;
2402 struct task_struct *task;
2403 struct seq_file *seq;
2404 int ret = -EINVAL;
2405
2406 task = get_proc_task(inode);
2407 if (task) {
2408 rcu_read_lock();
2409 ns = get_user_ns(task_cred_xxx(task, user_ns));
2410 rcu_read_unlock();
2411 put_task_struct(task);
2412 }
2413 if (!ns)
2414 goto err;
2415
2416 ret = seq_open(file, seq_ops);
2417 if (ret)
2418 goto err_put_ns;
2419
2420 seq = file->private_data;
2421 seq->private = ns;
2422
2423 return 0;
2424err_put_ns:
2425 put_user_ns(ns);
2426err:
2427 return ret;
2428}
2429
2430static int proc_id_map_release(struct inode *inode, struct file *file)
2431{
2432 struct seq_file *seq = file->private_data;
2433 struct user_namespace *ns = seq->private;
2434 put_user_ns(ns);
2435 return seq_release(inode, file);
2436}
2437
2438static int proc_uid_map_open(struct inode *inode, struct file *file)
2439{
2440 return proc_id_map_open(inode, file, &proc_uid_seq_operations);
2441}
2442
2443static int proc_gid_map_open(struct inode *inode, struct file *file)
2444{
2445 return proc_id_map_open(inode, file, &proc_gid_seq_operations);
2446}
2447
Eric W. Biedermanf76d2072012-08-30 01:24:05 -07002448static int proc_projid_map_open(struct inode *inode, struct file *file)
2449{
2450 return proc_id_map_open(inode, file, &proc_projid_seq_operations);
2451}
2452
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002453static const struct file_operations proc_uid_map_operations = {
2454 .open = proc_uid_map_open,
2455 .write = proc_uid_map_write,
2456 .read = seq_read,
2457 .llseek = seq_lseek,
2458 .release = proc_id_map_release,
2459};
2460
2461static const struct file_operations proc_gid_map_operations = {
2462 .open = proc_gid_map_open,
2463 .write = proc_gid_map_write,
2464 .read = seq_read,
2465 .llseek = seq_lseek,
2466 .release = proc_id_map_release,
2467};
Eric W. Biedermanf76d2072012-08-30 01:24:05 -07002468
2469static const struct file_operations proc_projid_map_operations = {
2470 .open = proc_projid_map_open,
2471 .write = proc_projid_map_write,
2472 .read = seq_read,
2473 .llseek = seq_lseek,
2474 .release = proc_id_map_release,
2475};
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002476#endif /* CONFIG_USER_NS */
2477
Kees Cook47830722008-10-06 03:11:58 +04002478static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
2479 struct pid *pid, struct task_struct *task)
2480{
Al Viroa9712bc2011-03-23 15:52:50 -04002481 int err = lock_trace(task);
2482 if (!err) {
2483 seq_printf(m, "%08x\n", task->personality);
2484 unlock_trace(task);
2485 }
2486 return err;
Kees Cook47830722008-10-06 03:11:58 +04002487}
2488
Eric W. Biederman801199c2006-10-02 02:18:48 -07002489/*
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002490 * Thread groups
2491 */
Arjan van de Ven00977a52007-02-12 00:55:34 -08002492static const struct file_operations proc_task_operations;
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08002493static const struct inode_operations proc_task_inode_operations;
Eric W. Biederman20cdc892006-10-02 02:17:07 -07002494
Eric Dumazetc5141e62007-05-08 00:26:15 -07002495static const struct pid_entry tgid_base_stuff[] = {
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002496 DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),
2497 DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
Pavel Emelyanov640708a2012-01-10 15:11:23 -08002498#ifdef CONFIG_CHECKPOINT_RESTORE
2499 DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
2500#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002501 DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
Eric W. Biederman6b4e3062010-03-07 16:41:34 -08002502 DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
Andrew Mortonb2211a32008-03-11 18:03:35 -07002503#ifdef CONFIG_NET
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002504 DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
Andrew Mortonb2211a32008-03-11 18:03:35 -07002505#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002506 REG("environ", S_IRUSR, proc_environ_operations),
2507 INF("auxv", S_IRUSR, proc_pid_auxv),
2508 ONE("status", S_IRUGO, proc_pid_status),
Al Viroa9712bc2011-03-23 15:52:50 -04002509 ONE("personality", S_IRUGO, proc_pid_personality),
Jiri Olsa3036e7b2010-09-30 15:15:33 -07002510 INF("limits", S_IRUGO, proc_pid_limits),
Ingo Molnar43ae34c2007-07-09 18:52:00 +02002511#ifdef CONFIG_SCHED_DEBUG
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002512 REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations),
Ingo Molnar43ae34c2007-07-09 18:52:00 +02002513#endif
Mike Galbraith5091faa2010-11-30 14:18:03 +01002514#ifdef CONFIG_SCHED_AUTOGROUP
2515 REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
2516#endif
john stultz4614a696b2009-12-14 18:00:05 -08002517 REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
Roland McGrathebcb6732008-07-25 19:46:00 -07002518#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
Al Viroa9712bc2011-03-23 15:52:50 -04002519 INF("syscall", S_IRUGO, proc_pid_syscall),
Roland McGrathebcb6732008-07-25 19:46:00 -07002520#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002521 INF("cmdline", S_IRUGO, proc_pid_cmdline),
2522 ONE("stat", S_IRUGO, proc_tgid_stat),
2523 ONE("statm", S_IRUGO, proc_pid_statm),
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -07002524 REG("maps", S_IRUGO, proc_pid_maps_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002525#ifdef CONFIG_NUMA
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -07002526 REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002527#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002528 REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),
2529 LNK("cwd", proc_cwd_link),
2530 LNK("root", proc_root_link),
2531 LNK("exe", proc_exe_link),
2532 REG("mounts", S_IRUGO, proc_mounts_operations),
2533 REG("mountinfo", S_IRUGO, proc_mountinfo_operations),
2534 REG("mountstats", S_IRUSR, proc_mountstats_operations),
Matt Mackall1e883282008-02-04 22:29:07 -08002535#ifdef CONFIG_PROC_PAGE_MONITOR
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002536 REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -07002537 REG("smaps", S_IRUGO, proc_pid_smaps_operations),
Al Viroca6b0bf2011-02-15 22:04:37 -05002538 REG("pagemap", S_IRUGO, proc_pagemap_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002539#endif
2540#ifdef CONFIG_SECURITY
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002541 DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002542#endif
2543#ifdef CONFIG_KALLSYMS
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002544 INF("wchan", S_IRUGO, proc_pid_wchan),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002545#endif
Ken Chen2ec220e2008-11-10 11:26:08 +03002546#ifdef CONFIG_STACKTRACE
Al Viroa9712bc2011-03-23 15:52:50 -04002547 ONE("stack", S_IRUGO, proc_pid_stack),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002548#endif
2549#ifdef CONFIG_SCHEDSTATS
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002550 INF("schedstat", S_IRUGO, proc_pid_schedstat),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002551#endif
Arjan van de Ven97455122008-01-25 21:08:34 +01002552#ifdef CONFIG_LATENCYTOP
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002553 REG("latency", S_IRUGO, proc_lstats_operations),
Arjan van de Ven97455122008-01-25 21:08:34 +01002554#endif
Paul Menage8793d852007-10-18 23:39:39 -07002555#ifdef CONFIG_PROC_PID_CPUSET
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002556 REG("cpuset", S_IRUGO, proc_cpuset_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002557#endif
Paul Menagea4243162007-10-18 23:39:35 -07002558#ifdef CONFIG_CGROUPS
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002559 REG("cgroup", S_IRUGO, proc_cgroup_operations),
Paul Menagea4243162007-10-18 23:39:35 -07002560#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002561 INF("oom_score", S_IRUGO, proc_oom_score),
David Rientjesfa0cbbf2012-11-12 17:53:04 -08002562 REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations),
David Rientjesa63d83f2010-08-09 17:19:46 -07002563 REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002564#ifdef CONFIG_AUDITSYSCALL
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002565 REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations),
2566 REG("sessionid", S_IRUGO, proc_sessionid_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002567#endif
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08002568#ifdef CONFIG_FAULT_INJECTION
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002569 REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08002570#endif
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002571#ifdef CONFIG_ELF_CORE
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002572 REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -07002573#endif
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002574#ifdef CONFIG_TASK_IO_ACCOUNTING
Vasiliy Kulikov1d1221f2011-06-24 16:08:38 +04002575 INF("io", S_IRUSR, proc_tgid_io_accounting),
Andrew Mortonaba76fd2006-12-10 02:19:48 -08002576#endif
Chris Metcalff133ecc2011-05-26 12:40:09 -04002577#ifdef CONFIG_HARDWALL
2578 INF("hardwall", S_IRUGO, proc_pid_hardwall),
2579#endif
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002580#ifdef CONFIG_USER_NS
2581 REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations),
2582 REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations),
Eric W. Biedermanf76d2072012-08-30 01:24:05 -07002583 REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002584#endif
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002585};
2586
2587static int proc_tgid_base_readdir(struct file * filp,
2588 void * dirent, filldir_t filldir)
2589{
2590 return proc_pident_readdir(filp,dirent,filldir,
2591 tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
2592}
2593
Arjan van de Ven00977a52007-02-12 00:55:34 -08002594static const struct file_operations proc_tgid_base_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002595 .read = generic_read_dir,
2596 .readdir = proc_tgid_base_readdir,
Arnd Bergmann6038f372010-08-15 18:52:59 +02002597 .llseek = default_llseek,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002598};
2599
Al Viro00cd8dd2012-06-10 17:13:09 -04002600static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
2601{
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002602 return proc_pident_lookup(dir, dentry,
2603 tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002604}
2605
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08002606static const struct inode_operations proc_tgid_base_inode_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002607 .lookup = proc_tgid_base_lookup,
2608 .getattr = pid_getattr,
2609 .setattr = proc_setattr,
Vasiliy Kulikov04996802012-01-10 15:11:31 -08002610 .permission = proc_pid_permission,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002611};
2612
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002613static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614{
Eric W. Biederman48e64842006-06-26 00:25:48 -07002615 struct dentry *dentry, *leader, *dir;
Eric W. Biederman8578cea2006-06-26 00:25:54 -07002616 char buf[PROC_NUMBUF];
Eric W. Biederman48e64842006-06-26 00:25:48 -07002617 struct qstr name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618
Eric W. Biederman48e64842006-06-26 00:25:48 -07002619 name.name = buf;
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002620 name.len = snprintf(buf, sizeof(buf), "%d", pid);
2621 dentry = d_hash_and_lookup(mnt->mnt_root, &name);
Eric W. Biederman48e64842006-06-26 00:25:48 -07002622 if (dentry) {
Sukadev Bhattiprolu29f12ca2009-11-11 14:26:32 -08002623 shrink_dcache_parent(dentry);
Eric W. Biederman48e64842006-06-26 00:25:48 -07002624 d_drop(dentry);
2625 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627
Eric W. Biederman48e64842006-06-26 00:25:48 -07002628 name.name = buf;
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002629 name.len = snprintf(buf, sizeof(buf), "%d", tgid);
2630 leader = d_hash_and_lookup(mnt->mnt_root, &name);
Eric W. Biederman48e64842006-06-26 00:25:48 -07002631 if (!leader)
2632 goto out;
2633
2634 name.name = "task";
2635 name.len = strlen(name.name);
2636 dir = d_hash_and_lookup(leader, &name);
2637 if (!dir)
2638 goto out_put_leader;
2639
2640 name.name = buf;
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002641 name.len = snprintf(buf, sizeof(buf), "%d", pid);
Eric W. Biederman48e64842006-06-26 00:25:48 -07002642 dentry = d_hash_and_lookup(dir, &name);
2643 if (dentry) {
2644 shrink_dcache_parent(dentry);
2645 d_drop(dentry);
2646 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 }
Eric W. Biederman48e64842006-06-26 00:25:48 -07002648
2649 dput(dir);
2650out_put_leader:
2651 dput(leader);
2652out:
2653 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654}
2655
Randy Dunlap0895e912007-10-21 21:00:10 -07002656/**
2657 * proc_flush_task - Remove dcache entries for @task from the /proc dcache.
2658 * @task: task that should be flushed.
2659 *
2660 * When flushing dentries from proc, one needs to flush them from global
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002661 * proc (proc_mnt) and from all the namespaces' procs this task was seen
Randy Dunlap0895e912007-10-21 21:00:10 -07002662 * in. This call is supposed to do all of this job.
2663 *
2664 * Looks in the dcache for
2665 * /proc/@pid
2666 * /proc/@tgid/task/@pid
2667 * if either directory is present flushes it and all of it'ts children
2668 * from the dcache.
2669 *
2670 * It is safe and reasonable to cache /proc entries for a task until
2671 * that task exits. After that they just clog up the dcache with
2672 * useless entries, possibly causing useful dcache entries to be
2673 * flushed instead. This routine is proved to flush those useless
2674 * dcache entries at process exit time.
2675 *
2676 * NOTE: This routine is just an optimization so it does not guarantee
2677 * that no dcache entries will exist at process exit time it
2678 * just makes it very unlikely that any will persist.
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002679 */
2680
2681void proc_flush_task(struct task_struct *task)
2682{
Eric W. Biederman9fcc2d12007-11-14 17:00:07 -08002683 int i;
Oleg Nesterov9b4d1cbe2009-09-22 16:45:34 -07002684 struct pid *pid, *tgid;
Pavel Emelyanov130f77e2007-10-18 23:40:11 -07002685 struct upid *upid;
2686
Pavel Emelyanov130f77e2007-10-18 23:40:11 -07002687 pid = task_pid(task);
Oleg Nesterov9b4d1cbe2009-09-22 16:45:34 -07002688 tgid = task_tgid(task);
Pavel Emelyanov130f77e2007-10-18 23:40:11 -07002689
Eric W. Biederman9fcc2d12007-11-14 17:00:07 -08002690 for (i = 0; i <= pid->level; i++) {
Pavel Emelyanov130f77e2007-10-18 23:40:11 -07002691 upid = &pid->numbers[i];
2692 proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
Oleg Nesterov9b4d1cbe2009-09-22 16:45:34 -07002693 tgid->numbers[i].nr);
Pavel Emelyanov130f77e2007-10-18 23:40:11 -07002694 }
Pavel Emelyanov60347f62007-10-18 23:40:03 -07002695}
2696
Adrian Bunk9711ef92006-12-06 20:38:31 -08002697static struct dentry *proc_pid_instantiate(struct inode *dir,
2698 struct dentry * dentry,
Eric Dumazetc5141e62007-05-08 00:26:15 -07002699 struct task_struct *task, const void *ptr)
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002700{
2701 struct dentry *error = ERR_PTR(-ENOENT);
2702 struct inode *inode;
2703
Eric W. Biederman61a28782006-10-02 02:18:49 -07002704 inode = proc_pid_make_inode(dir->i_sb, task);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002705 if (!inode)
2706 goto out;
2707
2708 inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2709 inode->i_op = &proc_tgid_base_inode_operations;
2710 inode->i_fop = &proc_tgid_base_operations;
2711 inode->i_flags|=S_IMMUTABLE;
Vegard Nossumaed54172008-06-05 22:46:53 -07002712
Miklos Szeredibfe86842011-10-28 14:13:29 +02002713 set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff,
2714 ARRAY_SIZE(tgid_base_stuff)));
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002715
Nick Pigginfb045ad2011-01-07 17:49:55 +11002716 d_set_d_op(dentry, &pid_dentry_operations);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002717
2718 d_add(dentry, inode);
2719 /* Close the race of the process dying before we return the dentry */
Al Viro0b728e12012-06-10 16:03:43 -04002720 if (pid_revalidate(dentry, 0))
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002721 error = NULL;
2722out:
2723 return error;
2724}
2725
Al Viro00cd8dd2012-06-10 17:13:09 -04002726struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727{
Eric W. Biedermane656d8a2010-07-10 14:52:49 -07002728 struct dentry *result = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 unsigned tgid;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002731 struct pid_namespace *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 tgid = name_to_int(dentry);
2734 if (tgid == ~0U)
2735 goto out;
2736
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002737 ns = dentry->d_sb->s_fs_info;
Eric W. Biedermande758732006-06-26 00:25:51 -07002738 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002739 task = find_task_by_pid_ns(tgid, ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740 if (task)
2741 get_task_struct(task);
Eric W. Biedermande758732006-06-26 00:25:51 -07002742 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 if (!task)
2744 goto out;
2745
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002746 result = proc_pid_instantiate(dir, dentry, task, NULL);
Eric W. Biederman48e64842006-06-26 00:25:48 -07002747 put_task_struct(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748out:
Eric W. Biedermancd6a3ce2006-06-26 00:25:49 -07002749 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750}
2751
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752/*
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002753 * Find the first task with tgid >= tgid
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07002754 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 */
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002756struct tgid_iter {
2757 unsigned int tgid;
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002758 struct task_struct *task;
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002759};
2760static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)
2761{
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002762 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002764 if (iter.task)
2765 put_task_struct(iter.task);
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002766 rcu_read_lock();
2767retry:
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002768 iter.task = NULL;
2769 pid = find_ge_pid(iter.tgid, ns);
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002770 if (pid) {
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002771 iter.tgid = pid_nr_ns(pid, ns);
2772 iter.task = pid_task(pid, PIDTYPE_PID);
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002773 /* What we to know is if the pid we have find is the
2774 * pid of a thread_group_leader. Testing for task
2775 * being a thread_group_leader is the obvious thing
2776 * todo but there is a window when it fails, due to
2777 * the pid transfer logic in de_thread.
2778 *
2779 * So we perform the straight forward test of seeing
2780 * if the pid we have found is the pid of a thread
2781 * group leader, and don't worry if the task we have
2782 * found doesn't happen to be a thread group leader.
2783 * As we don't care in the case of readdir.
2784 */
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002785 if (!iter.task || !has_group_leader_pid(iter.task)) {
2786 iter.tgid += 1;
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002787 goto retry;
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002788 }
2789 get_task_struct(iter.task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 }
Eric W. Biederman454cc102006-06-26 00:25:51 -07002791 rcu_read_unlock();
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002792 return iter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793}
2794
Eric W. Biedermane656d8a2010-07-10 14:52:49 -07002795#define TGID_OFFSET (FIRST_PROCESS_ENTRY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796
Eric W. Biederman61a28782006-10-02 02:18:49 -07002797static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002798 struct tgid_iter iter)
Eric W. Biederman61a28782006-10-02 02:18:49 -07002799{
2800 char name[PROC_NUMBUF];
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002801 int len = snprintf(name, sizeof(name), "%d", iter.tgid);
Eric W. Biederman61a28782006-10-02 02:18:49 -07002802 return proc_fill_cache(filp, dirent, filldir, name, len,
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002803 proc_pid_instantiate, iter.task, NULL);
Eric W. Biederman61a28782006-10-02 02:18:49 -07002804}
2805
Vasiliy Kulikov04996802012-01-10 15:11:31 -08002806static int fake_filldir(void *buf, const char *name, int namelen,
2807 loff_t offset, u64 ino, unsigned d_type)
2808{
2809 return 0;
2810}
2811
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812/* for the /proc/ directory itself, after non-process stuff has been done */
2813int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
2814{
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002815 struct tgid_iter iter;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002816 struct pid_namespace *ns;
Vasiliy Kulikov04996802012-01-10 15:11:31 -08002817 filldir_t __filldir;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818
Linus Torvaldsd8bdc592011-04-18 10:36:54 -07002819 if (filp->f_pos >= PID_MAX_LIMIT + TGID_OFFSET)
Eric W. Biedermanae06c7c2010-07-10 15:23:34 -07002820 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002822 ns = filp->f_dentry->d_sb->s_fs_info;
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002823 iter.task = NULL;
2824 iter.tgid = filp->f_pos - TGID_OFFSET;
2825 for (iter = next_tgid(ns, iter);
2826 iter.task;
2827 iter.tgid += 1, iter = next_tgid(ns, iter)) {
Vasiliy Kulikov04996802012-01-10 15:11:31 -08002828 if (has_pid_permissions(ns, iter.task, 2))
2829 __filldir = filldir;
2830 else
2831 __filldir = fake_filldir;
2832
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002833 filp->f_pos = iter.tgid + TGID_OFFSET;
Vasiliy Kulikov04996802012-01-10 15:11:31 -08002834 if (proc_pid_fill_cache(filp, dirent, __filldir, iter) < 0) {
Eric W. Biederman19fd4bb2007-11-28 16:21:26 -08002835 put_task_struct(iter.task);
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002836 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 }
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002839 filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET;
2840out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 return 0;
2842}
2843
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07002844/*
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002845 * Tasks
2846 */
Eric Dumazetc5141e62007-05-08 00:26:15 -07002847static const struct pid_entry tid_base_stuff[] = {
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002848 DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
Jerome Marchand38355412010-04-27 13:13:06 -07002849 DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
Eric W. Biederman6b4e3062010-03-07 16:41:34 -08002850 DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002851 REG("environ", S_IRUSR, proc_environ_operations),
2852 INF("auxv", S_IRUSR, proc_pid_auxv),
2853 ONE("status", S_IRUGO, proc_pid_status),
Al Viroa9712bc2011-03-23 15:52:50 -04002854 ONE("personality", S_IRUGO, proc_pid_personality),
Jiri Olsa3036e7b2010-09-30 15:15:33 -07002855 INF("limits", S_IRUGO, proc_pid_limits),
Ingo Molnar43ae34c2007-07-09 18:52:00 +02002856#ifdef CONFIG_SCHED_DEBUG
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002857 REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations),
Ingo Molnar43ae34c2007-07-09 18:52:00 +02002858#endif
john stultz4614a696b2009-12-14 18:00:05 -08002859 REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
Roland McGrathebcb6732008-07-25 19:46:00 -07002860#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
Al Viroa9712bc2011-03-23 15:52:50 -04002861 INF("syscall", S_IRUGO, proc_pid_syscall),
Roland McGrathebcb6732008-07-25 19:46:00 -07002862#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002863 INF("cmdline", S_IRUGO, proc_pid_cmdline),
2864 ONE("stat", S_IRUGO, proc_tid_stat),
2865 ONE("statm", S_IRUGO, proc_pid_statm),
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -07002866 REG("maps", S_IRUGO, proc_tid_maps_operations),
Cyrill Gorcunov818411612012-05-31 16:26:43 -07002867#ifdef CONFIG_CHECKPOINT_RESTORE
2868 REG("children", S_IRUGO, proc_tid_children_operations),
2869#endif
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002870#ifdef CONFIG_NUMA
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -07002871 REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002872#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002873 REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),
2874 LNK("cwd", proc_cwd_link),
2875 LNK("root", proc_root_link),
2876 LNK("exe", proc_exe_link),
2877 REG("mounts", S_IRUGO, proc_mounts_operations),
2878 REG("mountinfo", S_IRUGO, proc_mountinfo_operations),
Matt Mackall1e883282008-02-04 22:29:07 -08002879#ifdef CONFIG_PROC_PAGE_MONITOR
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002880 REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
Siddhesh Poyarekarb7643752012-03-21 16:34:04 -07002881 REG("smaps", S_IRUGO, proc_tid_smaps_operations),
Al Viroca6b0bf2011-02-15 22:04:37 -05002882 REG("pagemap", S_IRUGO, proc_pagemap_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002883#endif
2884#ifdef CONFIG_SECURITY
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002885 DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002886#endif
2887#ifdef CONFIG_KALLSYMS
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002888 INF("wchan", S_IRUGO, proc_pid_wchan),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002889#endif
Ken Chen2ec220e2008-11-10 11:26:08 +03002890#ifdef CONFIG_STACKTRACE
Al Viroa9712bc2011-03-23 15:52:50 -04002891 ONE("stack", S_IRUGO, proc_pid_stack),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002892#endif
2893#ifdef CONFIG_SCHEDSTATS
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002894 INF("schedstat", S_IRUGO, proc_pid_schedstat),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002895#endif
Arjan van de Ven97455122008-01-25 21:08:34 +01002896#ifdef CONFIG_LATENCYTOP
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002897 REG("latency", S_IRUGO, proc_lstats_operations),
Arjan van de Ven97455122008-01-25 21:08:34 +01002898#endif
Paul Menage8793d852007-10-18 23:39:39 -07002899#ifdef CONFIG_PROC_PID_CPUSET
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002900 REG("cpuset", S_IRUGO, proc_cpuset_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002901#endif
Paul Menagea4243162007-10-18 23:39:35 -07002902#ifdef CONFIG_CGROUPS
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002903 REG("cgroup", S_IRUGO, proc_cgroup_operations),
Paul Menagea4243162007-10-18 23:39:35 -07002904#endif
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002905 INF("oom_score", S_IRUGO, proc_oom_score),
David Rientjesfa0cbbf2012-11-12 17:53:04 -08002906 REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations),
David Rientjesa63d83f2010-08-09 17:19:46 -07002907 REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002908#ifdef CONFIG_AUDITSYSCALL
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002909 REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations),
Al Viro26ec3c62011-02-15 21:24:05 -05002910 REG("sessionid", S_IRUGO, proc_sessionid_operations),
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002911#endif
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08002912#ifdef CONFIG_FAULT_INJECTION
Alexey Dobriyan631f9c12008-11-10 01:32:52 +03002913 REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08002914#endif
Andrea Righi297c5d92008-07-25 01:48:49 -07002915#ifdef CONFIG_TASK_IO_ACCOUNTING
Vasiliy Kulikov1d1221f2011-06-24 16:08:38 +04002916 INF("io", S_IRUSR, proc_tid_io_accounting),
Andrea Righi297c5d92008-07-25 01:48:49 -07002917#endif
Chris Metcalff133ecc2011-05-26 12:40:09 -04002918#ifdef CONFIG_HARDWALL
2919 INF("hardwall", S_IRUGO, proc_pid_hardwall),
2920#endif
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002921#ifdef CONFIG_USER_NS
2922 REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations),
2923 REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations),
Eric W. Biedermanf76d2072012-08-30 01:24:05 -07002924 REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
Eric W. Biederman22d917d2011-11-17 00:11:58 -08002925#endif
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002926};
2927
2928static int proc_tid_base_readdir(struct file * filp,
2929 void * dirent, filldir_t filldir)
2930{
2931 return proc_pident_readdir(filp,dirent,filldir,
2932 tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
2933}
2934
Al Viro00cd8dd2012-06-10 17:13:09 -04002935static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
2936{
Eric W. Biederman7bcd6b02006-10-02 02:18:56 -07002937 return proc_pident_lookup(dir, dentry,
2938 tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002939}
2940
Arjan van de Ven00977a52007-02-12 00:55:34 -08002941static const struct file_operations proc_tid_base_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002942 .read = generic_read_dir,
2943 .readdir = proc_tid_base_readdir,
Arnd Bergmann6038f372010-08-15 18:52:59 +02002944 .llseek = default_llseek,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002945};
2946
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08002947static const struct inode_operations proc_tid_base_inode_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002948 .lookup = proc_tid_base_lookup,
2949 .getattr = pid_getattr,
2950 .setattr = proc_setattr,
2951};
2952
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002953static struct dentry *proc_task_instantiate(struct inode *dir,
Eric Dumazetc5141e62007-05-08 00:26:15 -07002954 struct dentry *dentry, struct task_struct *task, const void *ptr)
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002955{
2956 struct dentry *error = ERR_PTR(-ENOENT);
2957 struct inode *inode;
Eric W. Biederman61a28782006-10-02 02:18:49 -07002958 inode = proc_pid_make_inode(dir->i_sb, task);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002959
2960 if (!inode)
2961 goto out;
2962 inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2963 inode->i_op = &proc_tid_base_inode_operations;
2964 inode->i_fop = &proc_tid_base_operations;
2965 inode->i_flags|=S_IMMUTABLE;
Vegard Nossumaed54172008-06-05 22:46:53 -07002966
Miklos Szeredibfe86842011-10-28 14:13:29 +02002967 set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff,
2968 ARRAY_SIZE(tid_base_stuff)));
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002969
Nick Pigginfb045ad2011-01-07 17:49:55 +11002970 d_set_d_op(dentry, &pid_dentry_operations);
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002971
2972 d_add(dentry, inode);
2973 /* Close the race of the process dying before we return the dentry */
Al Viro0b728e12012-06-10 16:03:43 -04002974 if (pid_revalidate(dentry, 0))
Eric W. Biederman444ceed2006-10-02 02:18:49 -07002975 error = NULL;
2976out:
2977 return error;
2978}
2979
Al Viro00cd8dd2012-06-10 17:13:09 -04002980static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002981{
2982 struct dentry *result = ERR_PTR(-ENOENT);
2983 struct task_struct *task;
2984 struct task_struct *leader = get_proc_task(dir);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002985 unsigned tid;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002986 struct pid_namespace *ns;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002987
2988 if (!leader)
2989 goto out_no_task;
2990
2991 tid = name_to_int(dentry);
2992 if (tid == ~0U)
2993 goto out;
2994
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002995 ns = dentry->d_sb->s_fs_info;
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002996 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002997 task = find_task_by_pid_ns(tid, ns);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07002998 if (task)
2999 get_task_struct(task);
3000 rcu_read_unlock();
3001 if (!task)
3002 goto out;
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07003003 if (!same_thread_group(leader, task))
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003004 goto out_drop_task;
3005
Eric W. Biederman444ceed2006-10-02 02:18:49 -07003006 result = proc_task_instantiate(dir, dentry, task, NULL);
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003007out_drop_task:
3008 put_task_struct(task);
3009out:
3010 put_task_struct(leader);
3011out_no_task:
3012 return result;
3013}
3014
3015/*
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003016 * Find the first tid of a thread group to return to user space.
3017 *
3018 * Usually this is just the thread group leader, but if the users
3019 * buffer was too small or there was a seek into the middle of the
3020 * directory we have more work todo.
3021 *
3022 * In the case of a short read we start with find_task_by_pid.
3023 *
3024 * In the case of a seek we start with the leader and walk nr
3025 * threads past it.
3026 */
Eric W. Biedermancc288732006-06-26 00:26:01 -07003027static struct task_struct *first_tid(struct task_struct *leader,
Pavel Emelyanovb4888932007-10-18 23:40:14 -07003028 int tid, int nr, struct pid_namespace *ns)
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003029{
Oleg Nesterova872ff02006-06-26 00:26:01 -07003030 struct task_struct *pos;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003031
Eric W. Biedermancc288732006-06-26 00:26:01 -07003032 rcu_read_lock();
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003033 /* Attempt to start with the pid of a thread */
3034 if (tid && (nr > 0)) {
Pavel Emelyanovb4888932007-10-18 23:40:14 -07003035 pos = find_task_by_pid_ns(tid, ns);
Oleg Nesterova872ff02006-06-26 00:26:01 -07003036 if (pos && (pos->group_leader == leader))
3037 goto found;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003038 }
3039
3040 /* If nr exceeds the number of threads there is nothing todo */
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003041 pos = NULL;
Oleg Nesterova872ff02006-06-26 00:26:01 -07003042 if (nr && nr >= get_nr_threads(leader))
3043 goto out;
3044
3045 /* If we haven't found our starting place yet start
3046 * with the leader and walk nr threads forward.
3047 */
3048 for (pos = leader; nr > 0; --nr) {
3049 pos = next_thread(pos);
3050 if (pos == leader) {
3051 pos = NULL;
3052 goto out;
3053 }
3054 }
3055found:
3056 get_task_struct(pos);
3057out:
Eric W. Biedermancc288732006-06-26 00:26:01 -07003058 rcu_read_unlock();
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003059 return pos;
3060}
3061
3062/*
3063 * Find the next thread in the thread list.
3064 * Return NULL if there is an error or no next thread.
3065 *
3066 * The reference to the input task_struct is released.
3067 */
3068static struct task_struct *next_tid(struct task_struct *start)
3069{
Oleg Nesterovc1df7fb2006-06-26 00:26:02 -07003070 struct task_struct *pos = NULL;
Eric W. Biedermancc288732006-06-26 00:26:01 -07003071 rcu_read_lock();
Oleg Nesterovc1df7fb2006-06-26 00:26:02 -07003072 if (pid_alive(start)) {
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003073 pos = next_thread(start);
Oleg Nesterovc1df7fb2006-06-26 00:26:02 -07003074 if (thread_group_leader(pos))
3075 pos = NULL;
3076 else
3077 get_task_struct(pos);
3078 }
Eric W. Biedermancc288732006-06-26 00:26:01 -07003079 rcu_read_unlock();
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003080 put_task_struct(start);
3081 return pos;
3082}
3083
Eric W. Biederman61a28782006-10-02 02:18:49 -07003084static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
3085 struct task_struct *task, int tid)
3086{
3087 char name[PROC_NUMBUF];
3088 int len = snprintf(name, sizeof(name), "%d", tid);
3089 return proc_fill_cache(filp, dirent, filldir, name, len,
3090 proc_task_instantiate, task, NULL);
3091}
3092
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093/* for the /proc/TGID/task/ directories */
3094static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
3095{
Josef "Jeff" Sipek2fddfee2006-12-08 02:36:36 -08003096 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 struct inode *inode = dentry->d_inode;
Guillaume Chazarain7d895242007-01-31 23:48:14 -08003098 struct task_struct *leader = NULL;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003099 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 int retval = -ENOENT;
3101 ino_t ino;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003102 int tid;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07003103 struct pid_namespace *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104
Guillaume Chazarain7d895242007-01-31 23:48:14 -08003105 task = get_proc_task(inode);
3106 if (!task)
3107 goto out_no_task;
3108 rcu_read_lock();
3109 if (pid_alive(task)) {
3110 leader = task->group_leader;
3111 get_task_struct(leader);
3112 }
3113 rcu_read_unlock();
3114 put_task_struct(task);
Eric W. Biederman99f89552006-06-26 00:25:55 -07003115 if (!leader)
3116 goto out_no_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 retval = 0;
3118
Linus Torvaldsee568b22009-03-17 10:02:35 -07003119 switch ((unsigned long)filp->f_pos) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003120 case 0:
3121 ino = inode->i_ino;
Zhang Leee6f7792009-03-16 14:44:31 +08003122 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 goto out;
Zhang Leee6f7792009-03-16 14:44:31 +08003124 filp->f_pos++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 /* fall through */
3126 case 1:
3127 ino = parent_ino(dentry);
Zhang Leee6f7792009-03-16 14:44:31 +08003128 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 goto out;
Zhang Leee6f7792009-03-16 14:44:31 +08003130 filp->f_pos++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131 /* fall through */
3132 }
3133
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003134 /* f_version caches the tgid value that the last readdir call couldn't
3135 * return. lseek aka telldir automagically resets f_version to 0.
3136 */
Pavel Emelyanovb4888932007-10-18 23:40:14 -07003137 ns = filp->f_dentry->d_sb->s_fs_info;
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -07003138 tid = (int)filp->f_version;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003139 filp->f_version = 0;
Zhang Leee6f7792009-03-16 14:44:31 +08003140 for (task = first_tid(leader, tid, filp->f_pos - 2, ns);
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003141 task;
Zhang Leee6f7792009-03-16 14:44:31 +08003142 task = next_tid(task), filp->f_pos++) {
Pavel Emelyanovb4888932007-10-18 23:40:14 -07003143 tid = task_pid_nr_ns(task, ns);
Eric W. Biederman61a28782006-10-02 02:18:49 -07003144 if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) {
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003145 /* returning this tgid failed, save it as the first
3146 * pid for the next readir call */
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -07003147 filp->f_version = (u64)tid;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003148 put_task_struct(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149 break;
Eric W. Biederman0bc58a92006-06-26 00:25:50 -07003150 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 }
3152out:
Eric W. Biederman99f89552006-06-26 00:25:55 -07003153 put_task_struct(leader);
3154out_no_task:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 return retval;
3156}
Eric W. Biederman6e66b522006-06-26 00:25:47 -07003157
3158static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
3159{
3160 struct inode *inode = dentry->d_inode;
Eric W. Biederman99f89552006-06-26 00:25:55 -07003161 struct task_struct *p = get_proc_task(inode);
Eric W. Biederman6e66b522006-06-26 00:25:47 -07003162 generic_fillattr(inode, stat);
3163
Eric W. Biederman99f89552006-06-26 00:25:55 -07003164 if (p) {
Eric W. Biederman99f89552006-06-26 00:25:55 -07003165 stat->nlink += get_nr_threads(p);
Eric W. Biederman99f89552006-06-26 00:25:55 -07003166 put_task_struct(p);
Eric W. Biederman6e66b522006-06-26 00:25:47 -07003167 }
3168
3169 return 0;
3170}
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003171
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08003172static const struct inode_operations proc_task_inode_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003173 .lookup = proc_task_lookup,
3174 .getattr = proc_task_getattr,
3175 .setattr = proc_setattr,
Vasiliy Kulikov04996802012-01-10 15:11:31 -08003176 .permission = proc_pid_permission,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003177};
3178
Arjan van de Ven00977a52007-02-12 00:55:34 -08003179static const struct file_operations proc_task_operations = {
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003180 .read = generic_read_dir,
3181 .readdir = proc_task_readdir,
Arnd Bergmann6038f372010-08-15 18:52:59 +02003182 .llseek = default_llseek,
Eric W. Biederman28a6d672006-10-02 02:17:05 -07003183};