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