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