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