projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.infradead.org/battery-2.6
[deliverable/linux.git] / fs / proc / base.c
1 /*
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.
14 *
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.
48 */
49
50 #include <asm/uaccess.h>
51
52 #include <linux/errno.h>
53 #include <linux/time.h>
54 #include <linux/proc_fs.h>
55 #include <linux/stat.h>
56 #include <linux/init.h>
57 #include <linux/capability.h>
58 #include <linux/file.h>
59 #include <linux/string.h>
60 #include <linux/seq_file.h>
61 #include <linux/namei.h>
62 #include <linux/mnt_namespace.h>
63 #include <linux/mm.h>
64 #include <linux/rcupdate.h>
65 #include <linux/kallsyms.h>
66 #include <linux/resource.h>
67 #include <linux/module.h>
68 #include <linux/mount.h>
69 #include <linux/security.h>
70 #include <linux/ptrace.h>
71 #include <linux/cgroup.h>
72 #include <linux/cpuset.h>
73 #include <linux/audit.h>
74 #include <linux/poll.h>
75 #include <linux/nsproxy.h>
76 #include <linux/oom.h>
77 #include <linux/elf.h>
78 #include <linux/pid_namespace.h>
79 #include "internal.h"
80
81 /* NOTE:
82 * Implementing inode permission operations in /proc is almost
83 * certainly an error. Permission checks need to happen during
84 * each system call not at open time. The reason is that most of
85 * what we wish to check for permissions in /proc varies at runtime.
86 *
87 * The classic example of a problem is opening file descriptors
88 * in /proc for a task before it execs a suid executable.
89 */
90
91
92 /* Worst case buffer size needed for holding an integer. */
93 #define PROC_NUMBUF 13
94
95 struct pid_entry {
96 char *name;
97 int len;
98 mode_t mode;
99 const struct inode_operations *iop;
100 const struct file_operations *fop;
101 union proc_op op;
102 };
103
104 #define NOD(NAME, MODE, IOP, FOP, OP) { \
105 .name = (NAME), \
106 .len = sizeof(NAME) - 1, \
107 .mode = MODE, \
108 .iop = IOP, \
109 .fop = FOP, \
110 .op = OP, \
111 }
112
113 #define DIR(NAME, MODE, OTYPE) \
114 NOD(NAME, (S_IFDIR|(MODE)), \
115 &proc_##OTYPE##_inode_operations, &proc_##OTYPE##_operations, \
116 {} )
117 #define LNK(NAME, OTYPE) \
118 NOD(NAME, (S_IFLNK|S_IRWXUGO), \
119 &proc_pid_link_inode_operations, NULL, \
120 { .proc_get_link = &proc_##OTYPE##_link } )
121 #define REG(NAME, MODE, OTYPE) \
122 NOD(NAME, (S_IFREG|(MODE)), NULL, \
123 &proc_##OTYPE##_operations, {})
124 #define INF(NAME, MODE, OTYPE) \
125 NOD(NAME, (S_IFREG|(MODE)), \
126 NULL, &proc_info_file_operations, \
127 { .proc_read = &proc_##OTYPE } )
128
129 int maps_protect;
130 EXPORT_SYMBOL(maps_protect);
131
132 static struct fs_struct *get_fs_struct(struct task_struct *task)
133 {
134 struct fs_struct *fs;
135 task_lock(task);
136 fs = task->fs;
137 if(fs)
138 atomic_inc(&fs->count);
139 task_unlock(task);
140 return fs;
141 }
142
143 static int get_nr_threads(struct task_struct *tsk)
144 {
145 /* Must be called with the rcu_read_lock held */
146 unsigned long flags;
147 int count = 0;
148
149 if (lock_task_sighand(tsk, &flags)) {
150 count = atomic_read(&tsk->signal->count);
151 unlock_task_sighand(tsk, &flags);
152 }
153 return count;
154 }
155
156 static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
157 {
158 struct task_struct *task = get_proc_task(inode);
159 struct fs_struct *fs = NULL;
160 int result = -ENOENT;
161
162 if (task) {
163 fs = get_fs_struct(task);
164 put_task_struct(task);
165 }
166 if (fs) {
167 read_lock(&fs->lock);
168 *mnt = mntget(fs->pwdmnt);
169 *dentry = dget(fs->pwd);
170 read_unlock(&fs->lock);
171 result = 0;
172 put_fs_struct(fs);
173 }
174 return result;
175 }
176
177 static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
178 {
179 struct task_struct *task = get_proc_task(inode);
180 struct fs_struct *fs = NULL;
181 int result = -ENOENT;
182
183 if (task) {
184 fs = get_fs_struct(task);
185 put_task_struct(task);
186 }
187 if (fs) {
188 read_lock(&fs->lock);
189 *mnt = mntget(fs->rootmnt);
190 *dentry = dget(fs->root);
191 read_unlock(&fs->lock);
192 result = 0;
193 put_fs_struct(fs);
194 }
195 return result;
196 }
197
198 #define MAY_PTRACE(task) \
199 (task == current || \
200 (task->parent == current && \
201 (task->ptrace & PT_PTRACED) && \
202 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
203 security_ptrace(current,task) == 0))
204
205 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
206 {
207 int res = 0;
208 unsigned int len;
209 struct mm_struct *mm = get_task_mm(task);
210 if (!mm)
211 goto out;
212 if (!mm->arg_end)
213 goto out_mm; /* Shh! No looking before we're done */
214
215 len = mm->arg_end - mm->arg_start;
216
217 if (len > PAGE_SIZE)
218 len = PAGE_SIZE;
219
220 res = access_process_vm(task, mm->arg_start, buffer, len, 0);
221
222 // If the nul at the end of args has been overwritten, then
223 // assume application is using setproctitle(3).
224 if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
225 len = strnlen(buffer, res);
226 if (len < res) {
227 res = len;
228 } else {
229 len = mm->env_end - mm->env_start;
230 if (len > PAGE_SIZE - res)
231 len = PAGE_SIZE - res;
232 res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
233 res = strnlen(buffer, res);
234 }
235 }
236 out_mm:
237 mmput(mm);
238 out:
239 return res;
240 }
241
242 static int proc_pid_auxv(struct task_struct *task, char *buffer)
243 {
244 int res = 0;
245 struct mm_struct *mm = get_task_mm(task);
246 if (mm) {
247 unsigned int nwords = 0;
248 do
249 nwords += 2;
250 while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
251 res = nwords * sizeof(mm->saved_auxv[0]);
252 if (res > PAGE_SIZE)
253 res = PAGE_SIZE;
254 memcpy(buffer, mm->saved_auxv, res);
255 mmput(mm);
256 }
257 return res;
258 }
259
260
261 #ifdef CONFIG_KALLSYMS
262 /*
263 * Provides a wchan file via kallsyms in a proper one-value-per-file format.
264 * Returns the resolved symbol. If that fails, simply return the address.
265 */
266 static int proc_pid_wchan(struct task_struct *task, char *buffer)
267 {
268 unsigned long wchan;
269 char symname[KSYM_NAME_LEN];
270
271 wchan = get_wchan(task);
272
273 if (lookup_symbol_name(wchan, symname) < 0)
274 return sprintf(buffer, "%lu", wchan);
275 else
276 return sprintf(buffer, "%s", symname);
277 }
278 #endif /* CONFIG_KALLSYMS */
279
280 #ifdef CONFIG_SCHEDSTATS
281 /*
282 * Provides /proc/PID/schedstat
283 */
284 static int proc_pid_schedstat(struct task_struct *task, char *buffer)
285 {
286 return sprintf(buffer, "%llu %llu %lu\n",
287 task->sched_info.cpu_time,
288 task->sched_info.run_delay,
289 task->sched_info.pcount);
290 }
291 #endif
292
293 /* The badness from the OOM killer */
294 unsigned long badness(struct task_struct *p, unsigned long uptime);
295 static int proc_oom_score(struct task_struct *task, char *buffer)
296 {
297 unsigned long points;
298 struct timespec uptime;
299
300 do_posix_clock_monotonic_gettime(&uptime);
301 read_lock(&tasklist_lock);
302 points = badness(task, uptime.tv_sec);
303 read_unlock(&tasklist_lock);
304 return sprintf(buffer, "%lu\n", points);
305 }
306
307 struct limit_names {
308 char *name;
309 char *unit;
310 };
311
312 static const struct limit_names lnames[RLIM_NLIMITS] = {
313 [RLIMIT_CPU] = {"Max cpu time", "ms"},
314 [RLIMIT_FSIZE] = {"Max file size", "bytes"},
315 [RLIMIT_DATA] = {"Max data size", "bytes"},
316 [RLIMIT_STACK] = {"Max stack size", "bytes"},
317 [RLIMIT_CORE] = {"Max core file size", "bytes"},
318 [RLIMIT_RSS] = {"Max resident set", "bytes"},
319 [RLIMIT_NPROC] = {"Max processes", "processes"},
320 [RLIMIT_NOFILE] = {"Max open files", "files"},
321 [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
322 [RLIMIT_AS] = {"Max address space", "bytes"},
323 [RLIMIT_LOCKS] = {"Max file locks", "locks"},
324 [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
325 [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
326 [RLIMIT_NICE] = {"Max nice priority", NULL},
327 [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
328 };
329
330 /* Display limits for a process */
331 static int proc_pid_limits(struct task_struct *task, char *buffer)
332 {
333 unsigned int i;
334 int count = 0;
335 unsigned long flags;
336 char *bufptr = buffer;
337
338 struct rlimit rlim[RLIM_NLIMITS];
339
340 rcu_read_lock();
341 if (!lock_task_sighand(task,&flags)) {
342 rcu_read_unlock();
343 return 0;
344 }
345 memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
346 unlock_task_sighand(task, &flags);
347 rcu_read_unlock();
348
349 /*
350 * print the file header
351 */
352 count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n",
353 "Limit", "Soft Limit", "Hard Limit", "Units");
354
355 for (i = 0; i < RLIM_NLIMITS; i++) {
356 if (rlim[i].rlim_cur == RLIM_INFINITY)
357 count += sprintf(&bufptr[count], "%-25s %-20s ",
358 lnames[i].name, "unlimited");
359 else
360 count += sprintf(&bufptr[count], "%-25s %-20lu ",
361 lnames[i].name, rlim[i].rlim_cur);
362
363 if (rlim[i].rlim_max == RLIM_INFINITY)
364 count += sprintf(&bufptr[count], "%-20s ", "unlimited");
365 else
366 count += sprintf(&bufptr[count], "%-20lu ",
367 rlim[i].rlim_max);
368
369 if (lnames[i].unit)
370 count += sprintf(&bufptr[count], "%-10s\n",
371 lnames[i].unit);
372 else
373 count += sprintf(&bufptr[count], "\n");
374 }
375
376 return count;
377 }
378
379 /************************************************************************/
380 /* Here the fs part begins */
381 /************************************************************************/
382
383 /* permission checks */
384 static int proc_fd_access_allowed(struct inode *inode)
385 {
386 struct task_struct *task;
387 int allowed = 0;
388 /* Allow access to a task's file descriptors if it is us or we
389 * may use ptrace attach to the process and find out that
390 * information.
391 */
392 task = get_proc_task(inode);
393 if (task) {
394 allowed = ptrace_may_attach(task);
395 put_task_struct(task);
396 }
397 return allowed;
398 }
399
400 static int proc_setattr(struct dentry *dentry, struct iattr *attr)
401 {
402 int error;
403 struct inode *inode = dentry->d_inode;
404
405 if (attr->ia_valid & ATTR_MODE)
406 return -EPERM;
407
408 error = inode_change_ok(inode, attr);
409 if (!error)
410 error = inode_setattr(inode, attr);
411 return error;
412 }
413
414 static const struct inode_operations proc_def_inode_operations = {
415 .setattr = proc_setattr,
416 };
417
418 extern struct seq_operations mounts_op;
419 struct proc_mounts {
420 struct seq_file m;
421 int event;
422 };
423
424 static int mounts_open(struct inode *inode, struct file *file)
425 {
426 struct task_struct *task = get_proc_task(inode);
427 struct nsproxy *nsp;
428 struct mnt_namespace *ns = NULL;
429 struct proc_mounts *p;
430 int ret = -EINVAL;
431
432 if (task) {
433 rcu_read_lock();
434 nsp = task_nsproxy(task);
435 if (nsp) {
436 ns = nsp->mnt_ns;
437 if (ns)
438 get_mnt_ns(ns);
439 }
440 rcu_read_unlock();
441
442 put_task_struct(task);
443 }
444
445 if (ns) {
446 ret = -ENOMEM;
447 p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
448 if (p) {
449 file->private_data = &p->m;
450 ret = seq_open(file, &mounts_op);
451 if (!ret) {
452 p->m.private = ns;
453 p->event = ns->event;
454 return 0;
455 }
456 kfree(p);
457 }
458 put_mnt_ns(ns);
459 }
460 return ret;
461 }
462
463 static int mounts_release(struct inode *inode, struct file *file)
464 {
465 struct seq_file *m = file->private_data;
466 struct mnt_namespace *ns = m->private;
467 put_mnt_ns(ns);
468 return seq_release(inode, file);
469 }
470
471 static unsigned mounts_poll(struct file *file, poll_table *wait)
472 {
473 struct proc_mounts *p = file->private_data;
474 struct mnt_namespace *ns = p->m.private;
475 unsigned res = 0;
476
477 poll_wait(file, &ns->poll, wait);
478
479 spin_lock(&vfsmount_lock);
480 if (p->event != ns->event) {
481 p->event = ns->event;
482 res = POLLERR;
483 }
484 spin_unlock(&vfsmount_lock);
485
486 return res;
487 }
488
489 static const struct file_operations proc_mounts_operations = {
490 .open = mounts_open,
491 .read = seq_read,
492 .llseek = seq_lseek,
493 .release = mounts_release,
494 .poll = mounts_poll,
495 };
496
497 extern struct seq_operations mountstats_op;
498 static int mountstats_open(struct inode *inode, struct file *file)
499 {
500 int ret = seq_open(file, &mountstats_op);
501
502 if (!ret) {
503 struct seq_file *m = file->private_data;
504 struct nsproxy *nsp;
505 struct mnt_namespace *mnt_ns = NULL;
506 struct task_struct *task = get_proc_task(inode);
507
508 if (task) {
509 rcu_read_lock();
510 nsp = task_nsproxy(task);
511 if (nsp) {
512 mnt_ns = nsp->mnt_ns;
513 if (mnt_ns)
514 get_mnt_ns(mnt_ns);
515 }
516 rcu_read_unlock();
517
518 put_task_struct(task);
519 }
520
521 if (mnt_ns)
522 m->private = mnt_ns;
523 else {
524 seq_release(inode, file);
525 ret = -EINVAL;
526 }
527 }
528 return ret;
529 }
530
531 static const struct file_operations proc_mountstats_operations = {
532 .open = mountstats_open,
533 .read = seq_read,
534 .llseek = seq_lseek,
535 .release = mounts_release,
536 };
537
538 #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */
539
540 static ssize_t proc_info_read(struct file * file, char __user * buf,
541 size_t count, loff_t *ppos)
542 {
543 struct inode * inode = file->f_path.dentry->d_inode;
544 unsigned long page;
545 ssize_t length;
546 struct task_struct *task = get_proc_task(inode);
547
548 length = -ESRCH;
549 if (!task)
550 goto out_no_task;
551
552 if (count > PROC_BLOCK_SIZE)
553 count = PROC_BLOCK_SIZE;
554
555 length = -ENOMEM;
556 if (!(page = __get_free_page(GFP_TEMPORARY)))
557 goto out;
558
559 length = PROC_I(inode)->op.proc_read(task, (char*)page);
560
561 if (length >= 0)
562 length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
563 free_page(page);
564 out:
565 put_task_struct(task);
566 out_no_task:
567 return length;
568 }
569
570 static const struct file_operations proc_info_file_operations = {
571 .read = proc_info_read,
572 };
573
574 static int mem_open(struct inode* inode, struct file* file)
575 {
576 file->private_data = (void*)((long)current->self_exec_id);
577 return 0;
578 }
579
580 static ssize_t mem_read(struct file * file, char __user * buf,
581 size_t count, loff_t *ppos)
582 {
583 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
584 char *page;
585 unsigned long src = *ppos;
586 int ret = -ESRCH;
587 struct mm_struct *mm;
588
589 if (!task)
590 goto out_no_task;
591
592 if (!MAY_PTRACE(task) || !ptrace_may_attach(task))
593 goto out;
594
595 ret = -ENOMEM;
596 page = (char *)__get_free_page(GFP_TEMPORARY);
597 if (!page)
598 goto out;
599
600 ret = 0;
601
602 mm = get_task_mm(task);
603 if (!mm)
604 goto out_free;
605
606 ret = -EIO;
607
608 if (file->private_data != (void*)((long)current->self_exec_id))
609 goto out_put;
610
611 ret = 0;
612
613 while (count > 0) {
614 int this_len, retval;
615
616 this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
617 retval = access_process_vm(task, src, page, this_len, 0);
618 if (!retval || !MAY_PTRACE(task) || !ptrace_may_attach(task)) {
619 if (!ret)
620 ret = -EIO;
621 break;
622 }
623
624 if (copy_to_user(buf, page, retval)) {
625 ret = -EFAULT;
626 break;
627 }
628
629 ret += retval;
630 src += retval;
631 buf += retval;
632 count -= retval;
633 }
634 *ppos = src;
635
636 out_put:
637 mmput(mm);
638 out_free:
639 free_page((unsigned long) page);
640 out:
641 put_task_struct(task);
642 out_no_task:
643 return ret;
644 }
645
646 #define mem_write NULL
647
648 #ifndef mem_write
649 /* This is a security hazard */
650 static ssize_t mem_write(struct file * file, const char __user *buf,
651 size_t count, loff_t *ppos)
652 {
653 int copied;
654 char *page;
655 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
656 unsigned long dst = *ppos;
657
658 copied = -ESRCH;
659 if (!task)
660 goto out_no_task;
661
662 if (!MAY_PTRACE(task) || !ptrace_may_attach(task))
663 goto out;
664
665 copied = -ENOMEM;
666 page = (char *)__get_free_page(GFP_TEMPORARY);
667 if (!page)
668 goto out;
669
670 copied = 0;
671 while (count > 0) {
672 int this_len, retval;
673
674 this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
675 if (copy_from_user(page, buf, this_len)) {
676 copied = -EFAULT;
677 break;
678 }
679 retval = access_process_vm(task, dst, page, this_len, 1);
680 if (!retval) {
681 if (!copied)
682 copied = -EIO;
683 break;
684 }
685 copied += retval;
686 buf += retval;
687 dst += retval;
688 count -= retval;
689 }
690 *ppos = dst;
691 free_page((unsigned long) page);
692 out:
693 put_task_struct(task);
694 out_no_task:
695 return copied;
696 }
697 #endif
698
699 static loff_t mem_lseek(struct file * file, loff_t offset, int orig)
700 {
701 switch (orig) {
702 case 0:
703 file->f_pos = offset;
704 break;
705 case 1:
706 file->f_pos += offset;
707 break;
708 default:
709 return -EINVAL;
710 }
711 force_successful_syscall_return();
712 return file->f_pos;
713 }
714
715 static const struct file_operations proc_mem_operations = {
716 .llseek = mem_lseek,
717 .read = mem_read,
718 .write = mem_write,
719 .open = mem_open,
720 };
721
722 static ssize_t environ_read(struct file *file, char __user *buf,
723 size_t count, loff_t *ppos)
724 {
725 struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
726 char *page;
727 unsigned long src = *ppos;
728 int ret = -ESRCH;
729 struct mm_struct *mm;
730
731 if (!task)
732 goto out_no_task;
733
734 if (!ptrace_may_attach(task))
735 goto out;
736
737 ret = -ENOMEM;
738 page = (char *)__get_free_page(GFP_TEMPORARY);
739 if (!page)
740 goto out;
741
742 ret = 0;
743
744 mm = get_task_mm(task);
745 if (!mm)
746 goto out_free;
747
748 while (count > 0) {
749 int this_len, retval, max_len;
750
751 this_len = mm->env_end - (mm->env_start + src);
752
753 if (this_len <= 0)
754 break;
755
756 max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
757 this_len = (this_len > max_len) ? max_len : this_len;
758
759 retval = access_process_vm(task, (mm->env_start + src),
760 page, this_len, 0);
761
762 if (retval <= 0) {
763 ret = retval;
764 break;
765 }
766
767 if (copy_to_user(buf, page, retval)) {
768 ret = -EFAULT;
769 break;
770 }
771
772 ret += retval;
773 src += retval;
774 buf += retval;
775 count -= retval;
776 }
777 *ppos = src;
778
779 mmput(mm);
780 out_free:
781 free_page((unsigned long) page);
782 out:
783 put_task_struct(task);
784 out_no_task:
785 return ret;
786 }
787
788 static const struct file_operations proc_environ_operations = {
789 .read = environ_read,
790 };
791
792 static ssize_t oom_adjust_read(struct file *file, char __user *buf,
793 size_t count, loff_t *ppos)
794 {
795 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
796 char buffer[PROC_NUMBUF];
797 size_t len;
798 int oom_adjust;
799
800 if (!task)
801 return -ESRCH;
802 oom_adjust = task->oomkilladj;
803 put_task_struct(task);
804
805 len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
806
807 return simple_read_from_buffer(buf, count, ppos, buffer, len);
808 }
809
810 static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
811 size_t count, loff_t *ppos)
812 {
813 struct task_struct *task;
814 char buffer[PROC_NUMBUF], *end;
815 int oom_adjust;
816
817 memset(buffer, 0, sizeof(buffer));
818 if (count > sizeof(buffer) - 1)
819 count = sizeof(buffer) - 1;
820 if (copy_from_user(buffer, buf, count))
821 return -EFAULT;
822 oom_adjust = simple_strtol(buffer, &end, 0);
823 if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) &&
824 oom_adjust != OOM_DISABLE)
825 return -EINVAL;
826 if (*end == '\n')
827 end++;
828 task = get_proc_task(file->f_path.dentry->d_inode);
829 if (!task)
830 return -ESRCH;
831 if (oom_adjust < task->oomkilladj && !capable(CAP_SYS_RESOURCE)) {
832 put_task_struct(task);
833 return -EACCES;
834 }
835 task->oomkilladj = oom_adjust;
836 put_task_struct(task);
837 if (end - buffer == 0)
838 return -EIO;
839 return end - buffer;
840 }
841
842 static const struct file_operations proc_oom_adjust_operations = {
843 .read = oom_adjust_read,
844 .write = oom_adjust_write,
845 };
846
847 #ifdef CONFIG_MMU
848 static ssize_t clear_refs_write(struct file *file, const char __user *buf,
849 size_t count, loff_t *ppos)
850 {
851 struct task_struct *task;
852 char buffer[PROC_NUMBUF], *end;
853 struct mm_struct *mm;
854
855 memset(buffer, 0, sizeof(buffer));
856 if (count > sizeof(buffer) - 1)
857 count = sizeof(buffer) - 1;
858 if (copy_from_user(buffer, buf, count))
859 return -EFAULT;
860 if (!simple_strtol(buffer, &end, 0))
861 return -EINVAL;
862 if (*end == '\n')
863 end++;
864 task = get_proc_task(file->f_path.dentry->d_inode);
865 if (!task)
866 return -ESRCH;
867 mm = get_task_mm(task);
868 if (mm) {
869 clear_refs_smap(mm);
870 mmput(mm);
871 }
872 put_task_struct(task);
873 if (end - buffer == 0)
874 return -EIO;
875 return end - buffer;
876 }
877
878 static struct file_operations proc_clear_refs_operations = {
879 .write = clear_refs_write,
880 };
881 #endif
882
883 #ifdef CONFIG_AUDITSYSCALL
884 #define TMPBUFLEN 21
885 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
886 size_t count, loff_t *ppos)
887 {
888 struct inode * inode = file->f_path.dentry->d_inode;
889 struct task_struct *task = get_proc_task(inode);
890 ssize_t length;
891 char tmpbuf[TMPBUFLEN];
892
893 if (!task)
894 return -ESRCH;
895 length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
896 audit_get_loginuid(task->audit_context));
897 put_task_struct(task);
898 return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
899 }
900
901 static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
902 size_t count, loff_t *ppos)
903 {
904 struct inode * inode = file->f_path.dentry->d_inode;
905 char *page, *tmp;
906 ssize_t length;
907 uid_t loginuid;
908
909 if (!capable(CAP_AUDIT_CONTROL))
910 return -EPERM;
911
912 if (current != pid_task(proc_pid(inode), PIDTYPE_PID))
913 return -EPERM;
914
915 if (count >= PAGE_SIZE)
916 count = PAGE_SIZE - 1;
917
918 if (*ppos != 0) {
919 /* No partial writes. */
920 return -EINVAL;
921 }
922 page = (char*)__get_free_page(GFP_TEMPORARY);
923 if (!page)
924 return -ENOMEM;
925 length = -EFAULT;
926 if (copy_from_user(page, buf, count))
927 goto out_free_page;
928
929 page[count] = '\0';
930 loginuid = simple_strtoul(page, &tmp, 10);
931 if (tmp == page) {
932 length = -EINVAL;
933 goto out_free_page;
934
935 }
936 length = audit_set_loginuid(current, loginuid);
937 if (likely(length == 0))
938 length = count;
939
940 out_free_page:
941 free_page((unsigned long) page);
942 return length;
943 }
944
945 static const struct file_operations proc_loginuid_operations = {
946 .read = proc_loginuid_read,
947 .write = proc_loginuid_write,
948 };
949 #endif
950
951 #ifdef CONFIG_FAULT_INJECTION
952 static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
953 size_t count, loff_t *ppos)
954 {
955 struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
956 char buffer[PROC_NUMBUF];
957 size_t len;
958 int make_it_fail;
959
960 if (!task)
961 return -ESRCH;
962 make_it_fail = task->make_it_fail;
963 put_task_struct(task);
964
965 len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
966
967 return simple_read_from_buffer(buf, count, ppos, buffer, len);
968 }
969
970 static ssize_t proc_fault_inject_write(struct file * file,
971 const char __user * buf, size_t count, loff_t *ppos)
972 {
973 struct task_struct *task;
974 char buffer[PROC_NUMBUF], *end;
975 int make_it_fail;
976
977 if (!capable(CAP_SYS_RESOURCE))
978 return -EPERM;
979 memset(buffer, 0, sizeof(buffer));
980 if (count > sizeof(buffer) - 1)
981 count = sizeof(buffer) - 1;
982 if (copy_from_user(buffer, buf, count))
983 return -EFAULT;
984 make_it_fail = simple_strtol(buffer, &end, 0);
985 if (*end == '\n')
986 end++;
987 task = get_proc_task(file->f_dentry->d_inode);
988 if (!task)
989 return -ESRCH;
990 task->make_it_fail = make_it_fail;
991 put_task_struct(task);
992 if (end - buffer == 0)
993 return -EIO;
994 return end - buffer;
995 }
996
997 static const struct file_operations proc_fault_inject_operations = {
998 .read = proc_fault_inject_read,
999 .write = proc_fault_inject_write,
1000 };
1001 #endif
1002
1003 #ifdef CONFIG_SCHED_DEBUG
1004 /*
1005 * Print out various scheduling related per-task fields:
1006 */
1007 static int sched_show(struct seq_file *m, void *v)
1008 {
1009 struct inode *inode = m->private;
1010 struct task_struct *p;
1011
1012 WARN_ON(!inode);
1013
1014 p = get_proc_task(inode);
1015 if (!p)
1016 return -ESRCH;
1017 proc_sched_show_task(p, m);
1018
1019 put_task_struct(p);
1020
1021 return 0;
1022 }
1023
1024 static ssize_t
1025 sched_write(struct file *file, const char __user *buf,
1026 size_t count, loff_t *offset)
1027 {
1028 struct inode *inode = file->f_path.dentry->d_inode;
1029 struct task_struct *p;
1030
1031 WARN_ON(!inode);
1032
1033 p = get_proc_task(inode);
1034 if (!p)
1035 return -ESRCH;
1036 proc_sched_set_task(p);
1037
1038 put_task_struct(p);
1039
1040 return count;
1041 }
1042
1043 static int sched_open(struct inode *inode, struct file *filp)
1044 {
1045 int ret;
1046
1047 ret = single_open(filp, sched_show, NULL);
1048 if (!ret) {
1049 struct seq_file *m = filp->private_data;
1050
1051 m->private = inode;
1052 }
1053 return ret;
1054 }
1055
1056 static const struct file_operations proc_pid_sched_operations = {
1057 .open = sched_open,
1058 .read = seq_read,
1059 .write = sched_write,
1060 .llseek = seq_lseek,
1061 .release = single_release,
1062 };
1063
1064 #endif
1065
1066 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
1067 {
1068 struct inode *inode = dentry->d_inode;
1069 int error = -EACCES;
1070
1071 /* We don't need a base pointer in the /proc filesystem */
1072 path_release(nd);
1073
1074 /* Are we allowed to snoop on the tasks file descriptors? */
1075 if (!proc_fd_access_allowed(inode))
1076 goto out;
1077
1078 error = PROC_I(inode)->op.proc_get_link(inode, &nd->dentry, &nd->mnt);
1079 nd->last_type = LAST_BIND;
1080 out:
1081 return ERR_PTR(error);
1082 }
1083
1084 static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
1085 char __user *buffer, int buflen)
1086 {
1087 struct inode * inode;
1088 char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
1089 char *path;
1090 int len;
1091
1092 if (!tmp)
1093 return -ENOMEM;
1094
1095 inode = dentry->d_inode;
1096 path = d_path(dentry, mnt, tmp, PAGE_SIZE);
1097 len = PTR_ERR(path);
1098 if (IS_ERR(path))
1099 goto out;
1100 len = tmp + PAGE_SIZE - 1 - path;
1101
1102 if (len > buflen)
1103 len = buflen;
1104 if (copy_to_user(buffer, path, len))
1105 len = -EFAULT;
1106 out:
1107 free_page((unsigned long)tmp);
1108 return len;
1109 }
1110
1111 static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
1112 {
1113 int error = -EACCES;
1114 struct inode *inode = dentry->d_inode;
1115 struct dentry *de;
1116 struct vfsmount *mnt = NULL;
1117
1118 /* Are we allowed to snoop on the tasks file descriptors? */
1119 if (!proc_fd_access_allowed(inode))
1120 goto out;
1121
1122 error = PROC_I(inode)->op.proc_get_link(inode, &de, &mnt);
1123 if (error)
1124 goto out;
1125
1126 error = do_proc_readlink(de, mnt, buffer, buflen);
1127 dput(de);
1128 mntput(mnt);
1129 out:
1130 return error;
1131 }
1132
1133 static const struct inode_operations proc_pid_link_inode_operations = {
1134 .readlink = proc_pid_readlink,
1135 .follow_link = proc_pid_follow_link,
1136 .setattr = proc_setattr,
1137 };
1138
1139
1140 /* building an inode */
1141
1142 static int task_dumpable(struct task_struct *task)
1143 {
1144 int dumpable = 0;
1145 struct mm_struct *mm;
1146
1147 task_lock(task);
1148 mm = task->mm;
1149 if (mm)
1150 dumpable = get_dumpable(mm);
1151 task_unlock(task);
1152 if(dumpable == 1)
1153 return 1;
1154 return 0;
1155 }
1156
1157
1158 static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
1159 {
1160 struct inode * inode;
1161 struct proc_inode *ei;
1162
1163 /* We need a new inode */
1164
1165 inode = new_inode(sb);
1166 if (!inode)
1167 goto out;
1168
1169 /* Common stuff */
1170 ei = PROC_I(inode);
1171 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1172 inode->i_op = &proc_def_inode_operations;
1173
1174 /*
1175 * grab the reference to task.
1176 */
1177 ei->pid = get_task_pid(task, PIDTYPE_PID);
1178 if (!ei->pid)
1179 goto out_unlock;
1180
1181 inode->i_uid = 0;
1182 inode->i_gid = 0;
1183 if (task_dumpable(task)) {
1184 inode->i_uid = task->euid;
1185 inode->i_gid = task->egid;
1186 }
1187 security_task_to_inode(task, inode);
1188
1189 out:
1190 return inode;
1191
1192 out_unlock:
1193 iput(inode);
1194 return NULL;
1195 }
1196
1197 static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
1198 {
1199 struct inode *inode = dentry->d_inode;
1200 struct task_struct *task;
1201 generic_fillattr(inode, stat);
1202
1203 rcu_read_lock();
1204 stat->uid = 0;
1205 stat->gid = 0;
1206 task = pid_task(proc_pid(inode), PIDTYPE_PID);
1207 if (task) {
1208 if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1209 task_dumpable(task)) {
1210 stat->uid = task->euid;
1211 stat->gid = task->egid;
1212 }
1213 }
1214 rcu_read_unlock();
1215 return 0;
1216 }
1217
1218 /* dentry stuff */
1219
1220 /*
1221 * Exceptional case: normally we are not allowed to unhash a busy
1222 * directory. In this case, however, we can do it - no aliasing problems
1223 * due to the way we treat inodes.
1224 *
1225 * Rewrite the inode's ownerships here because the owning task may have
1226 * performed a setuid(), etc.
1227 *
1228 * Before the /proc/pid/status file was created the only way to read
1229 * the effective uid of a /process was to stat /proc/pid. Reading
1230 * /proc/pid/status is slow enough that procps and other packages
1231 * kept stating /proc/pid. To keep the rules in /proc simple I have
1232 * made this apply to all per process world readable and executable
1233 * directories.
1234 */
1235 static int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
1236 {
1237 struct inode *inode = dentry->d_inode;
1238 struct task_struct *task = get_proc_task(inode);
1239 if (task) {
1240 if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1241 task_dumpable(task)) {
1242 inode->i_uid = task->euid;
1243 inode->i_gid = task->egid;
1244 } else {
1245 inode->i_uid = 0;
1246 inode->i_gid = 0;
1247 }
1248 inode->i_mode &= ~(S_ISUID | S_ISGID);
1249 security_task_to_inode(task, inode);
1250 put_task_struct(task);
1251 return 1;
1252 }
1253 d_drop(dentry);
1254 return 0;
1255 }
1256
1257 static int pid_delete_dentry(struct dentry * dentry)
1258 {
1259 /* Is the task we represent dead?
1260 * If so, then don't put the dentry on the lru list,
1261 * kill it immediately.
1262 */
1263 return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
1264 }
1265
1266 static struct dentry_operations pid_dentry_operations =
1267 {
1268 .d_revalidate = pid_revalidate,
1269 .d_delete = pid_delete_dentry,
1270 };
1271
1272 /* Lookups */
1273
1274 typedef struct dentry *instantiate_t(struct inode *, struct dentry *,
1275 struct task_struct *, const void *);
1276
1277 /*
1278 * Fill a directory entry.
1279 *
1280 * If possible create the dcache entry and derive our inode number and
1281 * file type from dcache entry.
1282 *
1283 * Since all of the proc inode numbers are dynamically generated, the inode
1284 * numbers do not exist until the inode is cache. This means creating the
1285 * the dcache entry in readdir is necessary to keep the inode numbers
1286 * reported by readdir in sync with the inode numbers reported
1287 * by stat.
1288 */
1289 static int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
1290 char *name, int len,
1291 instantiate_t instantiate, struct task_struct *task, const void *ptr)
1292 {
1293 struct dentry *child, *dir = filp->f_path.dentry;
1294 struct inode *inode;
1295 struct qstr qname;
1296 ino_t ino = 0;
1297 unsigned type = DT_UNKNOWN;
1298
1299 qname.name = name;
1300 qname.len = len;
1301 qname.hash = full_name_hash(name, len);
1302
1303 child = d_lookup(dir, &qname);
1304 if (!child) {
1305 struct dentry *new;
1306 new = d_alloc(dir, &qname);
1307 if (new) {
1308 child = instantiate(dir->d_inode, new, task, ptr);
1309 if (child)
1310 dput(new);
1311 else
1312 child = new;
1313 }
1314 }
1315 if (!child || IS_ERR(child) || !child->d_inode)
1316 goto end_instantiate;
1317 inode = child->d_inode;
1318 if (inode) {
1319 ino = inode->i_ino;
1320 type = inode->i_mode >> 12;
1321 }
1322 dput(child);
1323 end_instantiate:
1324 if (!ino)
1325 ino = find_inode_number(dir, &qname);
1326 if (!ino)
1327 ino = 1;
1328 return filldir(dirent, name, len, filp->f_pos, ino, type);
1329 }
1330
1331 static unsigned name_to_int(struct dentry *dentry)
1332 {
1333 const char *name = dentry->d_name.name;
1334 int len = dentry->d_name.len;
1335 unsigned n = 0;
1336
1337 if (len > 1 && *name == '0')
1338 goto out;
1339 while (len-- > 0) {
1340 unsigned c = *name++ - '0';
1341 if (c > 9)
1342 goto out;
1343 if (n >= (~0U-9)/10)
1344 goto out;
1345 n *= 10;
1346 n += c;
1347 }
1348 return n;
1349 out:
1350 return ~0U;
1351 }
1352
1353 #define PROC_FDINFO_MAX 64
1354
1355 static int proc_fd_info(struct inode *inode, struct dentry **dentry,
1356 struct vfsmount **mnt, char *info)
1357 {
1358 struct task_struct *task = get_proc_task(inode);
1359 struct files_struct *files = NULL;
1360 struct file *file;
1361 int fd = proc_fd(inode);
1362
1363 if (task) {
1364 files = get_files_struct(task);
1365 put_task_struct(task);
1366 }
1367 if (files) {
1368 /*
1369 * We are not taking a ref to the file structure, so we must
1370 * hold ->file_lock.
1371 */
1372 spin_lock(&files->file_lock);
1373 file = fcheck_files(files, fd);
1374 if (file) {
1375 if (mnt)
1376 *mnt = mntget(file->f_path.mnt);
1377 if (dentry)
1378 *dentry = dget(file->f_path.dentry);
1379 if (info)
1380 snprintf(info, PROC_FDINFO_MAX,
1381 "pos:\t%lli\n"
1382 "flags:\t0%o\n",
1383 (long long) file->f_pos,
1384 file->f_flags);
1385 spin_unlock(&files->file_lock);
1386 put_files_struct(files);
1387 return 0;
1388 }
1389 spin_unlock(&files->file_lock);
1390 put_files_struct(files);
1391 }
1392 return -ENOENT;
1393 }
1394
1395 static int proc_fd_link(struct inode *inode, struct dentry **dentry,
1396 struct vfsmount **mnt)
1397 {
1398 return proc_fd_info(inode, dentry, mnt, NULL);
1399 }
1400
1401 static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
1402 {
1403 struct inode *inode = dentry->d_inode;
1404 struct task_struct *task = get_proc_task(inode);
1405 int fd = proc_fd(inode);
1406 struct files_struct *files;
1407
1408 if (task) {
1409 files = get_files_struct(task);
1410 if (files) {
1411 rcu_read_lock();
1412 if (fcheck_files(files, fd)) {
1413 rcu_read_unlock();
1414 put_files_struct(files);
1415 if (task_dumpable(task)) {
1416 inode->i_uid = task->euid;
1417 inode->i_gid = task->egid;
1418 } else {
1419 inode->i_uid = 0;
1420 inode->i_gid = 0;
1421 }
1422 inode->i_mode &= ~(S_ISUID | S_ISGID);
1423 security_task_to_inode(task, inode);
1424 put_task_struct(task);
1425 return 1;
1426 }
1427 rcu_read_unlock();
1428 put_files_struct(files);
1429 }
1430 put_task_struct(task);
1431 }
1432 d_drop(dentry);
1433 return 0;
1434 }
1435
1436 static struct dentry_operations tid_fd_dentry_operations =
1437 {
1438 .d_revalidate = tid_fd_revalidate,
1439 .d_delete = pid_delete_dentry,
1440 };
1441
1442 static struct dentry *proc_fd_instantiate(struct inode *dir,
1443 struct dentry *dentry, struct task_struct *task, const void *ptr)
1444 {
1445 unsigned fd = *(const unsigned *)ptr;
1446 struct file *file;
1447 struct files_struct *files;
1448 struct inode *inode;
1449 struct proc_inode *ei;
1450 struct dentry *error = ERR_PTR(-ENOENT);
1451
1452 inode = proc_pid_make_inode(dir->i_sb, task);
1453 if (!inode)
1454 goto out;
1455 ei = PROC_I(inode);
1456 ei->fd = fd;
1457 files = get_files_struct(task);
1458 if (!files)
1459 goto out_iput;
1460 inode->i_mode = S_IFLNK;
1461
1462 /*
1463 * We are not taking a ref to the file structure, so we must
1464 * hold ->file_lock.
1465 */
1466 spin_lock(&files->file_lock);
1467 file = fcheck_files(files, fd);
1468 if (!file)
1469 goto out_unlock;
1470 if (file->f_mode & 1)
1471 inode->i_mode |= S_IRUSR | S_IXUSR;
1472 if (file->f_mode & 2)
1473 inode->i_mode |= S_IWUSR | S_IXUSR;
1474 spin_unlock(&files->file_lock);
1475 put_files_struct(files);
1476
1477 inode->i_op = &proc_pid_link_inode_operations;
1478 inode->i_size = 64;
1479 ei->op.proc_get_link = proc_fd_link;
1480 dentry->d_op = &tid_fd_dentry_operations;
1481 d_add(dentry, inode);
1482 /* Close the race of the process dying before we return the dentry */
1483 if (tid_fd_revalidate(dentry, NULL))
1484 error = NULL;
1485
1486 out:
1487 return error;
1488 out_unlock:
1489 spin_unlock(&files->file_lock);
1490 put_files_struct(files);
1491 out_iput:
1492 iput(inode);
1493 goto out;
1494 }
1495
1496 static struct dentry *proc_lookupfd_common(struct inode *dir,
1497 struct dentry *dentry,
1498 instantiate_t instantiate)
1499 {
1500 struct task_struct *task = get_proc_task(dir);
1501 unsigned fd = name_to_int(dentry);
1502 struct dentry *result = ERR_PTR(-ENOENT);
1503
1504 if (!task)
1505 goto out_no_task;
1506 if (fd == ~0U)
1507 goto out;
1508
1509 result = instantiate(dir, dentry, task, &fd);
1510 out:
1511 put_task_struct(task);
1512 out_no_task:
1513 return result;
1514 }
1515
1516 static int proc_readfd_common(struct file * filp, void * dirent,
1517 filldir_t filldir, instantiate_t instantiate)
1518 {
1519 struct dentry *dentry = filp->f_path.dentry;
1520 struct inode *inode = dentry->d_inode;
1521 struct task_struct *p = get_proc_task(inode);
1522 unsigned int fd, ino;
1523 int retval;
1524 struct files_struct * files;
1525 struct fdtable *fdt;
1526
1527 retval = -ENOENT;
1528 if (!p)
1529 goto out_no_task;
1530 retval = 0;
1531
1532 fd = filp->f_pos;
1533 switch (fd) {
1534 case 0:
1535 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
1536 goto out;
1537 filp->f_pos++;
1538 case 1:
1539 ino = parent_ino(dentry);
1540 if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
1541 goto out;
1542 filp->f_pos++;
1543 default:
1544 files = get_files_struct(p);
1545 if (!files)
1546 goto out;
1547 rcu_read_lock();
1548 fdt = files_fdtable(files);
1549 for (fd = filp->f_pos-2;
1550 fd < fdt->max_fds;
1551 fd++, filp->f_pos++) {
1552 char name[PROC_NUMBUF];
1553 int len;
1554
1555 if (!fcheck_files(files, fd))
1556 continue;
1557 rcu_read_unlock();
1558
1559 len = snprintf(name, sizeof(name), "%d", fd);
1560 if (proc_fill_cache(filp, dirent, filldir,
1561 name, len, instantiate,
1562 p, &fd) < 0) {
1563 rcu_read_lock();
1564 break;
1565 }
1566 rcu_read_lock();
1567 }
1568 rcu_read_unlock();
1569 put_files_struct(files);
1570 }
1571 out:
1572 put_task_struct(p);
1573 out_no_task:
1574 return retval;
1575 }
1576
1577 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
1578 struct nameidata *nd)
1579 {
1580 return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
1581 }
1582
1583 static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
1584 {
1585 return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
1586 }
1587
1588 static ssize_t proc_fdinfo_read(struct file *file, char __user *buf,
1589 size_t len, loff_t *ppos)
1590 {
1591 char tmp[PROC_FDINFO_MAX];
1592 int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, NULL, tmp);
1593 if (!err)
1594 err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp));
1595 return err;
1596 }
1597
1598 static const struct file_operations proc_fdinfo_file_operations = {
1599 .open = nonseekable_open,
1600 .read = proc_fdinfo_read,
1601 };
1602
1603 static const struct file_operations proc_fd_operations = {
1604 .read = generic_read_dir,
1605 .readdir = proc_readfd,
1606 };
1607
1608 /*
1609 * /proc/pid/fd needs a special permission handler so that a process can still
1610 * access /proc/self/fd after it has executed a setuid().
1611 */
1612 static int proc_fd_permission(struct inode *inode, int mask,
1613 struct nameidata *nd)
1614 {
1615 int rv;
1616
1617 rv = generic_permission(inode, mask, NULL);
1618 if (rv == 0)
1619 return 0;
1620 if (task_pid(current) == proc_pid(inode))
1621 rv = 0;
1622 return rv;
1623 }
1624
1625 /*
1626 * proc directories can do almost nothing..
1627 */
1628 static const struct inode_operations proc_fd_inode_operations = {
1629 .lookup = proc_lookupfd,
1630 .permission = proc_fd_permission,
1631 .setattr = proc_setattr,
1632 };
1633
1634 static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
1635 struct dentry *dentry, struct task_struct *task, const void *ptr)
1636 {
1637 unsigned fd = *(unsigned *)ptr;
1638 struct inode *inode;
1639 struct proc_inode *ei;
1640 struct dentry *error = ERR_PTR(-ENOENT);
1641
1642 inode = proc_pid_make_inode(dir->i_sb, task);
1643 if (!inode)
1644 goto out;
1645 ei = PROC_I(inode);
1646 ei->fd = fd;
1647 inode->i_mode = S_IFREG | S_IRUSR;
1648 inode->i_fop = &proc_fdinfo_file_operations;
1649 dentry->d_op = &tid_fd_dentry_operations;
1650 d_add(dentry, inode);
1651 /* Close the race of the process dying before we return the dentry */
1652 if (tid_fd_revalidate(dentry, NULL))
1653 error = NULL;
1654
1655 out:
1656 return error;
1657 }
1658
1659 static struct dentry *proc_lookupfdinfo(struct inode *dir,
1660 struct dentry *dentry,
1661 struct nameidata *nd)
1662 {
1663 return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
1664 }
1665
1666 static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
1667 {
1668 return proc_readfd_common(filp, dirent, filldir,
1669 proc_fdinfo_instantiate);
1670 }
1671
1672 static const struct file_operations proc_fdinfo_operations = {
1673 .read = generic_read_dir,
1674 .readdir = proc_readfdinfo,
1675 };
1676
1677 /*
1678 * proc directories can do almost nothing..
1679 */
1680 static const struct inode_operations proc_fdinfo_inode_operations = {
1681 .lookup = proc_lookupfdinfo,
1682 .setattr = proc_setattr,
1683 };
1684
1685
1686 static struct dentry *proc_pident_instantiate(struct inode *dir,
1687 struct dentry *dentry, struct task_struct *task, const void *ptr)
1688 {
1689 const struct pid_entry *p = ptr;
1690 struct inode *inode;
1691 struct proc_inode *ei;
1692 struct dentry *error = ERR_PTR(-EINVAL);
1693
1694 inode = proc_pid_make_inode(dir->i_sb, task);
1695 if (!inode)
1696 goto out;
1697
1698 ei = PROC_I(inode);
1699 inode->i_mode = p->mode;
1700 if (S_ISDIR(inode->i_mode))
1701 inode->i_nlink = 2; /* Use getattr to fix if necessary */
1702 if (p->iop)
1703 inode->i_op = p->iop;
1704 if (p->fop)
1705 inode->i_fop = p->fop;
1706 ei->op = p->op;
1707 dentry->d_op = &pid_dentry_operations;
1708 d_add(dentry, inode);
1709 /* Close the race of the process dying before we return the dentry */
1710 if (pid_revalidate(dentry, NULL))
1711 error = NULL;
1712 out:
1713 return error;
1714 }
1715
1716 static struct dentry *proc_pident_lookup(struct inode *dir,
1717 struct dentry *dentry,
1718 const struct pid_entry *ents,
1719 unsigned int nents)
1720 {
1721 struct inode *inode;
1722 struct dentry *error;
1723 struct task_struct *task = get_proc_task(dir);
1724 const struct pid_entry *p, *last;
1725
1726 error = ERR_PTR(-ENOENT);
1727 inode = NULL;
1728
1729 if (!task)
1730 goto out_no_task;
1731
1732 /*
1733 * Yes, it does not scale. And it should not. Don't add
1734 * new entries into /proc/<tgid>/ without very good reasons.
1735 */
1736 last = &ents[nents - 1];
1737 for (p = ents; p <= last; p++) {
1738 if (p->len != dentry->d_name.len)
1739 continue;
1740 if (!memcmp(dentry->d_name.name, p->name, p->len))
1741 break;
1742 }
1743 if (p > last)
1744 goto out;
1745
1746 error = proc_pident_instantiate(dir, dentry, task, p);
1747 out:
1748 put_task_struct(task);
1749 out_no_task:
1750 return error;
1751 }
1752
1753 static int proc_pident_fill_cache(struct file *filp, void *dirent,
1754 filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
1755 {
1756 return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
1757 proc_pident_instantiate, task, p);
1758 }
1759
1760 static int proc_pident_readdir(struct file *filp,
1761 void *dirent, filldir_t filldir,
1762 const struct pid_entry *ents, unsigned int nents)
1763 {
1764 int i;
1765 struct dentry *dentry = filp->f_path.dentry;
1766 struct inode *inode = dentry->d_inode;
1767 struct task_struct *task = get_proc_task(inode);
1768 const struct pid_entry *p, *last;
1769 ino_t ino;
1770 int ret;
1771
1772 ret = -ENOENT;
1773 if (!task)
1774 goto out_no_task;
1775
1776 ret = 0;
1777 i = filp->f_pos;
1778 switch (i) {
1779 case 0:
1780 ino = inode->i_ino;
1781 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
1782 goto out;
1783 i++;
1784 filp->f_pos++;
1785 /* fall through */
1786 case 1:
1787 ino = parent_ino(dentry);
1788 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
1789 goto out;
1790 i++;
1791 filp->f_pos++;
1792 /* fall through */
1793 default:
1794 i -= 2;
1795 if (i >= nents) {
1796 ret = 1;
1797 goto out;
1798 }
1799 p = ents + i;
1800 last = &ents[nents - 1];
1801 while (p <= last) {
1802 if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
1803 goto out;
1804 filp->f_pos++;
1805 p++;
1806 }
1807 }
1808
1809 ret = 1;
1810 out:
1811 put_task_struct(task);
1812 out_no_task:
1813 return ret;
1814 }
1815
1816 #ifdef CONFIG_SECURITY
1817 static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
1818 size_t count, loff_t *ppos)
1819 {
1820 struct inode * inode = file->f_path.dentry->d_inode;
1821 char *p = NULL;
1822 ssize_t length;
1823 struct task_struct *task = get_proc_task(inode);
1824
1825 if (!task)
1826 return -ESRCH;
1827
1828 length = security_getprocattr(task,
1829 (char*)file->f_path.dentry->d_name.name,
1830 &p);
1831 put_task_struct(task);
1832 if (length > 0)
1833 length = simple_read_from_buffer(buf, count, ppos, p, length);
1834 kfree(p);
1835 return length;
1836 }
1837
1838 static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
1839 size_t count, loff_t *ppos)
1840 {
1841 struct inode * inode = file->f_path.dentry->d_inode;
1842 char *page;
1843 ssize_t length;
1844 struct task_struct *task = get_proc_task(inode);
1845
1846 length = -ESRCH;
1847 if (!task)
1848 goto out_no_task;
1849 if (count > PAGE_SIZE)
1850 count = PAGE_SIZE;
1851
1852 /* No partial writes. */
1853 length = -EINVAL;
1854 if (*ppos != 0)
1855 goto out;
1856
1857 length = -ENOMEM;
1858 page = (char*)__get_free_page(GFP_TEMPORARY);
1859 if (!page)
1860 goto out;
1861
1862 length = -EFAULT;
1863 if (copy_from_user(page, buf, count))
1864 goto out_free;
1865
1866 length = security_setprocattr(task,
1867 (char*)file->f_path.dentry->d_name.name,
1868 (void*)page, count);
1869 out_free:
1870 free_page((unsigned long) page);
1871 out:
1872 put_task_struct(task);
1873 out_no_task:
1874 return length;
1875 }
1876
1877 static const struct file_operations proc_pid_attr_operations = {
1878 .read = proc_pid_attr_read,
1879 .write = proc_pid_attr_write,
1880 };
1881
1882 static const struct pid_entry attr_dir_stuff[] = {
1883 REG("current", S_IRUGO|S_IWUGO, pid_attr),
1884 REG("prev", S_IRUGO, pid_attr),
1885 REG("exec", S_IRUGO|S_IWUGO, pid_attr),
1886 REG("fscreate", S_IRUGO|S_IWUGO, pid_attr),
1887 REG("keycreate", S_IRUGO|S_IWUGO, pid_attr),
1888 REG("sockcreate", S_IRUGO|S_IWUGO, pid_attr),
1889 };
1890
1891 static int proc_attr_dir_readdir(struct file * filp,
1892 void * dirent, filldir_t filldir)
1893 {
1894 return proc_pident_readdir(filp,dirent,filldir,
1895 attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff));
1896 }
1897
1898 static const struct file_operations proc_attr_dir_operations = {
1899 .read = generic_read_dir,
1900 .readdir = proc_attr_dir_readdir,
1901 };
1902
1903 static struct dentry *proc_attr_dir_lookup(struct inode *dir,
1904 struct dentry *dentry, struct nameidata *nd)
1905 {
1906 return proc_pident_lookup(dir, dentry,
1907 attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
1908 }
1909
1910 static const struct inode_operations proc_attr_dir_inode_operations = {
1911 .lookup = proc_attr_dir_lookup,
1912 .getattr = pid_getattr,
1913 .setattr = proc_setattr,
1914 };
1915
1916 #endif
1917
1918 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1919 static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
1920 size_t count, loff_t *ppos)
1921 {
1922 struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
1923 struct mm_struct *mm;
1924 char buffer[PROC_NUMBUF];
1925 size_t len;
1926 int ret;
1927
1928 if (!task)
1929 return -ESRCH;
1930
1931 ret = 0;
1932 mm = get_task_mm(task);
1933 if (mm) {
1934 len = snprintf(buffer, sizeof(buffer), "%08lx\n",
1935 ((mm->flags & MMF_DUMP_FILTER_MASK) >>
1936 MMF_DUMP_FILTER_SHIFT));
1937 mmput(mm);
1938 ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
1939 }
1940
1941 put_task_struct(task);
1942
1943 return ret;
1944 }
1945
1946 static ssize_t proc_coredump_filter_write(struct file *file,
1947 const char __user *buf,
1948 size_t count,
1949 loff_t *ppos)
1950 {
1951 struct task_struct *task;
1952 struct mm_struct *mm;
1953 char buffer[PROC_NUMBUF], *end;
1954 unsigned int val;
1955 int ret;
1956 int i;
1957 unsigned long mask;
1958
1959 ret = -EFAULT;
1960 memset(buffer, 0, sizeof(buffer));
1961 if (count > sizeof(buffer) - 1)
1962 count = sizeof(buffer) - 1;
1963 if (copy_from_user(buffer, buf, count))
1964 goto out_no_task;
1965
1966 ret = -EINVAL;
1967 val = (unsigned int)simple_strtoul(buffer, &end, 0);
1968 if (*end == '\n')
1969 end++;
1970 if (end - buffer == 0)
1971 goto out_no_task;
1972
1973 ret = -ESRCH;
1974 task = get_proc_task(file->f_dentry->d_inode);
1975 if (!task)
1976 goto out_no_task;
1977
1978 ret = end - buffer;
1979 mm = get_task_mm(task);
1980 if (!mm)
1981 goto out_no_mm;
1982
1983 for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
1984 if (val & mask)
1985 set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
1986 else
1987 clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
1988 }
1989
1990 mmput(mm);
1991 out_no_mm:
1992 put_task_struct(task);
1993 out_no_task:
1994 return ret;
1995 }
1996
1997 static const struct file_operations proc_coredump_filter_operations = {
1998 .read = proc_coredump_filter_read,
1999 .write = proc_coredump_filter_write,
2000 };
2001 #endif
2002
2003 /*
2004 * /proc/self:
2005 */
2006 static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
2007 int buflen)
2008 {
2009 char tmp[PROC_NUMBUF];
2010 sprintf(tmp, "%d", task_tgid_vnr(current));
2011 return vfs_readlink(dentry,buffer,buflen,tmp);
2012 }
2013
2014 static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
2015 {
2016 char tmp[PROC_NUMBUF];
2017 sprintf(tmp, "%d", task_tgid_vnr(current));
2018 return ERR_PTR(vfs_follow_link(nd,tmp));
2019 }
2020
2021 static const struct inode_operations proc_self_inode_operations = {
2022 .readlink = proc_self_readlink,
2023 .follow_link = proc_self_follow_link,
2024 };
2025
2026 /*
2027 * proc base
2028 *
2029 * These are the directory entries in the root directory of /proc
2030 * that properly belong to the /proc filesystem, as they describe
2031 * describe something that is process related.
2032 */
2033 static const struct pid_entry proc_base_stuff[] = {
2034 NOD("self", S_IFLNK|S_IRWXUGO,
2035 &proc_self_inode_operations, NULL, {}),
2036 };
2037
2038 /*
2039 * Exceptional case: normally we are not allowed to unhash a busy
2040 * directory. In this case, however, we can do it - no aliasing problems
2041 * due to the way we treat inodes.
2042 */
2043 static int proc_base_revalidate(struct dentry *dentry, struct nameidata *nd)
2044 {
2045 struct inode *inode = dentry->d_inode;
2046 struct task_struct *task = get_proc_task(inode);
2047 if (task) {
2048 put_task_struct(task);
2049 return 1;
2050 }
2051 d_drop(dentry);
2052 return 0;
2053 }
2054
2055 static struct dentry_operations proc_base_dentry_operations =
2056 {
2057 .d_revalidate = proc_base_revalidate,
2058 .d_delete = pid_delete_dentry,
2059 };
2060
2061 static struct dentry *proc_base_instantiate(struct inode *dir,
2062 struct dentry *dentry, struct task_struct *task, const void *ptr)
2063 {
2064 const struct pid_entry *p = ptr;
2065 struct inode *inode;
2066 struct proc_inode *ei;
2067 struct dentry *error = ERR_PTR(-EINVAL);
2068
2069 /* Allocate the inode */
2070 error = ERR_PTR(-ENOMEM);
2071 inode = new_inode(dir->i_sb);
2072 if (!inode)
2073 goto out;
2074
2075 /* Initialize the inode */
2076 ei = PROC_I(inode);
2077 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
2078
2079 /*
2080 * grab the reference to the task.
2081 */
2082 ei->pid = get_task_pid(task, PIDTYPE_PID);
2083 if (!ei->pid)
2084 goto out_iput;
2085
2086 inode->i_uid = 0;
2087 inode->i_gid = 0;
2088 inode->i_mode = p->mode;
2089 if (S_ISDIR(inode->i_mode))
2090 inode->i_nlink = 2;
2091 if (S_ISLNK(inode->i_mode))
2092 inode->i_size = 64;
2093 if (p->iop)
2094 inode->i_op = p->iop;
2095 if (p->fop)
2096 inode->i_fop = p->fop;
2097 ei->op = p->op;
2098 dentry->d_op = &proc_base_dentry_operations;
2099 d_add(dentry, inode);
2100 error = NULL;
2101 out:
2102 return error;
2103 out_iput:
2104 iput(inode);
2105 goto out;
2106 }
2107
2108 static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
2109 {
2110 struct dentry *error;
2111 struct task_struct *task = get_proc_task(dir);
2112 const struct pid_entry *p, *last;
2113
2114 error = ERR_PTR(-ENOENT);
2115
2116 if (!task)
2117 goto out_no_task;
2118
2119 /* Lookup the directory entry */
2120 last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1];
2121 for (p = proc_base_stuff; p <= last; p++) {
2122 if (p->len != dentry->d_name.len)
2123 continue;
2124 if (!memcmp(dentry->d_name.name, p->name, p->len))
2125 break;
2126 }
2127 if (p > last)
2128 goto out;
2129
2130 error = proc_base_instantiate(dir, dentry, task, p);
2131
2132 out:
2133 put_task_struct(task);
2134 out_no_task:
2135 return error;
2136 }
2137
2138 static int proc_base_fill_cache(struct file *filp, void *dirent,
2139 filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
2140 {
2141 return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
2142 proc_base_instantiate, task, p);
2143 }
2144
2145 #ifdef CONFIG_TASK_IO_ACCOUNTING
2146 static int proc_pid_io_accounting(struct task_struct *task, char *buffer)
2147 {
2148 return sprintf(buffer,
2149 #ifdef CONFIG_TASK_XACCT
2150 "rchar: %llu\n"
2151 "wchar: %llu\n"
2152 "syscr: %llu\n"
2153 "syscw: %llu\n"
2154 #endif
2155 "read_bytes: %llu\n"
2156 "write_bytes: %llu\n"
2157 "cancelled_write_bytes: %llu\n",
2158 #ifdef CONFIG_TASK_XACCT
2159 (unsigned long long)task->rchar,
2160 (unsigned long long)task->wchar,
2161 (unsigned long long)task->syscr,
2162 (unsigned long long)task->syscw,
2163 #endif
2164 (unsigned long long)task->ioac.read_bytes,
2165 (unsigned long long)task->ioac.write_bytes,
2166 (unsigned long long)task->ioac.cancelled_write_bytes);
2167 }
2168 #endif
2169
2170 /*
2171 * Thread groups
2172 */
2173 static const struct file_operations proc_task_operations;
2174 static const struct inode_operations proc_task_inode_operations;
2175
2176 static const struct pid_entry tgid_base_stuff[] = {
2177 DIR("task", S_IRUGO|S_IXUGO, task),
2178 DIR("fd", S_IRUSR|S_IXUSR, fd),
2179 DIR("fdinfo", S_IRUSR|S_IXUSR, fdinfo),
2180 REG("environ", S_IRUSR, environ),
2181 INF("auxv", S_IRUSR, pid_auxv),
2182 INF("status", S_IRUGO, pid_status),
2183 INF("limits", S_IRUSR, pid_limits),
2184 #ifdef CONFIG_SCHED_DEBUG
2185 REG("sched", S_IRUGO|S_IWUSR, pid_sched),
2186 #endif
2187 INF("cmdline", S_IRUGO, pid_cmdline),
2188 INF("stat", S_IRUGO, tgid_stat),
2189 INF("statm", S_IRUGO, pid_statm),
2190 REG("maps", S_IRUGO, maps),
2191 #ifdef CONFIG_NUMA
2192 REG("numa_maps", S_IRUGO, numa_maps),
2193 #endif
2194 REG("mem", S_IRUSR|S_IWUSR, mem),
2195 LNK("cwd", cwd),
2196 LNK("root", root),
2197 LNK("exe", exe),
2198 REG("mounts", S_IRUGO, mounts),
2199 REG("mountstats", S_IRUSR, mountstats),
2200 #ifdef CONFIG_MMU
2201 REG("clear_refs", S_IWUSR, clear_refs),
2202 REG("smaps", S_IRUGO, smaps),
2203 #endif
2204 #ifdef CONFIG_SECURITY
2205 DIR("attr", S_IRUGO|S_IXUGO, attr_dir),
2206 #endif
2207 #ifdef CONFIG_KALLSYMS
2208 INF("wchan", S_IRUGO, pid_wchan),
2209 #endif
2210 #ifdef CONFIG_SCHEDSTATS
2211 INF("schedstat", S_IRUGO, pid_schedstat),
2212 #endif
2213 #ifdef CONFIG_PROC_PID_CPUSET
2214 REG("cpuset", S_IRUGO, cpuset),
2215 #endif
2216 #ifdef CONFIG_CGROUPS
2217 REG("cgroup", S_IRUGO, cgroup),
2218 #endif
2219 INF("oom_score", S_IRUGO, oom_score),
2220 REG("oom_adj", S_IRUGO|S_IWUSR, oom_adjust),
2221 #ifdef CONFIG_AUDITSYSCALL
2222 REG("loginuid", S_IWUSR|S_IRUGO, loginuid),
2223 #endif
2224 #ifdef CONFIG_FAULT_INJECTION
2225 REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
2226 #endif
2227 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
2228 REG("coredump_filter", S_IRUGO|S_IWUSR, coredump_filter),
2229 #endif
2230 #ifdef CONFIG_TASK_IO_ACCOUNTING
2231 INF("io", S_IRUGO, pid_io_accounting),
2232 #endif
2233 };
2234
2235 static int proc_tgid_base_readdir(struct file * filp,
2236 void * dirent, filldir_t filldir)
2237 {
2238 return proc_pident_readdir(filp,dirent,filldir,
2239 tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
2240 }
2241
2242 static const struct file_operations proc_tgid_base_operations = {
2243 .read = generic_read_dir,
2244 .readdir = proc_tgid_base_readdir,
2245 };
2246
2247 static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
2248 return proc_pident_lookup(dir, dentry,
2249 tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
2250 }
2251
2252 static const struct inode_operations proc_tgid_base_inode_operations = {
2253 .lookup = proc_tgid_base_lookup,
2254 .getattr = pid_getattr,
2255 .setattr = proc_setattr,
2256 };
2257
2258 /**
2259 * proc_flush_task - Remove dcache entries for @task from the /proc dcache.
2260 *
2261 * @task: task that should be flushed.
2262 *
2263 * Looks in the dcache for
2264 * /proc/@pid
2265 * /proc/@tgid/task/@pid
2266 * if either directory is present flushes it and all of it'ts children
2267 * from the dcache.
2268 *
2269 * It is safe and reasonable to cache /proc entries for a task until
2270 * that task exits. After that they just clog up the dcache with
2271 * useless entries, possibly causing useful dcache entries to be
2272 * flushed instead. This routine is proved to flush those useless
2273 * dcache entries at process exit time.
2274 *
2275 * NOTE: This routine is just an optimization so it does not guarantee
2276 * that no dcache entries will exist at process exit time it
2277 * just makes it very unlikely that any will persist.
2278 */
2279 static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
2280 {
2281 struct dentry *dentry, *leader, *dir;
2282 char buf[PROC_NUMBUF];
2283 struct qstr name;
2284
2285 name.name = buf;
2286 name.len = snprintf(buf, sizeof(buf), "%d", pid);
2287 dentry = d_hash_and_lookup(mnt->mnt_root, &name);
2288 if (dentry) {
2289 shrink_dcache_parent(dentry);
2290 d_drop(dentry);
2291 dput(dentry);
2292 }
2293
2294 if (tgid == 0)
2295 goto out;
2296
2297 name.name = buf;
2298 name.len = snprintf(buf, sizeof(buf), "%d", tgid);
2299 leader = d_hash_and_lookup(mnt->mnt_root, &name);
2300 if (!leader)
2301 goto out;
2302
2303 name.name = "task";
2304 name.len = strlen(name.name);
2305 dir = d_hash_and_lookup(leader, &name);
2306 if (!dir)
2307 goto out_put_leader;
2308
2309 name.name = buf;
2310 name.len = snprintf(buf, sizeof(buf), "%d", pid);
2311 dentry = d_hash_and_lookup(dir, &name);
2312 if (dentry) {
2313 shrink_dcache_parent(dentry);
2314 d_drop(dentry);
2315 dput(dentry);
2316 }
2317
2318 dput(dir);
2319 out_put_leader:
2320 dput(leader);
2321 out:
2322 return;
2323 }
2324
2325 /*
2326 * when flushing dentries from proc one need to flush them from global
2327 * proc (proc_mnt) and from all the namespaces' procs this task was seen
2328 * in. this call is supposed to make all this job.
2329 */
2330
2331 void proc_flush_task(struct task_struct *task)
2332 {
2333 int i, leader;
2334 struct pid *pid, *tgid;
2335 struct upid *upid;
2336
2337 leader = thread_group_leader(task);
2338 proc_flush_task_mnt(proc_mnt, task->pid, leader ? task->tgid : 0);
2339 pid = task_pid(task);
2340 if (pid->level == 0)
2341 return;
2342
2343 tgid = task_tgid(task);
2344 for (i = 1; i <= pid->level; i++) {
2345 upid = &pid->numbers[i];
2346 proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
2347 leader ? 0 : tgid->numbers[i].nr);
2348 }
2349
2350 upid = &pid->numbers[pid->level];
2351 if (upid->nr == 1)
2352 pid_ns_release_proc(upid->ns);
2353 }
2354
2355 static struct dentry *proc_pid_instantiate(struct inode *dir,
2356 struct dentry * dentry,
2357 struct task_struct *task, const void *ptr)
2358 {
2359 struct dentry *error = ERR_PTR(-ENOENT);
2360 struct inode *inode;
2361
2362 inode = proc_pid_make_inode(dir->i_sb, task);
2363 if (!inode)
2364 goto out;
2365
2366 inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2367 inode->i_op = &proc_tgid_base_inode_operations;
2368 inode->i_fop = &proc_tgid_base_operations;
2369 inode->i_flags|=S_IMMUTABLE;
2370 inode->i_nlink = 5;
2371 #ifdef CONFIG_SECURITY
2372 inode->i_nlink += 1;
2373 #endif
2374
2375 dentry->d_op = &pid_dentry_operations;
2376
2377 d_add(dentry, inode);
2378 /* Close the race of the process dying before we return the dentry */
2379 if (pid_revalidate(dentry, NULL))
2380 error = NULL;
2381 out:
2382 return error;
2383 }
2384
2385 struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
2386 {
2387 struct dentry *result = ERR_PTR(-ENOENT);
2388 struct task_struct *task;
2389 unsigned tgid;
2390 struct pid_namespace *ns;
2391
2392 result = proc_base_lookup(dir, dentry);
2393 if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
2394 goto out;
2395
2396 tgid = name_to_int(dentry);
2397 if (tgid == ~0U)
2398 goto out;
2399
2400 ns = dentry->d_sb->s_fs_info;
2401 rcu_read_lock();
2402 task = find_task_by_pid_ns(tgid, ns);
2403 if (task)
2404 get_task_struct(task);
2405 rcu_read_unlock();
2406 if (!task)
2407 goto out;
2408
2409 result = proc_pid_instantiate(dir, dentry, task, NULL);
2410 put_task_struct(task);
2411 out:
2412 return result;
2413 }
2414
2415 /*
2416 * Find the first task with tgid >= tgid
2417 *
2418 */
2419 static struct task_struct *next_tgid(unsigned int tgid,
2420 struct pid_namespace *ns)
2421 {
2422 struct task_struct *task;
2423 struct pid *pid;
2424
2425 rcu_read_lock();
2426 retry:
2427 task = NULL;
2428 pid = find_ge_pid(tgid, ns);
2429 if (pid) {
2430 tgid = pid_nr_ns(pid, ns) + 1;
2431 task = pid_task(pid, PIDTYPE_PID);
2432 /* What we to know is if the pid we have find is the
2433 * pid of a thread_group_leader. Testing for task
2434 * being a thread_group_leader is the obvious thing
2435 * todo but there is a window when it fails, due to
2436 * the pid transfer logic in de_thread.
2437 *
2438 * So we perform the straight forward test of seeing
2439 * if the pid we have found is the pid of a thread
2440 * group leader, and don't worry if the task we have
2441 * found doesn't happen to be a thread group leader.
2442 * As we don't care in the case of readdir.
2443 */
2444 if (!task || !has_group_leader_pid(task))
2445 goto retry;
2446 get_task_struct(task);
2447 }
2448 rcu_read_unlock();
2449 return task;
2450 }
2451
2452 #define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff))
2453
2454 static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
2455 struct task_struct *task, int tgid)
2456 {
2457 char name[PROC_NUMBUF];
2458 int len = snprintf(name, sizeof(name), "%d", tgid);
2459 return proc_fill_cache(filp, dirent, filldir, name, len,
2460 proc_pid_instantiate, task, NULL);
2461 }
2462
2463 /* for the /proc/ directory itself, after non-process stuff has been done */
2464 int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
2465 {
2466 unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
2467 struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode);
2468 struct task_struct *task;
2469 int tgid;
2470 struct pid_namespace *ns;
2471
2472 if (!reaper)
2473 goto out_no_task;
2474
2475 for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) {
2476 const struct pid_entry *p = &proc_base_stuff[nr];
2477 if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0)
2478 goto out;
2479 }
2480
2481 ns = filp->f_dentry->d_sb->s_fs_info;
2482 tgid = filp->f_pos - TGID_OFFSET;
2483 for (task = next_tgid(tgid, ns);
2484 task;
2485 put_task_struct(task), task = next_tgid(tgid + 1, ns)) {
2486 tgid = task_pid_nr_ns(task, ns);
2487 filp->f_pos = tgid + TGID_OFFSET;
2488 if (proc_pid_fill_cache(filp, dirent, filldir, task, tgid) < 0) {
2489 put_task_struct(task);
2490 goto out;
2491 }
2492 }
2493 filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET;
2494 out:
2495 put_task_struct(reaper);
2496 out_no_task:
2497 return 0;
2498 }
2499
2500 /*
2501 * Tasks
2502 */
2503 static const struct pid_entry tid_base_stuff[] = {
2504 DIR("fd", S_IRUSR|S_IXUSR, fd),
2505 DIR("fdinfo", S_IRUSR|S_IXUSR, fdinfo),
2506 REG("environ", S_IRUSR, environ),
2507 INF("auxv", S_IRUSR, pid_auxv),
2508 INF("status", S_IRUGO, pid_status),
2509 INF("limits", S_IRUSR, pid_limits),
2510 #ifdef CONFIG_SCHED_DEBUG
2511 REG("sched", S_IRUGO|S_IWUSR, pid_sched),
2512 #endif
2513 INF("cmdline", S_IRUGO, pid_cmdline),
2514 INF("stat", S_IRUGO, tid_stat),
2515 INF("statm", S_IRUGO, pid_statm),
2516 REG("maps", S_IRUGO, maps),
2517 #ifdef CONFIG_NUMA
2518 REG("numa_maps", S_IRUGO, numa_maps),
2519 #endif
2520 REG("mem", S_IRUSR|S_IWUSR, mem),
2521 LNK("cwd", cwd),
2522 LNK("root", root),
2523 LNK("exe", exe),
2524 REG("mounts", S_IRUGO, mounts),
2525 #ifdef CONFIG_MMU
2526 REG("clear_refs", S_IWUSR, clear_refs),
2527 REG("smaps", S_IRUGO, smaps),
2528 #endif
2529 #ifdef CONFIG_SECURITY
2530 DIR("attr", S_IRUGO|S_IXUGO, attr_dir),
2531 #endif
2532 #ifdef CONFIG_KALLSYMS
2533 INF("wchan", S_IRUGO, pid_wchan),
2534 #endif
2535 #ifdef CONFIG_SCHEDSTATS
2536 INF("schedstat", S_IRUGO, pid_schedstat),
2537 #endif
2538 #ifdef CONFIG_PROC_PID_CPUSET
2539 REG("cpuset", S_IRUGO, cpuset),
2540 #endif
2541 #ifdef CONFIG_CGROUPS
2542 REG("cgroup", S_IRUGO, cgroup),
2543 #endif
2544 INF("oom_score", S_IRUGO, oom_score),
2545 REG("oom_adj", S_IRUGO|S_IWUSR, oom_adjust),
2546 #ifdef CONFIG_AUDITSYSCALL
2547 REG("loginuid", S_IWUSR|S_IRUGO, loginuid),
2548 #endif
2549 #ifdef CONFIG_FAULT_INJECTION
2550 REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
2551 #endif
2552 };
2553
2554 static int proc_tid_base_readdir(struct file * filp,
2555 void * dirent, filldir_t filldir)
2556 {
2557 return proc_pident_readdir(filp,dirent,filldir,
2558 tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
2559 }
2560
2561 static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
2562 return proc_pident_lookup(dir, dentry,
2563 tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
2564 }
2565
2566 static const struct file_operations proc_tid_base_operations = {
2567 .read = generic_read_dir,
2568 .readdir = proc_tid_base_readdir,
2569 };
2570
2571 static const struct inode_operations proc_tid_base_inode_operations = {
2572 .lookup = proc_tid_base_lookup,
2573 .getattr = pid_getattr,
2574 .setattr = proc_setattr,
2575 };
2576
2577 static struct dentry *proc_task_instantiate(struct inode *dir,
2578 struct dentry *dentry, struct task_struct *task, const void *ptr)
2579 {
2580 struct dentry *error = ERR_PTR(-ENOENT);
2581 struct inode *inode;
2582 inode = proc_pid_make_inode(dir->i_sb, task);
2583
2584 if (!inode)
2585 goto out;
2586 inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
2587 inode->i_op = &proc_tid_base_inode_operations;
2588 inode->i_fop = &proc_tid_base_operations;
2589 inode->i_flags|=S_IMMUTABLE;
2590 inode->i_nlink = 4;
2591 #ifdef CONFIG_SECURITY
2592 inode->i_nlink += 1;
2593 #endif
2594
2595 dentry->d_op = &pid_dentry_operations;
2596
2597 d_add(dentry, inode);
2598 /* Close the race of the process dying before we return the dentry */
2599 if (pid_revalidate(dentry, NULL))
2600 error = NULL;
2601 out:
2602 return error;
2603 }
2604
2605 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
2606 {
2607 struct dentry *result = ERR_PTR(-ENOENT);
2608 struct task_struct *task;
2609 struct task_struct *leader = get_proc_task(dir);
2610 unsigned tid;
2611 struct pid_namespace *ns;
2612
2613 if (!leader)
2614 goto out_no_task;
2615
2616 tid = name_to_int(dentry);
2617 if (tid == ~0U)
2618 goto out;
2619
2620 ns = dentry->d_sb->s_fs_info;
2621 rcu_read_lock();
2622 task = find_task_by_pid_ns(tid, ns);
2623 if (task)
2624 get_task_struct(task);
2625 rcu_read_unlock();
2626 if (!task)
2627 goto out;
2628 if (!same_thread_group(leader, task))
2629 goto out_drop_task;
2630
2631 result = proc_task_instantiate(dir, dentry, task, NULL);
2632 out_drop_task:
2633 put_task_struct(task);
2634 out:
2635 put_task_struct(leader);
2636 out_no_task:
2637 return result;
2638 }
2639
2640 /*
2641 * Find the first tid of a thread group to return to user space.
2642 *
2643 * Usually this is just the thread group leader, but if the users
2644 * buffer was too small or there was a seek into the middle of the
2645 * directory we have more work todo.
2646 *
2647 * In the case of a short read we start with find_task_by_pid.
2648 *
2649 * In the case of a seek we start with the leader and walk nr
2650 * threads past it.
2651 */
2652 static struct task_struct *first_tid(struct task_struct *leader,
2653 int tid, int nr, struct pid_namespace *ns)
2654 {
2655 struct task_struct *pos;
2656
2657 rcu_read_lock();
2658 /* Attempt to start with the pid of a thread */
2659 if (tid && (nr > 0)) {
2660 pos = find_task_by_pid_ns(tid, ns);
2661 if (pos && (pos->group_leader == leader))
2662 goto found;
2663 }
2664
2665 /* If nr exceeds the number of threads there is nothing todo */
2666 pos = NULL;
2667 if (nr && nr >= get_nr_threads(leader))
2668 goto out;
2669
2670 /* If we haven't found our starting place yet start
2671 * with the leader and walk nr threads forward.
2672 */
2673 for (pos = leader; nr > 0; --nr) {
2674 pos = next_thread(pos);
2675 if (pos == leader) {
2676 pos = NULL;
2677 goto out;
2678 }
2679 }
2680 found:
2681 get_task_struct(pos);
2682 out:
2683 rcu_read_unlock();
2684 return pos;
2685 }
2686
2687 /*
2688 * Find the next thread in the thread list.
2689 * Return NULL if there is an error or no next thread.
2690 *
2691 * The reference to the input task_struct is released.
2692 */
2693 static struct task_struct *next_tid(struct task_struct *start)
2694 {
2695 struct task_struct *pos = NULL;
2696 rcu_read_lock();
2697 if (pid_alive(start)) {
2698 pos = next_thread(start);
2699 if (thread_group_leader(pos))
2700 pos = NULL;
2701 else
2702 get_task_struct(pos);
2703 }
2704 rcu_read_unlock();
2705 put_task_struct(start);
2706 return pos;
2707 }
2708
2709 static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
2710 struct task_struct *task, int tid)
2711 {
2712 char name[PROC_NUMBUF];
2713 int len = snprintf(name, sizeof(name), "%d", tid);
2714 return proc_fill_cache(filp, dirent, filldir, name, len,
2715 proc_task_instantiate, task, NULL);
2716 }
2717
2718 /* for the /proc/TGID/task/ directories */
2719 static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
2720 {
2721 struct dentry *dentry = filp->f_path.dentry;
2722 struct inode *inode = dentry->d_inode;
2723 struct task_struct *leader = NULL;
2724 struct task_struct *task;
2725 int retval = -ENOENT;
2726 ino_t ino;
2727 int tid;
2728 unsigned long pos = filp->f_pos; /* avoiding "long long" filp->f_pos */
2729 struct pid_namespace *ns;
2730
2731 task = get_proc_task(inode);
2732 if (!task)
2733 goto out_no_task;
2734 rcu_read_lock();
2735 if (pid_alive(task)) {
2736 leader = task->group_leader;
2737 get_task_struct(leader);
2738 }
2739 rcu_read_unlock();
2740 put_task_struct(task);
2741 if (!leader)
2742 goto out_no_task;
2743 retval = 0;
2744
2745 switch (pos) {
2746 case 0:
2747 ino = inode->i_ino;
2748 if (filldir(dirent, ".", 1, pos, ino, DT_DIR) < 0)
2749 goto out;
2750 pos++;
2751 /* fall through */
2752 case 1:
2753 ino = parent_ino(dentry);
2754 if (filldir(dirent, "..", 2, pos, ino, DT_DIR) < 0)
2755 goto out;
2756 pos++;
2757 /* fall through */
2758 }
2759
2760 /* f_version caches the tgid value that the last readdir call couldn't
2761 * return. lseek aka telldir automagically resets f_version to 0.
2762 */
2763 ns = filp->f_dentry->d_sb->s_fs_info;
2764 tid = (int)filp->f_version;
2765 filp->f_version = 0;
2766 for (task = first_tid(leader, tid, pos - 2, ns);
2767 task;
2768 task = next_tid(task), pos++) {
2769 tid = task_pid_nr_ns(task, ns);
2770 if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) {
2771 /* returning this tgid failed, save it as the first
2772 * pid for the next readir call */
2773 filp->f_version = (u64)tid;
2774 put_task_struct(task);
2775 break;
2776 }
2777 }
2778 out:
2779 filp->f_pos = pos;
2780 put_task_struct(leader);
2781 out_no_task:
2782 return retval;
2783 }
2784
2785 static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
2786 {
2787 struct inode *inode = dentry->d_inode;
2788 struct task_struct *p = get_proc_task(inode);
2789 generic_fillattr(inode, stat);
2790
2791 if (p) {
2792 rcu_read_lock();
2793 stat->nlink += get_nr_threads(p);
2794 rcu_read_unlock();
2795 put_task_struct(p);
2796 }
2797
2798 return 0;
2799 }
2800
2801 static const struct inode_operations proc_task_inode_operations = {
2802 .lookup = proc_task_lookup,
2803 .getattr = proc_task_getattr,
2804 .setattr = proc_setattr,
2805 };
2806
2807 static const struct file_operations proc_task_operations = {
2808 .read = generic_read_dir,
2809 .readdir = proc_task_readdir,
2810 };
Linux kernel - Deliverables
This page took 0.105032 seconds and 6 git commands to generate.