4012 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * linux/fs/proc/base.c4 *5 * Copyright (C) 1991, 1992 Linus Torvalds6 *7 * proc base directory handling functions8 *9 * 1999, Al Viro. Rewritten. Now it covers the whole per-process part.10 * Instead of using magical inumbers to determine the kind of object11 * we allocate and fill in-core inodes upon lookup. They don't even12 * 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 the14 * rest of procfs anymore.15 *16 *17 * Changelog:18 * 17-Jan-200519 * Allan Bezerra20 * 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 - INdT26 *27 * A new process specific entry (smaps) included in /proc. It shows the28 * size of rss for each memory area. The maps entry lacks information29 * 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 know32 * about physical memory consumption for a process specific library.33 *34 * Changelog:35 * 21-Feb-200536 * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT37 * Pud inclusion in the page table walking.38 *39 * ChangeLog:40 * 10-Mar-200541 * 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/generic-radix-tree.h>63#include <linux/string.h>64#include <linux/seq_file.h>65#include <linux/namei.h>66#include <linux/mnt_namespace.h>67#include <linux/mm.h>68#include <linux/swap.h>69#include <linux/rcupdate.h>70#include <linux/kallsyms.h>71#include <linux/stacktrace.h>72#include <linux/resource.h>73#include <linux/module.h>74#include <linux/mount.h>75#include <linux/security.h>76#include <linux/ptrace.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_parser.h>89#include <linux/fs_struct.h>90#include <linux/slab.h>91#include <linux/sched/autogroup.h>92#include <linux/sched/mm.h>93#include <linux/sched/coredump.h>94#include <linux/sched/debug.h>95#include <linux/sched/stat.h>96#include <linux/posix-timers.h>97#include <linux/time_namespace.h>98#include <linux/resctrl.h>99#include <linux/cn_proc.h>100#include <linux/ksm.h>101#include <uapi/linux/lsm.h>102#include <trace/events/oom.h>103#include "internal.h"104#include "fd.h"105 106#include "../../lib/kstrtox.h"107 108/* NOTE:109 * Implementing inode permission operations in /proc is almost110 * certainly an error. Permission checks need to happen during111 * each system call not at open time. The reason is that most of112 * what we wish to check for permissions in /proc varies at runtime.113 *114 * The classic example of a problem is opening file descriptors115 * in /proc for a task before it execs a suid executable.116 */117 118static u8 nlink_tid __ro_after_init;119static u8 nlink_tgid __ro_after_init;120 121enum proc_mem_force {122 PROC_MEM_FORCE_ALWAYS,123 PROC_MEM_FORCE_PTRACE,124 PROC_MEM_FORCE_NEVER125};126 127static enum proc_mem_force proc_mem_force_override __ro_after_init =128 IS_ENABLED(CONFIG_PROC_MEM_NO_FORCE) ? PROC_MEM_FORCE_NEVER :129 IS_ENABLED(CONFIG_PROC_MEM_FORCE_PTRACE) ? PROC_MEM_FORCE_PTRACE :130 PROC_MEM_FORCE_ALWAYS;131 132static const struct constant_table proc_mem_force_table[] __initconst = {133 { "always", PROC_MEM_FORCE_ALWAYS },134 { "ptrace", PROC_MEM_FORCE_PTRACE },135 { "never", PROC_MEM_FORCE_NEVER },136 { }137};138 139static int __init early_proc_mem_force_override(char *buf)140{141 if (!buf)142 return -EINVAL;143 144 /*145 * lookup_constant() defaults to proc_mem_force_override to preseve146 * the initial Kconfig choice in case an invalid param gets passed.147 */148 proc_mem_force_override = lookup_constant(proc_mem_force_table,149 buf, proc_mem_force_override);150 151 return 0;152}153early_param("proc_mem.force_override", early_proc_mem_force_override);154 155struct pid_entry {156 const char *name;157 unsigned int len;158 umode_t mode;159 const struct inode_operations *iop;160 const struct file_operations *fop;161 union proc_op op;162};163 164#define NOD(NAME, MODE, IOP, FOP, OP) { \165 .name = (NAME), \166 .len = sizeof(NAME) - 1, \167 .mode = MODE, \168 .iop = IOP, \169 .fop = FOP, \170 .op = OP, \171}172 173#define DIR(NAME, MODE, iops, fops) \174 NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} )175#define LNK(NAME, get_link) \176 NOD(NAME, (S_IFLNK|S_IRWXUGO), \177 &proc_pid_link_inode_operations, NULL, \178 { .proc_get_link = get_link } )179#define REG(NAME, MODE, fops) \180 NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {})181#define ONE(NAME, MODE, show) \182 NOD(NAME, (S_IFREG|(MODE)), \183 NULL, &proc_single_file_operations, \184 { .proc_show = show } )185#define ATTR(LSMID, NAME, MODE) \186 NOD(NAME, (S_IFREG|(MODE)), \187 NULL, &proc_pid_attr_operations, \188 { .lsmid = LSMID })189 190/*191 * Count the number of hardlinks for the pid_entry table, excluding the .192 * and .. links.193 */194static unsigned int __init pid_entry_nlink(const struct pid_entry *entries,195 unsigned int n)196{197 unsigned int i;198 unsigned int count;199 200 count = 2;201 for (i = 0; i < n; ++i) {202 if (S_ISDIR(entries[i].mode))203 ++count;204 }205 206 return count;207}208 209static int get_task_root(struct task_struct *task, struct path *root)210{211 int result = -ENOENT;212 213 task_lock(task);214 if (task->fs) {215 get_fs_root(task->fs, root);216 result = 0;217 }218 task_unlock(task);219 return result;220}221 222static HWJS_SUSPENDS int proc_cwd_link(struct dentry *dentry, struct path *path)223{224 struct task_struct *task = get_proc_task(d_inode(dentry));225 int result = -ENOENT;226 227 if (task) {228 task_lock(task);229 if (task->fs) {230 get_fs_pwd(task->fs, path);231 result = 0;232 }233 task_unlock(task);234 put_task_struct(task);235 }236 return result;237}238 239static HWJS_SUSPENDS int proc_root_link(struct dentry *dentry, struct path *path)240{241 struct task_struct *task = get_proc_task(d_inode(dentry));242 int result = -ENOENT;243 244 if (task) {245 result = get_task_root(task, path);246 put_task_struct(task);247 }248 return result;249}250 251/*252 * If the user used setproctitle(), we just get the string from253 * user space at arg_start, and limit it to a maximum of one page.254 */255static ssize_t get_mm_proctitle(struct mm_struct *mm, char __user *buf,256 size_t count, unsigned long pos,257 unsigned long arg_start)258{259 char *page;260 int ret, got;261 262 if (pos >= PAGE_SIZE)263 return 0;264 265 page = (char *)__get_free_page(GFP_KERNEL);266 if (!page)267 return -ENOMEM;268 269 ret = 0;270 got = access_remote_vm(mm, arg_start, page, PAGE_SIZE, FOLL_ANON);271 if (got > 0) {272 int len = strnlen(page, got);273 274 /* Include the NUL character if it was found */275 if (len < got)276 len++;277 278 if (len > pos) {279 len -= pos;280 if (len > count)281 len = count;282 len -= copy_to_user(buf, page+pos, len);283 if (!len)284 len = -EFAULT;285 ret = len;286 }287 }288 free_page((unsigned long)page);289 return ret;290}291 292static ssize_t get_mm_cmdline(struct mm_struct *mm, char __user *buf,293 size_t count, loff_t *ppos)294{295 unsigned long arg_start, arg_end, env_start, env_end;296 unsigned long pos, len;297 char *page, c;298 299 /* Check if process spawned far enough to have cmdline. */300 if (!mm->env_end)301 return 0;302 303 spin_lock(&mm->arg_lock);304 arg_start = mm->arg_start;305 arg_end = mm->arg_end;306 env_start = mm->env_start;307 env_end = mm->env_end;308 spin_unlock(&mm->arg_lock);309 310 if (arg_start >= arg_end)311 return 0;312 313 /*314 * We allow setproctitle() to overwrite the argument315 * strings, and overflow past the original end. But316 * only when it overflows into the environment area.317 */318 if (env_start != arg_end || env_end < env_start)319 env_start = env_end = arg_end;320 len = env_end - arg_start;321 322 /* We're not going to care if "*ppos" has high bits set */323 pos = *ppos;324 if (pos >= len)325 return 0;326 if (count > len - pos)327 count = len - pos;328 if (!count)329 return 0;330 331 /*332 * Magical special case: if the argv[] end byte is not333 * zero, the user has overwritten it with setproctitle(3).334 *335 * Possible future enhancement: do this only once when336 * pos is 0, and set a flag in the 'struct file'.337 */338 if (access_remote_vm(mm, arg_end-1, &c, 1, FOLL_ANON) == 1 && c)339 return get_mm_proctitle(mm, buf, count, pos, arg_start);340 341 /*342 * For the non-setproctitle() case we limit things strictly343 * to the [arg_start, arg_end[ range.344 */345 pos += arg_start;346 if (pos < arg_start || pos >= arg_end)347 return 0;348 if (count > arg_end - pos)349 count = arg_end - pos;350 351 page = (char *)__get_free_page(GFP_KERNEL);352 if (!page)353 return -ENOMEM;354 355 len = 0;356 while (count) {357 int got;358 size_t size = min_t(size_t, PAGE_SIZE, count);359 360 got = access_remote_vm(mm, pos, page, size, FOLL_ANON);361 if (got <= 0)362 break;363 got -= copy_to_user(buf, page, got);364 if (unlikely(!got)) {365 if (!len)366 len = -EFAULT;367 break;368 }369 pos += got;370 buf += got;371 len += got;372 count -= got;373 }374 375 free_page((unsigned long)page);376 return len;377}378 379static ssize_t get_task_cmdline(struct task_struct *tsk, char __user *buf,380 size_t count, loff_t *pos)381{382 struct mm_struct *mm;383 ssize_t ret;384 385 mm = get_task_mm(tsk);386 if (!mm)387 return 0;388 389 ret = get_mm_cmdline(mm, buf, count, pos);390 mmput(mm);391 return ret;392}393 394static HWJS_SUSPENDS ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf,395 size_t count, loff_t *pos)396{397 struct task_struct *tsk;398 ssize_t ret;399 400 BUG_ON(*pos < 0);401 402 tsk = get_proc_task(file_inode(file));403 if (!tsk)404 return -ESRCH;405 ret = get_task_cmdline(tsk, buf, count, pos);406 put_task_struct(tsk);407 if (ret > 0)408 *pos += ret;409 return ret;410}411 412static const struct file_operations proc_pid_cmdline_ops = {413 .read = proc_pid_cmdline_read,414 .llseek = generic_file_llseek,415};416 417#ifdef CONFIG_KALLSYMS418/*419 * Provides a wchan file via kallsyms in a proper one-value-per-file format.420 * Returns the resolved symbol. If that fails, simply return the address.421 */422static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns,423 struct pid *pid, struct task_struct *task)424{425 unsigned long wchan;426 char symname[KSYM_NAME_LEN];427 428 if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))429 goto print0;430 431 wchan = get_wchan(task);432 if (wchan && !lookup_symbol_name(wchan, symname)) {433 seq_puts(m, symname);434 return 0;435 }436 437print0:438 seq_putc(m, '0');439 return 0;440}441#endif /* CONFIG_KALLSYMS */442 443static int lock_trace(struct task_struct *task)444{445 int err = down_read_killable(&task->signal->exec_update_lock);446 if (err)447 return err;448 if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) {449 up_read(&task->signal->exec_update_lock);450 return -EPERM;451 }452 return 0;453}454 455static HWJS_SUSPENDS void unlock_trace(struct task_struct *task)456{457 up_read(&task->signal->exec_update_lock);458}459 460#ifdef CONFIG_STACKTRACE461 462#define MAX_STACK_TRACE_DEPTH 64463 464static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,465 struct pid *pid, struct task_struct *task)466{467 unsigned long *entries;468 int err;469 470 /*471 * The ability to racily run the kernel stack unwinder on a running task472 * and then observe the unwinder output is scary; while it is useful for473 * debugging kernel issues, it can also allow an attacker to leak kernel474 * stack contents.475 * Doing this in a manner that is at least safe from races would require476 * some work to ensure that the remote task can not be scheduled; and477 * even then, this would still expose the unwinder as local attack478 * surface.479 * Therefore, this interface is restricted to root.480 */481 if (!file_ns_capable(m->file, &init_user_ns, CAP_SYS_ADMIN))482 return -EACCES;483 484 entries = kmalloc_array(MAX_STACK_TRACE_DEPTH, sizeof(*entries),485 GFP_KERNEL);486 if (!entries)487 return -ENOMEM;488 489 err = lock_trace(task);490 if (!err) {491 unsigned int i, nr_entries;492 493 nr_entries = stack_trace_save_tsk(task, entries,494 MAX_STACK_TRACE_DEPTH, 0);495 496 for (i = 0; i < nr_entries; i++) {497 seq_printf(m, "[<0>] %pB\n", (void *)entries[i]);498 }499 500 unlock_trace(task);501 }502 kfree(entries);503 504 return err;505}506#endif507 508#ifdef CONFIG_SCHED_INFO509/*510 * Provides /proc/PID/schedstat511 */512static int proc_pid_schedstat(struct seq_file *m, struct pid_namespace *ns,513 struct pid *pid, struct task_struct *task)514{515 if (unlikely(!sched_info_on()))516 seq_puts(m, "0 0 0\n");517 else518 seq_printf(m, "%llu %llu %lu\n",519 (unsigned long long)task->se.sum_exec_runtime,520 (unsigned long long)task->sched_info.run_delay,521 task->sched_info.pcount);522 523 return 0;524}525#endif526 527#ifdef CONFIG_LATENCYTOP528static int lstats_show_proc(struct seq_file *m, void *v)529{530 int i;531 struct inode *inode = m->private;532 struct task_struct *task = get_proc_task(inode);533 534 if (!task)535 return -ESRCH;536 seq_puts(m, "Latency Top version : v0.1\n");537 for (i = 0; i < LT_SAVECOUNT; i++) {538 struct latency_record *lr = &task->latency_record[i];539 if (lr->backtrace[0]) {540 int q;541 seq_printf(m, "%i %li %li",542 lr->count, lr->time, lr->max);543 for (q = 0; q < LT_BACKTRACEDEPTH; q++) {544 unsigned long bt = lr->backtrace[q];545 546 if (!bt)547 break;548 seq_printf(m, " %ps", (void *)bt);549 }550 seq_putc(m, '\n');551 }552 553 }554 put_task_struct(task);555 return 0;556}557 558static int lstats_open(struct inode *inode, struct file *file)559{560 return single_open(file, lstats_show_proc, inode);561}562 563static ssize_t lstats_write(struct file *file, const char __user *buf,564 size_t count, loff_t *offs)565{566 struct task_struct *task = get_proc_task(file_inode(file));567 568 if (!task)569 return -ESRCH;570 clear_tsk_latency_tracing(task);571 put_task_struct(task);572 573 return count;574}575 576static const struct file_operations proc_lstats_operations = {577 .open = lstats_open,578 .read = seq_read,579 .write = lstats_write,580 .llseek = seq_lseek,581 .release = single_release,582};583 584#endif585 586static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns,587 struct pid *pid, struct task_struct *task)588{589 unsigned long totalpages = totalram_pages() + total_swap_pages;590 unsigned long points = 0;591 long badness;592 593 badness = oom_badness(task, totalpages);594 /*595 * Special case OOM_SCORE_ADJ_MIN for all others scale the596 * badness value into [0, 2000] range which we have been597 * exporting for a long time so userspace might depend on it.598 */599 if (badness != LONG_MIN)600 points = (1000 + badness * 1000 / (long)totalpages) * 2 / 3;601 602 seq_printf(m, "%lu\n", points);603 604 return 0;605}606 607struct limit_names {608 const char *name;609 const char *unit;610};611 612static const struct limit_names lnames[RLIM_NLIMITS] = {613 [RLIMIT_CPU] = {"Max cpu time", "seconds"},614 [RLIMIT_FSIZE] = {"Max file size", "bytes"},615 [RLIMIT_DATA] = {"Max data size", "bytes"},616 [RLIMIT_STACK] = {"Max stack size", "bytes"},617 [RLIMIT_CORE] = {"Max core file size", "bytes"},618 [RLIMIT_RSS] = {"Max resident set", "bytes"},619 [RLIMIT_NPROC] = {"Max processes", "processes"},620 [RLIMIT_NOFILE] = {"Max open files", "files"},621 [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},622 [RLIMIT_AS] = {"Max address space", "bytes"},623 [RLIMIT_LOCKS] = {"Max file locks", "locks"},624 [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},625 [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},626 [RLIMIT_NICE] = {"Max nice priority", NULL},627 [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},628 [RLIMIT_RTTIME] = {"Max realtime timeout", "us"},629};630 631/* Display limits for a process */632static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns,633 struct pid *pid, struct task_struct *task)634{635 unsigned int i;636 unsigned long flags;637 638 struct rlimit rlim[RLIM_NLIMITS];639 640 if (!lock_task_sighand(task, &flags))641 return 0;642 memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);643 unlock_task_sighand(task, &flags);644 645 /*646 * print the file header647 */648 seq_puts(m, "Limit "649 "Soft Limit "650 "Hard Limit "651 "Units \n");652 653 for (i = 0; i < RLIM_NLIMITS; i++) {654 if (rlim[i].rlim_cur == RLIM_INFINITY)655 seq_printf(m, "%-25s %-20s ",656 lnames[i].name, "unlimited");657 else658 seq_printf(m, "%-25s %-20lu ",659 lnames[i].name, rlim[i].rlim_cur);660 661 if (rlim[i].rlim_max == RLIM_INFINITY)662 seq_printf(m, "%-20s ", "unlimited");663 else664 seq_printf(m, "%-20lu ", rlim[i].rlim_max);665 666 if (lnames[i].unit)667 seq_printf(m, "%-10s\n", lnames[i].unit);668 else669 seq_putc(m, '\n');670 }671 672 return 0;673}674 675#ifdef CONFIG_HAVE_ARCH_TRACEHOOK676static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns,677 struct pid *pid, struct task_struct *task)678{679 struct syscall_info info;680 u64 *args = &info.data.args[0];681 int res;682 683 res = lock_trace(task);684 if (res)685 return res;686 687 if (task_current_syscall(task, &info))688 seq_puts(m, "running\n");689 else if (info.data.nr < 0)690 seq_printf(m, "%d 0x%llx 0x%llx\n",691 info.data.nr, info.sp, info.data.instruction_pointer);692 else693 seq_printf(m,694 "%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",695 info.data.nr,696 args[0], args[1], args[2], args[3], args[4], args[5],697 info.sp, info.data.instruction_pointer);698 unlock_trace(task);699 700 return 0;701}702#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */703 704/************************************************************************/705/* Here the fs part begins */706/************************************************************************/707 708/* permission checks */709static bool proc_fd_access_allowed(struct inode *inode)710{711 struct task_struct *task;712 bool allowed = false;713 /* Allow access to a task's file descriptors if it is us or we714 * may use ptrace attach to the process and find out that715 * information.716 */717 task = get_proc_task(inode);718 if (task) {719 allowed = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);720 put_task_struct(task);721 }722 return allowed;723}724 725int proc_setattr(struct mnt_idmap *idmap, struct dentry *dentry,726 struct iattr *attr)727{728 int error;729 struct inode *inode = d_inode(dentry);730 731 if (attr->ia_valid & ATTR_MODE)732 return -EPERM;733 734 error = setattr_prepare(&nop_mnt_idmap, dentry, attr);735 if (error)736 return error;737 738 setattr_copy(&nop_mnt_idmap, inode, attr);739 return 0;740}741 742/*743 * May current process learn task's sched/cmdline info (for hide_pid_min=1)744 * or euid/egid (for hide_pid_min=2)?745 */746static bool has_pid_permissions(struct proc_fs_info *fs_info,747 struct task_struct *task,748 enum proc_hidepid hide_pid_min)749{750 /*751 * If 'hidpid' mount option is set force a ptrace check,752 * we indicate that we are using a filesystem syscall753 * by passing PTRACE_MODE_READ_FSCREDS754 */755 if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE)756 return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);757 758 if (fs_info->hide_pid < hide_pid_min)759 return true;760 if (in_group_p(fs_info->pid_gid))761 return true;762 return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);763}764 765 766static HWJS_SUSPENDS int proc_pid_permission(struct mnt_idmap *idmap,767 struct inode *inode, int mask)768{769 struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);770 struct task_struct *task;771 bool has_perms;772 773 task = get_proc_task(inode);774 if (!task)775 return -ESRCH;776 has_perms = has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS);777 put_task_struct(task);778 779 if (!has_perms) {780 if (fs_info->hide_pid == HIDEPID_INVISIBLE) {781 /*782 * Let's make getdents(), stat(), and open()783 * consistent with each other. If a process784 * may not stat() a file, it shouldn't be seen785 * in procfs at all.786 */787 return -ENOENT;788 }789 790 return -EPERM;791 }792 return generic_permission(&nop_mnt_idmap, inode, mask);793}794 795 796 797static const struct inode_operations proc_def_inode_operations = {798 .setattr = proc_setattr,799};800 801static HWJS_SUSPENDS int proc_single_show(struct seq_file *m, void *v)802{803 struct inode *inode = m->private;804 struct pid_namespace *ns = proc_pid_ns(inode->i_sb);805 struct pid *pid = proc_pid(inode);806 struct task_struct *task;807 int ret;808 809 task = get_pid_task(pid, PIDTYPE_PID);810 if (!task)811 return -ESRCH;812 813 ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);814 815 put_task_struct(task);816 return ret;817}818 819static int proc_single_open(struct inode *inode, struct file *filp)820{821 return single_open(filp, proc_single_show, inode);822}823 824static const struct file_operations proc_single_file_operations = {825 .open = proc_single_open,826 .read = seq_read,827 .llseek = seq_lseek,828 .release = single_release,829};830 831 832struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode)833{834 struct task_struct *task = get_proc_task(inode);835 struct mm_struct *mm = ERR_PTR(-ESRCH);836 837 if (task) {838 mm = mm_access(task, mode | PTRACE_MODE_FSCREDS);839 put_task_struct(task);840 841 if (!IS_ERR_OR_NULL(mm)) {842 /* ensure this mm_struct can't be freed */843 mmgrab(mm);844 /* but do not pin its memory */845 mmput(mm);846 }847 }848 849 return mm;850}851 852static HWJS_SUSPENDS int __mem_open(struct inode *inode, struct file *file, unsigned int mode)853{854 struct mm_struct *mm = proc_mem_open(inode, mode);855 856 if (IS_ERR(mm))857 return PTR_ERR(mm);858 859 file->private_data = mm;860 return 0;861}862 863static HWJS_SUSPENDS int mem_open(struct inode *inode, struct file *file)864{865 if (WARN_ON_ONCE(!(file->f_op->fop_flags & FOP_UNSIGNED_OFFSET)))866 return -EINVAL;867 return __mem_open(inode, file, PTRACE_MODE_ATTACH);868}869 870static HWJS_SUSPENDS bool proc_mem_foll_force(struct file *file, struct mm_struct *mm)871{872 struct task_struct *task;873 bool ptrace_active = false;874 875 switch (proc_mem_force_override) {876 case PROC_MEM_FORCE_NEVER:877 return false;878 case PROC_MEM_FORCE_PTRACE:879 task = get_proc_task(file_inode(file));880 if (task) {881 ptrace_active = READ_ONCE(task->ptrace) &&882 READ_ONCE(task->mm) == mm &&883 READ_ONCE(task->parent) == current;884 put_task_struct(task);885 }886 return ptrace_active;887 default:888 return true;889 }890}891 892static HWJS_SUSPENDS ssize_t mem_rw(struct file *file, char __user *buf,893 size_t count, loff_t *ppos, int write)894{895 struct mm_struct *mm = file->private_data;896 unsigned long addr = *ppos;897 ssize_t copied;898 char *page;899 unsigned int flags;900 901 if (!mm)902 return 0;903 904 page = (char *)__get_free_page(GFP_KERNEL);905 if (!page)906 return -ENOMEM;907 908 copied = 0;909 if (!mmget_not_zero(mm))910 goto free;911 912 flags = write ? FOLL_WRITE : 0;913 if (proc_mem_foll_force(file, mm))914 flags |= FOLL_FORCE;915 916 while (count > 0) {917 size_t this_len = min_t(size_t, count, PAGE_SIZE);918 919 if (write && copy_from_user(page, buf, this_len)) {920 copied = -EFAULT;921 break;922 }923 924 this_len = access_remote_vm(mm, addr, page, this_len, flags);925 if (!this_len) {926 if (!copied)927 copied = -EIO;928 break;929 }930 931 if (!write && copy_to_user(buf, page, this_len)) {932 copied = -EFAULT;933 break;934 }935 936 buf += this_len;937 addr += this_len;938 copied += this_len;939 count -= this_len;940 }941 *ppos = addr;942 943 mmput(mm);944free:945 free_page((unsigned long) page);946 return copied;947}948 949static HWJS_SUSPENDS ssize_t mem_read(struct file *file, char __user *buf,950 size_t count, loff_t *ppos)951{952 return mem_rw(file, buf, count, ppos, 0);953}954 955static HWJS_SUSPENDS ssize_t mem_write(struct file *file, const char __user *buf,956 size_t count, loff_t *ppos)957{958 return mem_rw(file, (char __user*)buf, count, ppos, 1);959}960 961loff_t mem_lseek(struct file *file, loff_t offset, int orig)962{963 switch (orig) {964 case 0:965 file->f_pos = offset;966 break;967 case 1:968 file->f_pos += offset;969 break;970 default:971 return -EINVAL;972 }973 force_successful_syscall_return();974 return file->f_pos;975}976 977static int mem_release(struct inode *inode, struct file *file)978{979 struct mm_struct *mm = file->private_data;980 if (mm)981 mmdrop(mm);982 return 0;983}984 985static const struct file_operations proc_mem_operations = {986 .llseek = mem_lseek,987 .read = mem_read,988 .write = mem_write,989 .open = mem_open,990 .release = mem_release,991 .fop_flags = FOP_UNSIGNED_OFFSET,992};993 994static HWJS_SUSPENDS int environ_open(struct inode *inode, struct file *file)995{996 return __mem_open(inode, file, PTRACE_MODE_READ);997}998 999static ssize_t environ_read(struct file *file, char __user *buf,1000 size_t count, loff_t *ppos)1001{1002 char *page;1003 unsigned long src = *ppos;1004 int ret = 0;1005 struct mm_struct *mm = file->private_data;1006 unsigned long env_start, env_end;1007 1008 /* Ensure the process spawned far enough to have an environment. */1009 if (!mm || !mm->env_end)1010 return 0;1011 1012 page = (char *)__get_free_page(GFP_KERNEL);1013 if (!page)1014 return -ENOMEM;1015 1016 ret = 0;1017 if (!mmget_not_zero(mm))1018 goto free;1019 1020 spin_lock(&mm->arg_lock);1021 env_start = mm->env_start;1022 env_end = mm->env_end;1023 spin_unlock(&mm->arg_lock);1024 1025 while (count > 0) {1026 size_t this_len, max_len;1027 int retval;1028 1029 if (src >= (env_end - env_start))1030 break;1031 1032 this_len = env_end - (env_start + src);1033 1034 max_len = min_t(size_t, PAGE_SIZE, count);1035 this_len = min(max_len, this_len);1036 1037 retval = access_remote_vm(mm, (env_start + src), page, this_len, FOLL_ANON);1038 1039 if (retval <= 0) {1040 ret = retval;1041 break;1042 }1043 1044 if (copy_to_user(buf, page, retval)) {1045 ret = -EFAULT;1046 break;1047 }1048 1049 ret += retval;1050 src += retval;1051 buf += retval;1052 count -= retval;1053 }1054 *ppos = src;1055 mmput(mm);1056 1057free:1058 free_page((unsigned long) page);1059 return ret;1060}1061 1062static const struct file_operations proc_environ_operations = {1063 .open = environ_open,1064 .read = environ_read,1065 .llseek = generic_file_llseek,1066 .release = mem_release,1067};1068 1069static HWJS_SUSPENDS int auxv_open(struct inode *inode, struct file *file)1070{1071 return __mem_open(inode, file, PTRACE_MODE_READ_FSCREDS);1072}1073 1074static ssize_t auxv_read(struct file *file, char __user *buf,1075 size_t count, loff_t *ppos)1076{1077 struct mm_struct *mm = file->private_data;1078 unsigned int nwords = 0;1079 1080 if (!mm)1081 return 0;1082 do {1083 nwords += 2;1084 } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */1085 return simple_read_from_buffer(buf, count, ppos, mm->saved_auxv,1086 nwords * sizeof(mm->saved_auxv[0]));1087}1088 1089static const struct file_operations proc_auxv_operations = {1090 .open = auxv_open,1091 .read = auxv_read,1092 .llseek = generic_file_llseek,1093 .release = mem_release,1094};1095 1096static HWJS_SUSPENDS ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,1097 loff_t *ppos)1098{1099 struct task_struct *task = get_proc_task(file_inode(file));1100 char buffer[PROC_NUMBUF];1101 int oom_adj = OOM_ADJUST_MIN;1102 size_t len;1103 1104 if (!task)1105 return -ESRCH;1106 if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX)1107 oom_adj = OOM_ADJUST_MAX;1108 else1109 oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) /1110 OOM_SCORE_ADJ_MAX;1111 put_task_struct(task);1112 if (oom_adj > OOM_ADJUST_MAX)1113 oom_adj = OOM_ADJUST_MAX;1114 len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj);1115 return simple_read_from_buffer(buf, count, ppos, buffer, len);1116}1117 1118static HWJS_SUSPENDS int __set_oom_adj(struct file *file, int oom_adj, bool legacy)1119{1120 struct mm_struct *mm = NULL;1121 struct task_struct *task;1122 int err = 0;1123 1124 task = get_proc_task(file_inode(file));1125 if (!task)1126 return -ESRCH;1127 1128 mutex_lock(&oom_adj_mutex);1129 if (legacy) {1130 if (oom_adj < task->signal->oom_score_adj &&1131 !capable(CAP_SYS_RESOURCE)) {1132 err = -EACCES;1133 goto err_unlock;1134 }1135 /*1136 * /proc/pid/oom_adj is provided for legacy purposes, ask users to use1137 * /proc/pid/oom_score_adj instead.1138 */1139 pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",1140 current->comm, task_pid_nr(current), task_pid_nr(task),1141 task_pid_nr(task));1142 } else {1143 if ((short)oom_adj < task->signal->oom_score_adj_min &&1144 !capable(CAP_SYS_RESOURCE)) {1145 err = -EACCES;1146 goto err_unlock;1147 }1148 }1149 1150 /*1151 * Make sure we will check other processes sharing the mm if this is1152 * not vfrok which wants its own oom_score_adj.1153 * pin the mm so it doesn't go away and get reused after task_unlock1154 */1155 if (!task->vfork_done) {1156 struct task_struct *p = find_lock_task_mm(task);1157 1158 if (p) {1159 if (test_bit(MMF_MULTIPROCESS, &p->mm->flags)) {1160 mm = p->mm;1161 mmgrab(mm);1162 }1163 task_unlock(p);1164 }1165 }1166 1167 task->signal->oom_score_adj = oom_adj;1168 if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE))1169 task->signal->oom_score_adj_min = (short)oom_adj;1170 trace_oom_score_adj_update(task);1171 1172 if (mm) {1173 struct task_struct *p;1174 1175 rcu_read_lock();1176 for_each_process(p) {1177 if (same_thread_group(task, p))1178 continue;1179 1180 /* do not touch kernel threads or the global init */1181 if (p->flags & PF_KTHREAD || is_global_init(p))1182 continue;1183 1184 task_lock(p);1185 if (!p->vfork_done && process_shares_mm(p, mm)) {1186 p->signal->oom_score_adj = oom_adj;1187 if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE))1188 p->signal->oom_score_adj_min = (short)oom_adj;1189 }1190 task_unlock(p);1191 }1192 rcu_read_unlock();1193 mmdrop(mm);1194 }1195err_unlock:1196 mutex_unlock(&oom_adj_mutex);1197 put_task_struct(task);1198 return err;1199}1200 1201/*1202 * /proc/pid/oom_adj exists solely for backwards compatibility with previous1203 * kernels. The effective policy is defined by oom_score_adj, which has a1204 * different scale: oom_adj grew exponentially and oom_score_adj grows linearly.1205 * Values written to oom_adj are simply mapped linearly to oom_score_adj.1206 * Processes that become oom disabled via oom_adj will still be oom disabled1207 * with this implementation.1208 *1209 * oom_adj cannot be removed since existing userspace binaries use it.1210 */1211static HWJS_SUSPENDS ssize_t oom_adj_write(struct file *file, const char __user *buf,1212 size_t count, loff_t *ppos)1213{1214 char buffer[PROC_NUMBUF] = {};1215 int oom_adj;1216 int err;1217 1218 if (count > sizeof(buffer) - 1)1219 count = sizeof(buffer) - 1;1220 if (copy_from_user(buffer, buf, count)) {1221 err = -EFAULT;1222 goto out;1223 }1224 1225 err = kstrtoint(strstrip(buffer), 0, &oom_adj);1226 if (err)1227 goto out;1228 if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) &&1229 oom_adj != OOM_DISABLE) {1230 err = -EINVAL;1231 goto out;1232 }1233 1234 /*1235 * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum1236 * value is always attainable.1237 */1238 if (oom_adj == OOM_ADJUST_MAX)1239 oom_adj = OOM_SCORE_ADJ_MAX;1240 else1241 oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;1242 1243 err = __set_oom_adj(file, oom_adj, true);1244out:1245 return err < 0 ? err : count;1246}1247 1248static const struct file_operations proc_oom_adj_operations = {1249 .read = oom_adj_read,1250 .write = oom_adj_write,1251 .llseek = generic_file_llseek,1252};1253 1254static HWJS_SUSPENDS ssize_t oom_score_adj_read(struct file *file, char __user *buf,1255 size_t count, loff_t *ppos)1256{1257 struct task_struct *task = get_proc_task(file_inode(file));1258 char buffer[PROC_NUMBUF];1259 short oom_score_adj = OOM_SCORE_ADJ_MIN;1260 size_t len;1261 1262 if (!task)1263 return -ESRCH;1264 oom_score_adj = task->signal->oom_score_adj;1265 put_task_struct(task);1266 len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj);1267 return simple_read_from_buffer(buf, count, ppos, buffer, len);1268}1269 1270static HWJS_SUSPENDS ssize_t oom_score_adj_write(struct file *file, const char __user *buf,1271 size_t count, loff_t *ppos)1272{1273 char buffer[PROC_NUMBUF] = {};1274 int oom_score_adj;1275 int err;1276 1277 if (count > sizeof(buffer) - 1)1278 count = sizeof(buffer) - 1;1279 if (copy_from_user(buffer, buf, count)) {1280 err = -EFAULT;1281 goto out;1282 }1283 1284 err = kstrtoint(strstrip(buffer), 0, &oom_score_adj);1285 if (err)1286 goto out;1287 if (oom_score_adj < OOM_SCORE_ADJ_MIN ||1288 oom_score_adj > OOM_SCORE_ADJ_MAX) {1289 err = -EINVAL;1290 goto out;1291 }1292 1293 err = __set_oom_adj(file, oom_score_adj, false);1294out:1295 return err < 0 ? err : count;1296}1297 1298static const struct file_operations proc_oom_score_adj_operations = {1299 .read = oom_score_adj_read,1300 .write = oom_score_adj_write,1301 .llseek = default_llseek,1302};1303 1304#ifdef CONFIG_AUDIT1305#define TMPBUFLEN 111306static ssize_t proc_loginuid_read(struct file * file, char __user * buf,1307 size_t count, loff_t *ppos)1308{1309 struct inode * inode = file_inode(file);1310 struct task_struct *task = get_proc_task(inode);1311 ssize_t length;1312 char tmpbuf[TMPBUFLEN];1313 1314 if (!task)1315 return -ESRCH;1316 length = scnprintf(tmpbuf, TMPBUFLEN, "%u",1317 from_kuid(file->f_cred->user_ns,1318 audit_get_loginuid(task)));1319 put_task_struct(task);1320 return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);1321}1322 1323static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,1324 size_t count, loff_t *ppos)1325{1326 struct inode * inode = file_inode(file);1327 uid_t loginuid;1328 kuid_t kloginuid;1329 int rv;1330 1331 /* Don't let kthreads write their own loginuid */1332 if (current->flags & PF_KTHREAD)1333 return -EPERM;1334 1335 rcu_read_lock();1336 if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {1337 rcu_read_unlock();1338 return -EPERM;1339 }1340 rcu_read_unlock();1341 1342 if (*ppos != 0) {1343 /* No partial writes. */1344 return -EINVAL;1345 }1346 1347 rv = kstrtou32_from_user(buf, count, 10, &loginuid);1348 if (rv < 0)1349 return rv;1350 1351 /* is userspace tring to explicitly UNSET the loginuid? */1352 if (loginuid == AUDIT_UID_UNSET) {1353 kloginuid = INVALID_UID;1354 } else {1355 kloginuid = make_kuid(file->f_cred->user_ns, loginuid);1356 if (!uid_valid(kloginuid))1357 return -EINVAL;1358 }1359 1360 rv = audit_set_loginuid(kloginuid);1361 if (rv < 0)1362 return rv;1363 return count;1364}1365 1366static const struct file_operations proc_loginuid_operations = {1367 .read = proc_loginuid_read,1368 .write = proc_loginuid_write,1369 .llseek = generic_file_llseek,1370};1371 1372static ssize_t proc_sessionid_read(struct file * file, char __user * buf,1373 size_t count, loff_t *ppos)1374{1375 struct inode * inode = file_inode(file);1376 struct task_struct *task = get_proc_task(inode);1377 ssize_t length;1378 char tmpbuf[TMPBUFLEN];1379 1380 if (!task)1381 return -ESRCH;1382 length = scnprintf(tmpbuf, TMPBUFLEN, "%u",1383 audit_get_sessionid(task));1384 put_task_struct(task);1385 return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);1386}1387 1388static const struct file_operations proc_sessionid_operations = {1389 .read = proc_sessionid_read,1390 .llseek = generic_file_llseek,1391};1392#endif1393 1394#ifdef CONFIG_FAULT_INJECTION1395static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,1396 size_t count, loff_t *ppos)1397{1398 struct task_struct *task = get_proc_task(file_inode(file));1399 char buffer[PROC_NUMBUF];1400 size_t len;1401 int make_it_fail;1402 1403 if (!task)1404 return -ESRCH;1405 make_it_fail = task->make_it_fail;1406 put_task_struct(task);1407 1408 len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);1409 1410 return simple_read_from_buffer(buf, count, ppos, buffer, len);1411}1412 1413static ssize_t proc_fault_inject_write(struct file * file,1414 const char __user * buf, size_t count, loff_t *ppos)1415{1416 struct task_struct *task;1417 char buffer[PROC_NUMBUF] = {};1418 int make_it_fail;1419 int rv;1420 1421 if (!capable(CAP_SYS_RESOURCE))1422 return -EPERM;1423 1424 if (count > sizeof(buffer) - 1)1425 count = sizeof(buffer) - 1;1426 if (copy_from_user(buffer, buf, count))1427 return -EFAULT;1428 rv = kstrtoint(strstrip(buffer), 0, &make_it_fail);1429 if (rv < 0)1430 return rv;1431 if (make_it_fail < 0 || make_it_fail > 1)1432 return -EINVAL;1433 1434 task = get_proc_task(file_inode(file));1435 if (!task)1436 return -ESRCH;1437 task->make_it_fail = make_it_fail;1438 put_task_struct(task);1439 1440 return count;1441}1442 1443static const struct file_operations proc_fault_inject_operations = {1444 .read = proc_fault_inject_read,1445 .write = proc_fault_inject_write,1446 .llseek = generic_file_llseek,1447};1448 1449static ssize_t proc_fail_nth_write(struct file *file, const char __user *buf,1450 size_t count, loff_t *ppos)1451{1452 struct task_struct *task;1453 int err;1454 unsigned int n;1455 1456 err = kstrtouint_from_user(buf, count, 0, &n);1457 if (err)1458 return err;1459 1460 task = get_proc_task(file_inode(file));1461 if (!task)1462 return -ESRCH;1463 task->fail_nth = n;1464 put_task_struct(task);1465 1466 return count;1467}1468 1469static ssize_t proc_fail_nth_read(struct file *file, char __user *buf,1470 size_t count, loff_t *ppos)1471{1472 struct task_struct *task;1473 char numbuf[PROC_NUMBUF];1474 ssize_t len;1475 1476 task = get_proc_task(file_inode(file));1477 if (!task)1478 return -ESRCH;1479 len = snprintf(numbuf, sizeof(numbuf), "%u\n", task->fail_nth);1480 put_task_struct(task);1481 return simple_read_from_buffer(buf, count, ppos, numbuf, len);1482}1483 1484static const struct file_operations proc_fail_nth_operations = {1485 .read = proc_fail_nth_read,1486 .write = proc_fail_nth_write,1487};1488#endif1489 1490 1491#ifdef CONFIG_SCHED_DEBUG1492/*1493 * Print out various scheduling related per-task fields:1494 */1495static int sched_show(struct seq_file *m, void *v)1496{1497 struct inode *inode = m->private;1498 struct pid_namespace *ns = proc_pid_ns(inode->i_sb);1499 struct task_struct *p;1500 1501 p = get_proc_task(inode);1502 if (!p)1503 return -ESRCH;1504 proc_sched_show_task(p, ns, m);1505 1506 put_task_struct(p);1507 1508 return 0;1509}1510 1511static ssize_t1512sched_write(struct file *file, const char __user *buf,1513 size_t count, loff_t *offset)1514{1515 struct inode *inode = file_inode(file);1516 struct task_struct *p;1517 1518 p = get_proc_task(inode);1519 if (!p)1520 return -ESRCH;1521 proc_sched_set_task(p);1522 1523 put_task_struct(p);1524 1525 return count;1526}1527 1528static int sched_open(struct inode *inode, struct file *filp)1529{1530 return single_open(filp, sched_show, inode);1531}1532 1533static const struct file_operations proc_pid_sched_operations = {1534 .open = sched_open,1535 .read = seq_read,1536 .write = sched_write,1537 .llseek = seq_lseek,1538 .release = single_release,1539};1540 1541#endif1542 1543#ifdef CONFIG_SCHED_AUTOGROUP1544/*1545 * Print out autogroup related information:1546 */1547static int sched_autogroup_show(struct seq_file *m, void *v)1548{1549 struct inode *inode = m->private;1550 struct task_struct *p;1551 1552 p = get_proc_task(inode);1553 if (!p)1554 return -ESRCH;1555 proc_sched_autogroup_show_task(p, m);1556 1557 put_task_struct(p);1558 1559 return 0;1560}1561 1562static ssize_t1563sched_autogroup_write(struct file *file, const char __user *buf,1564 size_t count, loff_t *offset)1565{1566 struct inode *inode = file_inode(file);1567 struct task_struct *p;1568 char buffer[PROC_NUMBUF] = {};1569 int nice;1570 int err;1571 1572 if (count > sizeof(buffer) - 1)1573 count = sizeof(buffer) - 1;1574 if (copy_from_user(buffer, buf, count))1575 return -EFAULT;1576 1577 err = kstrtoint(strstrip(buffer), 0, &nice);1578 if (err < 0)1579 return err;1580 1581 p = get_proc_task(inode);1582 if (!p)1583 return -ESRCH;1584 1585 err = proc_sched_autogroup_set_nice(p, nice);1586 if (err)1587 count = err;1588 1589 put_task_struct(p);1590 1591 return count;1592}1593 1594static int sched_autogroup_open(struct inode *inode, struct file *filp)1595{1596 int ret;1597 1598 ret = single_open(filp, sched_autogroup_show, NULL);1599 if (!ret) {1600 struct seq_file *m = filp->private_data;1601 1602 m->private = inode;1603 }1604 return ret;1605}1606 1607static const struct file_operations proc_pid_sched_autogroup_operations = {1608 .open = sched_autogroup_open,1609 .read = seq_read,1610 .write = sched_autogroup_write,1611 .llseek = seq_lseek,1612 .release = single_release,1613};1614 1615#endif /* CONFIG_SCHED_AUTOGROUP */1616 1617#ifdef CONFIG_TIME_NS1618static int timens_offsets_show(struct seq_file *m, void *v)1619{1620 struct task_struct *p;1621 1622 p = get_proc_task(file_inode(m->file));1623 if (!p)1624 return -ESRCH;1625 proc_timens_show_offsets(p, m);1626 1627 put_task_struct(p);1628 1629 return 0;1630}1631 1632static ssize_t timens_offsets_write(struct file *file, const char __user *buf,1633 size_t count, loff_t *ppos)1634{1635 struct inode *inode = file_inode(file);1636 struct proc_timens_offset offsets[2];1637 char *kbuf = NULL, *pos, *next_line;1638 struct task_struct *p;1639 int ret, noffsets;1640 1641 /* Only allow < page size writes at the beginning of the file */1642 if ((*ppos != 0) || (count >= PAGE_SIZE))1643 return -EINVAL;1644 1645 /* Slurp in the user data */1646 kbuf = memdup_user_nul(buf, count);1647 if (IS_ERR(kbuf))1648 return PTR_ERR(kbuf);1649 1650 /* Parse the user data */1651 ret = -EINVAL;1652 noffsets = 0;1653 for (pos = kbuf; pos; pos = next_line) {1654 struct proc_timens_offset *off = &offsets[noffsets];1655 char clock[10];1656 int err;1657 1658 /* Find the end of line and ensure we don't look past it */1659 next_line = strchr(pos, '\n');1660 if (next_line) {1661 *next_line = '\0';1662 next_line++;1663 if (*next_line == '\0')1664 next_line = NULL;1665 }1666 1667 err = sscanf(pos, "%9s %lld %lu", clock,1668 &off->val.tv_sec, &off->val.tv_nsec);1669 if (err != 3 || off->val.tv_nsec >= NSEC_PER_SEC)1670 goto out;1671 1672 clock[sizeof(clock) - 1] = 0;1673 if (strcmp(clock, "monotonic") == 0 ||1674 strcmp(clock, __stringify(CLOCK_MONOTONIC)) == 0)1675 off->clockid = CLOCK_MONOTONIC;1676 else if (strcmp(clock, "boottime") == 0 ||1677 strcmp(clock, __stringify(CLOCK_BOOTTIME)) == 0)1678 off->clockid = CLOCK_BOOTTIME;1679 else1680 goto out;1681 1682 noffsets++;1683 if (noffsets == ARRAY_SIZE(offsets)) {1684 if (next_line)1685 count = next_line - kbuf;1686 break;1687 }1688 }1689 1690 ret = -ESRCH;1691 p = get_proc_task(inode);1692 if (!p)1693 goto out;1694 ret = proc_timens_set_offset(file, p, offsets, noffsets);1695 put_task_struct(p);1696 if (ret)1697 goto out;1698 1699 ret = count;1700out:1701 kfree(kbuf);1702 return ret;1703}1704 1705static int timens_offsets_open(struct inode *inode, struct file *filp)1706{1707 return single_open(filp, timens_offsets_show, inode);1708}1709 1710static const struct file_operations proc_timens_offsets_operations = {1711 .open = timens_offsets_open,1712 .read = seq_read,1713 .write = timens_offsets_write,1714 .llseek = seq_lseek,1715 .release = single_release,1716};1717#endif /* CONFIG_TIME_NS */1718 1719static ssize_t comm_write(struct file *file, const char __user *buf,1720 size_t count, loff_t *offset)1721{1722 struct inode *inode = file_inode(file);1723 struct task_struct *p;1724 char buffer[TASK_COMM_LEN] = {};1725 const size_t maxlen = sizeof(buffer) - 1;1726 1727 if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count))1728 return -EFAULT;1729 1730 p = get_proc_task(inode);1731 if (!p)1732 return -ESRCH;1733 1734 if (same_thread_group(current, p)) {1735 set_task_comm(p, buffer);1736 proc_comm_connector(p);1737 }1738 else1739 count = -EINVAL;1740 1741 put_task_struct(p);1742 1743 return count;1744}1745 1746static HWJS_SUSPENDS int comm_show(struct seq_file *m, void *v)1747{1748 struct inode *inode = m->private;1749 struct task_struct *p;1750 1751 p = get_proc_task(inode);1752 if (!p)1753 return -ESRCH;1754 1755 proc_task_name(m, p, false);1756 seq_putc(m, '\n');1757 1758 put_task_struct(p);1759 1760 return 0;1761}1762 1763static int comm_open(struct inode *inode, struct file *filp)1764{1765 return single_open(filp, comm_show, inode);1766}1767 1768static const struct file_operations proc_pid_set_comm_operations = {1769 .open = comm_open,1770 .read = seq_read,1771 .write = comm_write,1772 .llseek = seq_lseek,1773 .release = single_release,1774};1775 1776static HWJS_SUSPENDS int proc_exe_link(struct dentry *dentry, struct path *exe_path)1777{1778 struct task_struct *task;1779 struct file *exe_file;1780 1781 task = get_proc_task(d_inode(dentry));1782 if (!task)1783 return -ENOENT;1784 exe_file = get_task_exe_file(task);1785 put_task_struct(task);1786 if (exe_file) {1787 *exe_path = exe_file->f_path;1788 path_get(&exe_file->f_path);1789 fput(exe_file);1790 return 0;1791 } else1792 return -ENOENT;1793}1794 1795static HWJS_SUSPENDS const char *proc_pid_get_link(struct dentry *dentry,1796 struct inode *inode,1797 struct delayed_call *done)1798{1799 struct path path;1800 int error = -EACCES;1801 1802 if (!dentry)1803 return ERR_PTR(-ECHILD);1804 1805 /* Are we allowed to snoop on the tasks file descriptors? */1806 if (!proc_fd_access_allowed(inode))1807 goto out;1808 1809 error = PROC_I(inode)->op.proc_get_link(dentry, &path);1810 if (error)1811 goto out;1812 1813 error = nd_jump_link(&path);1814out:1815 return ERR_PTR(error);1816}1817 1818static int do_proc_readlink(const struct path *path, char __user *buffer, int buflen)1819{1820 char *tmp = kmalloc(PATH_MAX, GFP_KERNEL);1821 char *pathname;1822 int len;1823 1824 if (!tmp)1825 return -ENOMEM;1826 1827 pathname = d_path(path, tmp, PATH_MAX);1828 len = PTR_ERR(pathname);1829 if (IS_ERR(pathname))1830 goto out;1831 len = tmp + PATH_MAX - 1 - pathname;1832 1833 if (len > buflen)1834 len = buflen;1835 if (copy_to_user(buffer, pathname, len))1836 len = -EFAULT;1837 out:1838 kfree(tmp);1839 return len;1840}1841 1842static HWJS_SUSPENDS int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)1843{1844 int error = -EACCES;1845 struct inode *inode = d_inode(dentry);1846 struct path path;1847 1848 /* Are we allowed to snoop on the tasks file descriptors? */1849 if (!proc_fd_access_allowed(inode))1850 goto out;1851 1852 error = PROC_I(inode)->op.proc_get_link(dentry, &path);1853 if (error)1854 goto out;1855 1856 error = do_proc_readlink(&path, buffer, buflen);1857 path_put(&path);1858out:1859 return error;1860}1861 1862const struct inode_operations proc_pid_link_inode_operations = {1863 .readlink = proc_pid_readlink,1864 .get_link = proc_pid_get_link,1865 .setattr = proc_setattr,1866};1867 1868 1869/* building an inode */1870 1871void task_dump_owner(struct task_struct *task, umode_t mode,1872 kuid_t *ruid, kgid_t *rgid)1873{1874 /* Depending on the state of dumpable compute who should own a1875 * proc file for a task.1876 */1877 const struct cred *cred;1878 kuid_t uid;1879 kgid_t gid;1880 1881 if (unlikely(task->flags & PF_KTHREAD)) {1882 *ruid = GLOBAL_ROOT_UID;1883 *rgid = GLOBAL_ROOT_GID;1884 return;1885 }1886 1887 /* Default to the tasks effective ownership */1888 rcu_read_lock();1889 cred = __task_cred(task);1890 uid = cred->euid;1891 gid = cred->egid;1892 rcu_read_unlock();1893 1894 /*1895 * Before the /proc/pid/status file was created the only way to read1896 * the effective uid of a /process was to stat /proc/pid. Reading1897 * /proc/pid/status is slow enough that procps and other packages1898 * kept stating /proc/pid. To keep the rules in /proc simple I have1899 * made this apply to all per process world readable and executable1900 * directories.1901 */1902 if (mode != (S_IFDIR|S_IRUGO|S_IXUGO)) {1903 struct mm_struct *mm;1904 task_lock(task);1905 mm = task->mm;1906 /* Make non-dumpable tasks owned by some root */1907 if (mm) {1908 if (get_dumpable(mm) != SUID_DUMP_USER) {1909 struct user_namespace *user_ns = mm->user_ns;1910 1911 uid = make_kuid(user_ns, 0);1912 if (!uid_valid(uid))1913 uid = GLOBAL_ROOT_UID;1914 1915 gid = make_kgid(user_ns, 0);1916 if (!gid_valid(gid))1917 gid = GLOBAL_ROOT_GID;1918 }1919 } else {1920 uid = GLOBAL_ROOT_UID;1921 gid = GLOBAL_ROOT_GID;1922 }1923 task_unlock(task);1924 }1925 *ruid = uid;1926 *rgid = gid;1927}1928 1929void proc_pid_evict_inode(struct proc_inode *ei)1930{1931 struct pid *pid = ei->pid;1932 1933 if (S_ISDIR(ei->vfs_inode.i_mode)) {1934 spin_lock(&pid->lock);1935 hlist_del_init_rcu(&ei->sibling_inodes);1936 spin_unlock(&pid->lock);1937 }1938}1939 1940struct inode *proc_pid_make_inode(struct super_block *sb,1941 struct task_struct *task, umode_t mode)1942{1943 struct inode * inode;1944 struct proc_inode *ei;1945 struct pid *pid;1946 1947 /* We need a new inode */1948 1949 inode = new_inode(sb);1950 if (!inode)1951 goto out;1952 1953 /* Common stuff */1954 ei = PROC_I(inode);1955 inode->i_mode = mode;1956 inode->i_ino = get_next_ino();1957 simple_inode_init_ts(inode);1958 inode->i_op = &proc_def_inode_operations;1959 1960 /*1961 * grab the reference to task.1962 */1963 pid = get_task_pid(task, PIDTYPE_PID);1964 if (!pid)1965 goto out_unlock;1966 1967 /* Let the pid remember us for quick removal */1968 ei->pid = pid;1969 1970 task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);1971 security_task_to_inode(task, inode);1972 1973out:1974 return inode;1975 1976out_unlock:1977 iput(inode);1978 return NULL;1979}1980 1981/*1982 * Generating an inode and adding it into @pid->inodes, so that task will1983 * invalidate inode's dentry before being released.1984 *1985 * This helper is used for creating dir-type entries under '/proc' and1986 * '/proc/<tgid>/task'. Other entries(eg. fd, stat) under '/proc/<tgid>'1987 * can be released by invalidating '/proc/<tgid>' dentry.1988 * In theory, dentries under '/proc/<tgid>/task' can also be released by1989 * invalidating '/proc/<tgid>' dentry, we reserve it to handle single1990 * thread exiting situation: Any one of threads should invalidate its1991 * '/proc/<tgid>/task/<pid>' dentry before released.1992 */1993static HWJS_SUSPENDS struct inode *proc_pid_make_base_inode(struct super_block *sb,1994 struct task_struct *task, umode_t mode)1995{1996 struct inode *inode;1997 struct proc_inode *ei;1998 struct pid *pid;1999 2000 inode = proc_pid_make_inode(sb, task, mode);2001 if (!inode)2002 return NULL;2003 2004 /* Let proc_flush_pid find this directory inode */2005 ei = PROC_I(inode);2006 pid = ei->pid;2007 spin_lock(&pid->lock);2008 hlist_add_head_rcu(&ei->sibling_inodes, &pid->inodes);2009 spin_unlock(&pid->lock);2010 2011 return inode;2012}2013 2014int pid_getattr(struct mnt_idmap *idmap, const struct path *path,2015 struct kstat *stat, u32 request_mask, unsigned int query_flags)2016{2017 struct inode *inode = d_inode(path->dentry);2018 struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);2019 struct task_struct *task;2020 2021 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);2022 2023 stat->uid = GLOBAL_ROOT_UID;2024 stat->gid = GLOBAL_ROOT_GID;2025 rcu_read_lock();2026 task = pid_task(proc_pid(inode), PIDTYPE_PID);2027 if (task) {2028 if (!has_pid_permissions(fs_info, task, HIDEPID_INVISIBLE)) {2029 rcu_read_unlock();2030 /*2031 * This doesn't prevent learning whether PID exists,2032 * it only makes getattr() consistent with readdir().2033 */2034 return -ENOENT;2035 }2036 task_dump_owner(task, inode->i_mode, &stat->uid, &stat->gid);2037 }2038 rcu_read_unlock();2039 return 0;2040}2041 2042/* dentry stuff */2043 2044/*2045 * Set <pid>/... inode ownership (can change due to setuid(), etc.)2046 */2047void pid_update_inode(struct task_struct *task, struct inode *inode)2048{2049 task_dump_owner(task, inode->i_mode, &inode->i_uid, &inode->i_gid);2050 2051 inode->i_mode &= ~(S_ISUID | S_ISGID);2052 security_task_to_inode(task, inode);2053}2054 2055/*2056 * Rewrite the inode's ownerships here because the owning task may have2057 * performed a setuid(), etc.2058 *2059 */2060static int pid_revalidate(struct dentry *dentry, unsigned int flags)2061{2062 struct inode *inode;2063 struct task_struct *task;2064 int ret = 0;2065 2066 rcu_read_lock();2067 inode = d_inode_rcu(dentry);2068 if (!inode)2069 goto out;2070 task = pid_task(proc_pid(inode), PIDTYPE_PID);2071 2072 if (task) {2073 pid_update_inode(task, inode);2074 ret = 1;2075 }2076out:2077 rcu_read_unlock();2078 return ret;2079}2080 2081static inline bool proc_inode_is_dead(struct inode *inode)2082{2083 return !proc_pid(inode)->tasks[PIDTYPE_PID].first;2084}2085 2086int pid_delete_dentry(const struct dentry *dentry)2087{2088 /* Is the task we represent dead?2089 * If so, then don't put the dentry on the lru list,2090 * kill it immediately.2091 */2092 return proc_inode_is_dead(d_inode(dentry));2093}2094 2095const struct dentry_operations pid_dentry_operations =2096{2097 .d_revalidate = pid_revalidate,2098 .d_delete = pid_delete_dentry,2099};2100 2101/* Lookups */2102 2103/*2104 * Fill a directory entry.2105 *2106 * If possible create the dcache entry and derive our inode number and2107 * file type from dcache entry.2108 *2109 * Since all of the proc inode numbers are dynamically generated, the inode2110 * numbers do not exist until the inode is cache. This means creating2111 * the dcache entry in readdir is necessary to keep the inode numbers2112 * reported by readdir in sync with the inode numbers reported2113 * by stat.2114 */2115bool proc_fill_cache(struct file *file, struct dir_context *ctx,2116 const char *name, unsigned int len,2117 instantiate_t instantiate, struct task_struct *task, const void *ptr)2118{2119 struct dentry *child, *dir = file->f_path.dentry;2120 struct qstr qname = QSTR_INIT(name, len);2121 struct inode *inode;2122 unsigned type = DT_UNKNOWN;2123 ino_t ino = 1;2124 2125 child = d_hash_and_lookup(dir, &qname);2126 if (!child) {2127 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);2128 child = d_alloc_parallel(dir, &qname, &wq);2129 if (IS_ERR(child))2130 goto end_instantiate;2131 if (d_in_lookup(child)) {2132 struct dentry *res;2133 res = instantiate(child, task, ptr);2134 d_lookup_done(child);2135 if (unlikely(res)) {2136 dput(child);2137 child = res;2138 if (IS_ERR(child))2139 goto end_instantiate;2140 }2141 }2142 }2143 inode = d_inode(child);2144 ino = inode->i_ino;2145 type = inode->i_mode >> 12;2146 dput(child);2147end_instantiate:2148 return dir_emit(ctx, name, len, ino, type);2149}2150 2151/*2152 * dname_to_vma_addr - maps a dentry name into two unsigned longs2153 * which represent vma start and end addresses.2154 */2155static int dname_to_vma_addr(struct dentry *dentry,2156 unsigned long *start, unsigned long *end)2157{2158 const char *str = dentry->d_name.name;2159 unsigned long long sval, eval;2160 unsigned int len;2161 2162 if (str[0] == '0' && str[1] != '-')2163 return -EINVAL;2164 len = _parse_integer(str, 16, &sval);2165 if (len & KSTRTOX_OVERFLOW)2166 return -EINVAL;2167 if (sval != (unsigned long)sval)2168 return -EINVAL;2169 str += len;2170 2171 if (*str != '-')2172 return -EINVAL;2173 str++;2174 2175 if (str[0] == '0' && str[1])2176 return -EINVAL;2177 len = _parse_integer(str, 16, &eval);2178 if (len & KSTRTOX_OVERFLOW)2179 return -EINVAL;2180 if (eval != (unsigned long)eval)2181 return -EINVAL;2182 str += len;2183 2184 if (*str != '\0')2185 return -EINVAL;2186 2187 *start = sval;2188 *end = eval;2189 2190 return 0;2191}2192 2193static HWJS_SUSPENDS int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)2194{2195 unsigned long vm_start, vm_end;2196 bool exact_vma_exists = false;2197 struct mm_struct *mm = NULL;2198 struct task_struct *task;2199 struct inode *inode;2200 int status = 0;2201 2202 if (flags & LOOKUP_RCU)2203 return -ECHILD;2204 2205 inode = d_inode(dentry);2206 task = get_proc_task(inode);2207 if (!task)2208 goto out_notask;2209 2210 mm = mm_access(task, PTRACE_MODE_READ_FSCREDS);2211 if (IS_ERR_OR_NULL(mm))2212 goto out;2213 2214 if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {2215 status = mmap_read_lock_killable(mm);2216 if (!status) {2217 exact_vma_exists = !!find_exact_vma(mm, vm_start,2218 vm_end);2219 mmap_read_unlock(mm);2220 }2221 }2222 2223 mmput(mm);2224 2225 if (exact_vma_exists) {2226 task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);2227 2228 security_task_to_inode(task, inode);2229 status = 1;2230 }2231 2232out:2233 put_task_struct(task);2234 2235out_notask:2236 return status;2237}2238 2239static const struct dentry_operations tid_map_files_dentry_operations = {2240 .d_revalidate = map_files_d_revalidate,2241 .d_delete = pid_delete_dentry,2242};2243 2244static HWJS_SUSPENDS int map_files_get_link(struct dentry *dentry, struct path *path)2245{2246 unsigned long vm_start, vm_end;2247 struct vm_area_struct *vma;2248 struct task_struct *task;2249 struct mm_struct *mm;2250 int rc;2251 2252 rc = -ENOENT;2253 task = get_proc_task(d_inode(dentry));2254 if (!task)2255 goto out;2256 2257 mm = get_task_mm(task);2258 put_task_struct(task);2259 if (!mm)2260 goto out;2261 2262 rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);2263 if (rc)2264 goto out_mmput;2265 2266 rc = mmap_read_lock_killable(mm);2267 if (rc)2268 goto out_mmput;2269 2270 rc = -ENOENT;2271 vma = find_exact_vma(mm, vm_start, vm_end);2272 if (vma && vma->vm_file) {2273 *path = *file_user_path(vma->vm_file);2274 path_get(path);2275 rc = 0;2276 }2277 mmap_read_unlock(mm);2278 2279out_mmput:2280 mmput(mm);2281out:2282 return rc;2283}2284 2285struct map_files_info {2286 unsigned long start;2287 unsigned long end;2288 fmode_t mode;2289};2290 2291/*2292 * Only allow CAP_SYS_ADMIN and CAP_CHECKPOINT_RESTORE to follow the links, due2293 * to concerns about how the symlinks may be used to bypass permissions on2294 * ancestor directories in the path to the file in question.2295 */2296static HWJS_SUSPENDS const char *2297proc_map_files_get_link(struct dentry *dentry,2298 struct inode *inode,2299 struct delayed_call *done)2300{2301 if (!checkpoint_restore_ns_capable(&init_user_ns))2302 return ERR_PTR(-EPERM);2303 2304 return proc_pid_get_link(dentry, inode, done);2305}2306 2307/*2308 * Identical to proc_pid_link_inode_operations except for get_link()2309 */2310static const struct inode_operations proc_map_files_link_inode_operations = {2311 .readlink = proc_pid_readlink,2312 .get_link = proc_map_files_get_link,2313 .setattr = proc_setattr,2314};2315 2316static HWJS_SUSPENDS struct dentry *2317proc_map_files_instantiate(struct dentry *dentry,2318 struct task_struct *task, const void *ptr)2319{2320 fmode_t mode = (fmode_t)(unsigned long)ptr;2321 struct proc_inode *ei;2322 struct inode *inode;2323 2324 inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK |2325 ((mode & FMODE_READ ) ? S_IRUSR : 0) |2326 ((mode & FMODE_WRITE) ? S_IWUSR : 0));2327 if (!inode)2328 return ERR_PTR(-ENOENT);2329 2330 ei = PROC_I(inode);2331 ei->op.proc_get_link = map_files_get_link;2332 2333 inode->i_op = &proc_map_files_link_inode_operations;2334 inode->i_size = 64;2335 2336 return proc_splice_unmountable(inode, dentry,2337 &tid_map_files_dentry_operations);2338}2339 2340static HWJS_SUSPENDS struct dentry *proc_map_files_lookup(struct inode *dir,2341 struct dentry *dentry, unsigned int flags)2342{2343 unsigned long vm_start, vm_end;2344 struct vm_area_struct *vma;2345 struct task_struct *task;2346 struct dentry *result;2347 struct mm_struct *mm;2348 2349 result = ERR_PTR(-ENOENT);2350 task = get_proc_task(dir);2351 if (!task)2352 goto out;2353 2354 result = ERR_PTR(-EACCES);2355 if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))2356 goto out_put_task;2357 2358 result = ERR_PTR(-ENOENT);2359 if (dname_to_vma_addr(dentry, &vm_start, &vm_end))2360 goto out_put_task;2361 2362 mm = get_task_mm(task);2363 if (!mm)2364 goto out_put_task;2365 2366 result = ERR_PTR(-EINTR);2367 if (mmap_read_lock_killable(mm))2368 goto out_put_mm;2369 2370 result = ERR_PTR(-ENOENT);2371 vma = find_exact_vma(mm, vm_start, vm_end);2372 if (!vma)2373 goto out_no_vma;2374 2375 if (vma->vm_file)2376 result = proc_map_files_instantiate(dentry, task,2377 (void *)(unsigned long)vma->vm_file->f_mode);2378 2379out_no_vma:2380 mmap_read_unlock(mm);2381out_put_mm:2382 mmput(mm);2383out_put_task:2384 put_task_struct(task);2385out:2386 return result;2387}2388 2389static const struct inode_operations proc_map_files_inode_operations = {2390 .lookup = proc_map_files_lookup,2391 .permission = proc_fd_permission,2392 .setattr = proc_setattr,2393};2394 2395static HWJS_SUSPENDS int2396proc_map_files_readdir(struct file *file, struct dir_context *ctx)2397{2398 struct vm_area_struct *vma;2399 struct task_struct *task;2400 struct mm_struct *mm;2401 unsigned long nr_files, pos, i;2402 GENRADIX(struct map_files_info) fa;2403 struct map_files_info *p;2404 int ret;2405 struct vma_iterator vmi;2406 2407 genradix_init(&fa);2408 2409 ret = -ENOENT;2410 task = get_proc_task(file_inode(file));2411 if (!task)2412 goto out;2413 2414 ret = -EACCES;2415 if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))2416 goto out_put_task;2417 2418 ret = 0;2419 if (!dir_emit_dots(file, ctx))2420 goto out_put_task;2421 2422 mm = get_task_mm(task);2423 if (!mm)2424 goto out_put_task;2425 2426 ret = mmap_read_lock_killable(mm);2427 if (ret) {2428 mmput(mm);2429 goto out_put_task;2430 }2431 2432 nr_files = 0;2433 2434 /*2435 * We need two passes here:2436 *2437 * 1) Collect vmas of mapped files with mmap_lock taken2438 * 2) Release mmap_lock and instantiate entries2439 *2440 * otherwise we get lockdep complained, since filldir()2441 * routine might require mmap_lock taken in might_fault().2442 */2443 2444 pos = 2;2445 vma_iter_init(&vmi, mm, 0);2446 for_each_vma(vmi, vma) {2447 if (!vma->vm_file)2448 continue;2449 if (++pos <= ctx->pos)2450 continue;2451 2452 p = genradix_ptr_alloc(&fa, nr_files++, GFP_KERNEL);2453 if (!p) {2454 ret = -ENOMEM;2455 mmap_read_unlock(mm);2456 mmput(mm);2457 goto out_put_task;2458 }2459 2460 p->start = vma->vm_start;2461 p->end = vma->vm_end;2462 p->mode = vma->vm_file->f_mode;2463 }2464 mmap_read_unlock(mm);2465 mmput(mm);2466 2467 for (i = 0; i < nr_files; i++) {2468 char buf[4 * sizeof(long) + 2]; /* max: %lx-%lx\0 */2469 unsigned int len;2470 2471 p = genradix_ptr(&fa, i);2472 len = snprintf(buf, sizeof(buf), "%lx-%lx", p->start, p->end);2473 if (!proc_fill_cache(file, ctx,2474 buf, len,2475 proc_map_files_instantiate,2476 task,2477 (void *)(unsigned long)p->mode))2478 break;2479 ctx->pos++;2480 }2481 2482out_put_task:2483 put_task_struct(task);2484out:2485 genradix_free(&fa);2486 return ret;2487}2488 2489static const struct file_operations proc_map_files_operations = {2490 .read = generic_read_dir,2491 .iterate_shared = proc_map_files_readdir,2492 .llseek = generic_file_llseek,2493};2494 2495#if defined(CONFIG_CHECKPOINT_RESTORE) && defined(CONFIG_POSIX_TIMERS)2496struct timers_private {2497 struct pid *pid;2498 struct task_struct *task;2499 struct sighand_struct *sighand;2500 struct pid_namespace *ns;2501 unsigned long flags;2502};2503 2504static void *timers_start(struct seq_file *m, loff_t *pos)2505{2506 struct timers_private *tp = m->private;2507 2508 tp->task = get_pid_task(tp->pid, PIDTYPE_PID);2509 if (!tp->task)2510 return ERR_PTR(-ESRCH);2511 2512 tp->sighand = lock_task_sighand(tp->task, &tp->flags);2513 if (!tp->sighand)2514 return ERR_PTR(-ESRCH);2515 2516 return seq_hlist_start(&tp->task->signal->posix_timers, *pos);2517}2518 2519static void *timers_next(struct seq_file *m, void *v, loff_t *pos)2520{2521 struct timers_private *tp = m->private;2522 return seq_hlist_next(v, &tp->task->signal->posix_timers, pos);2523}2524 2525static void timers_stop(struct seq_file *m, void *v)2526{2527 struct timers_private *tp = m->private;2528 2529 if (tp->sighand) {2530 unlock_task_sighand(tp->task, &tp->flags);2531 tp->sighand = NULL;2532 }2533 2534 if (tp->task) {2535 put_task_struct(tp->task);2536 tp->task = NULL;2537 }2538}2539 2540static int show_timer(struct seq_file *m, void *v)2541{2542 struct k_itimer *timer;2543 struct timers_private *tp = m->private;2544 int notify;2545 static const char * const nstr[] = {2546 [SIGEV_SIGNAL] = "signal",2547 [SIGEV_NONE] = "none",2548 [SIGEV_THREAD] = "thread",2549 };2550 2551 timer = hlist_entry((struct hlist_node *)v, struct k_itimer, list);2552 notify = timer->it_sigev_notify;2553 2554 seq_printf(m, "ID: %d\n", timer->it_id);2555 seq_printf(m, "signal: %d/%px\n",2556 timer->sigq->info.si_signo,2557 timer->sigq->info.si_value.sival_ptr);2558 seq_printf(m, "notify: %s/%s.%d\n",2559 nstr[notify & ~SIGEV_THREAD_ID],2560 (notify & SIGEV_THREAD_ID) ? "tid" : "pid",2561 pid_nr_ns(timer->it_pid, tp->ns));2562 seq_printf(m, "ClockID: %d\n", timer->it_clock);2563 2564 return 0;2565}2566 2567static const struct seq_operations proc_timers_seq_ops = {2568 .start = timers_start,2569 .next = timers_next,2570 .stop = timers_stop,2571 .show = show_timer,2572};2573 2574static int proc_timers_open(struct inode *inode, struct file *file)2575{2576 struct timers_private *tp;2577 2578 tp = __seq_open_private(file, &proc_timers_seq_ops,2579 sizeof(struct timers_private));2580 if (!tp)2581 return -ENOMEM;2582 2583 tp->pid = proc_pid(inode);2584 tp->ns = proc_pid_ns(inode->i_sb);2585 return 0;2586}2587 2588static const struct file_operations proc_timers_operations = {2589 .open = proc_timers_open,2590 .read = seq_read,2591 .llseek = seq_lseek,2592 .release = seq_release_private,2593};2594#endif2595 2596static ssize_t timerslack_ns_write(struct file *file, const char __user *buf,2597 size_t count, loff_t *offset)2598{2599 struct inode *inode = file_inode(file);2600 struct task_struct *p;2601 u64 slack_ns;2602 int err;2603 2604 err = kstrtoull_from_user(buf, count, 10, &slack_ns);2605 if (err < 0)2606 return err;2607 2608 p = get_proc_task(inode);2609 if (!p)2610 return -ESRCH;2611 2612 if (p != current) {2613 rcu_read_lock();2614 if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) {2615 rcu_read_unlock();2616 count = -EPERM;2617 goto out;2618 }2619 rcu_read_unlock();2620 2621 err = security_task_setscheduler(p);2622 if (err) {2623 count = err;2624 goto out;2625 }2626 }2627 2628 task_lock(p);2629 if (rt_or_dl_task_policy(p))2630 slack_ns = 0;2631 else if (slack_ns == 0)2632 slack_ns = p->default_timer_slack_ns;2633 p->timer_slack_ns = slack_ns;2634 task_unlock(p);2635 2636out:2637 put_task_struct(p);2638 2639 return count;2640}2641 2642static HWJS_SUSPENDS int timerslack_ns_show(struct seq_file *m, void *v)2643{2644 struct inode *inode = m->private;2645 struct task_struct *p;2646 int err = 0;2647 2648 p = get_proc_task(inode);2649 if (!p)2650 return -ESRCH;2651 2652 if (p != current) {2653 rcu_read_lock();2654 if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) {2655 rcu_read_unlock();2656 err = -EPERM;2657 goto out;2658 }2659 rcu_read_unlock();2660 2661 err = security_task_getscheduler(p);2662 if (err)2663 goto out;2664 }2665 2666 task_lock(p);2667 seq_printf(m, "%llu\n", p->timer_slack_ns);2668 task_unlock(p);2669 2670out:2671 put_task_struct(p);2672 2673 return err;2674}2675 2676static int timerslack_ns_open(struct inode *inode, struct file *filp)2677{2678 return single_open(filp, timerslack_ns_show, inode);2679}2680 2681static const struct file_operations proc_pid_set_timerslack_ns_operations = {2682 .open = timerslack_ns_open,2683 .read = seq_read,2684 .write = timerslack_ns_write,2685 .llseek = seq_lseek,2686 .release = single_release,2687};2688 2689static HWJS_SUSPENDS struct dentry *proc_pident_instantiate(struct dentry *dentry,2690 struct task_struct *task, const void *ptr)2691{2692 const struct pid_entry *p = ptr;2693 struct inode *inode;2694 struct proc_inode *ei;2695 2696 inode = proc_pid_make_inode(dentry->d_sb, task, p->mode);2697 if (!inode)2698 return ERR_PTR(-ENOENT);2699 2700 ei = PROC_I(inode);2701 if (S_ISDIR(inode->i_mode))2702 set_nlink(inode, 2); /* Use getattr to fix if necessary */2703 if (p->iop)2704 inode->i_op = p->iop;2705 if (p->fop)2706 inode->i_fop = p->fop;2707 ei->op = p->op;2708 pid_update_inode(task, inode);2709 d_set_d_op(dentry, &pid_dentry_operations);2710 return d_splice_alias(inode, dentry);2711}2712 2713static HWJS_SUSPENDS struct dentry *proc_pident_lookup(struct inode *dir, 2714 struct dentry *dentry,2715 const struct pid_entry *p,2716 const struct pid_entry *end)2717{2718 struct task_struct *task = get_proc_task(dir);2719 struct dentry *res = ERR_PTR(-ENOENT);2720 2721 if (!task)2722 goto out_no_task;2723 2724 /*2725 * Yes, it does not scale. And it should not. Don't add2726 * new entries into /proc/<tgid>/ without very good reasons.2727 */2728 for (; p < end; p++) {2729 if (p->len != dentry->d_name.len)2730 continue;2731 if (!memcmp(dentry->d_name.name, p->name, p->len)) {2732 res = proc_pident_instantiate(dentry, task, p);2733 break;2734 }2735 }2736 put_task_struct(task);2737out_no_task:2738 return res;2739}2740 2741static HWJS_SUSPENDS int proc_pident_readdir(struct file *file, struct dir_context *ctx,2742 const struct pid_entry *ents, unsigned int nents)2743{2744 struct task_struct *task = get_proc_task(file_inode(file));2745 const struct pid_entry *p;2746 2747 if (!task)2748 return -ENOENT;2749 2750 if (!dir_emit_dots(file, ctx))2751 goto out;2752 2753 if (ctx->pos >= nents + 2)2754 goto out;2755 2756 for (p = ents + (ctx->pos - 2); p < ents + nents; p++) {2757 if (!proc_fill_cache(file, ctx, p->name, p->len,2758 proc_pident_instantiate, task, p))2759 break;2760 ctx->pos++;2761 }2762out:2763 put_task_struct(task);2764 return 0;2765}2766 2767#ifdef CONFIG_SECURITY2768static int proc_pid_attr_open(struct inode *inode, struct file *file)2769{2770 file->private_data = NULL;2771 __mem_open(inode, file, PTRACE_MODE_READ_FSCREDS);2772 return 0;2773}2774 2775static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,2776 size_t count, loff_t *ppos)2777{2778 struct inode * inode = file_inode(file);2779 char *p = NULL;2780 ssize_t length;2781 struct task_struct *task = get_proc_task(inode);2782 2783 if (!task)2784 return -ESRCH;2785 2786 length = security_getprocattr(task, PROC_I(inode)->op.lsmid,2787 file->f_path.dentry->d_name.name,2788 &p);2789 put_task_struct(task);2790 if (length > 0)2791 length = simple_read_from_buffer(buf, count, ppos, p, length);2792 kfree(p);2793 return length;2794}2795 2796static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,2797 size_t count, loff_t *ppos)2798{2799 struct inode * inode = file_inode(file);2800 struct task_struct *task;2801 void *page;2802 int rv;2803 2804 /* A task may only write when it was the opener. */2805 if (file->private_data != current->mm)2806 return -EPERM;2807 2808 rcu_read_lock();2809 task = pid_task(proc_pid(inode), PIDTYPE_PID);2810 if (!task) {2811 rcu_read_unlock();2812 return -ESRCH;2813 }2814 /* A task may only write its own attributes. */2815 if (current != task) {2816 rcu_read_unlock();2817 return -EACCES;2818 }2819 /* Prevent changes to overridden credentials. */2820 if (current_cred() != current_real_cred()) {2821 rcu_read_unlock();2822 return -EBUSY;2823 }2824 rcu_read_unlock();2825 2826 if (count > PAGE_SIZE)2827 count = PAGE_SIZE;2828 2829 /* No partial writes. */2830 if (*ppos != 0)2831 return -EINVAL;2832 2833 page = memdup_user(buf, count);2834 if (IS_ERR(page)) {2835 rv = PTR_ERR(page);2836 goto out;2837 }2838 2839 /* Guard against adverse ptrace interaction */2840 rv = mutex_lock_interruptible(¤t->signal->cred_guard_mutex);2841 if (rv < 0)2842 goto out_free;2843 2844 rv = security_setprocattr(PROC_I(inode)->op.lsmid,2845 file->f_path.dentry->d_name.name, page,2846 count);2847 mutex_unlock(¤t->signal->cred_guard_mutex);2848out_free:2849 kfree(page);2850out:2851 return rv;2852}2853 2854static const struct file_operations proc_pid_attr_operations = {2855 .open = proc_pid_attr_open,2856 .read = proc_pid_attr_read,2857 .write = proc_pid_attr_write,2858 .llseek = generic_file_llseek,2859 .release = mem_release,2860};2861 2862#define LSM_DIR_OPS(LSM) \2863static int proc_##LSM##_attr_dir_iterate(struct file *filp, \2864 struct dir_context *ctx) \2865{ \2866 return proc_pident_readdir(filp, ctx, \2867 LSM##_attr_dir_stuff, \2868 ARRAY_SIZE(LSM##_attr_dir_stuff)); \2869} \2870\2871static const struct file_operations proc_##LSM##_attr_dir_ops = { \2872 .read = generic_read_dir, \2873 .iterate_shared = proc_##LSM##_attr_dir_iterate, \2874 .llseek = default_llseek, \2875}; \2876\2877static struct dentry *proc_##LSM##_attr_dir_lookup(struct inode *dir, \2878 struct dentry *dentry, unsigned int flags) \2879{ \2880 return proc_pident_lookup(dir, dentry, \2881 LSM##_attr_dir_stuff, \2882 LSM##_attr_dir_stuff + ARRAY_SIZE(LSM##_attr_dir_stuff)); \2883} \2884\2885static const struct inode_operations proc_##LSM##_attr_dir_inode_ops = { \2886 .lookup = proc_##LSM##_attr_dir_lookup, \2887 .getattr = pid_getattr, \2888 .setattr = proc_setattr, \2889}2890 2891#ifdef CONFIG_SECURITY_SMACK2892static const struct pid_entry smack_attr_dir_stuff[] = {2893 ATTR(LSM_ID_SMACK, "current", 0666),2894};2895LSM_DIR_OPS(smack);2896#endif2897 2898#ifdef CONFIG_SECURITY_APPARMOR2899static const struct pid_entry apparmor_attr_dir_stuff[] = {2900 ATTR(LSM_ID_APPARMOR, "current", 0666),2901 ATTR(LSM_ID_APPARMOR, "prev", 0444),2902 ATTR(LSM_ID_APPARMOR, "exec", 0666),2903};2904LSM_DIR_OPS(apparmor);2905#endif2906 2907static const struct pid_entry attr_dir_stuff[] = {2908 ATTR(LSM_ID_UNDEF, "current", 0666),2909 ATTR(LSM_ID_UNDEF, "prev", 0444),2910 ATTR(LSM_ID_UNDEF, "exec", 0666),2911 ATTR(LSM_ID_UNDEF, "fscreate", 0666),2912 ATTR(LSM_ID_UNDEF, "keycreate", 0666),2913 ATTR(LSM_ID_UNDEF, "sockcreate", 0666),2914#ifdef CONFIG_SECURITY_SMACK2915 DIR("smack", 0555,2916 proc_smack_attr_dir_inode_ops, proc_smack_attr_dir_ops),2917#endif2918#ifdef CONFIG_SECURITY_APPARMOR2919 DIR("apparmor", 0555,2920 proc_apparmor_attr_dir_inode_ops, proc_apparmor_attr_dir_ops),2921#endif2922};2923 2924static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx)2925{2926 return proc_pident_readdir(file, ctx, 2927 attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));2928}2929 2930static const struct file_operations proc_attr_dir_operations = {2931 .read = generic_read_dir,2932 .iterate_shared = proc_attr_dir_readdir,2933 .llseek = generic_file_llseek,2934};2935 2936static struct dentry *proc_attr_dir_lookup(struct inode *dir,2937 struct dentry *dentry, unsigned int flags)2938{2939 return proc_pident_lookup(dir, dentry,2940 attr_dir_stuff,2941 attr_dir_stuff + ARRAY_SIZE(attr_dir_stuff));2942}2943 2944static const struct inode_operations proc_attr_dir_inode_operations = {2945 .lookup = proc_attr_dir_lookup,2946 .getattr = pid_getattr,2947 .setattr = proc_setattr,2948};2949 2950#endif2951 2952#ifdef CONFIG_ELF_CORE2953static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,2954 size_t count, loff_t *ppos)2955{2956 struct task_struct *task = get_proc_task(file_inode(file));2957 struct mm_struct *mm;2958 char buffer[PROC_NUMBUF];2959 size_t len;2960 int ret;2961 2962 if (!task)2963 return -ESRCH;2964 2965 ret = 0;2966 mm = get_task_mm(task);2967 if (mm) {2968 len = snprintf(buffer, sizeof(buffer), "%08lx\n",2969 ((mm->flags & MMF_DUMP_FILTER_MASK) >>2970 MMF_DUMP_FILTER_SHIFT));2971 mmput(mm);2972 ret = simple_read_from_buffer(buf, count, ppos, buffer, len);2973 }2974 2975 put_task_struct(task);2976 2977 return ret;2978}2979 2980static HWJS_SUSPENDS ssize_t proc_coredump_filter_write(struct file *file,2981 const char __user *buf,2982 size_t count,2983 loff_t *ppos)2984{2985 struct task_struct *task;2986 struct mm_struct *mm;2987 unsigned int val;2988 int ret;2989 int i;2990 unsigned long mask;2991 2992 ret = kstrtouint_from_user(buf, count, 0, &val);2993 if (ret < 0)2994 return ret;2995 2996 ret = -ESRCH;2997 task = get_proc_task(file_inode(file));2998 if (!task)2999 goto out_no_task;3000 3001 mm = get_task_mm(task);3002 if (!mm)3003 goto out_no_mm;3004 ret = 0;3005 3006 for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {3007 if (val & mask)3008 set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);3009 else3010 clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);3011 }3012 3013 mmput(mm);3014 out_no_mm:3015 put_task_struct(task);3016 out_no_task:3017 if (ret < 0)3018 return ret;3019 return count;3020}3021 3022static const struct file_operations proc_coredump_filter_operations = {3023 .read = proc_coredump_filter_read,3024 .write = proc_coredump_filter_write,3025 .llseek = generic_file_llseek,3026};3027#endif3028 3029#ifdef CONFIG_TASK_IO_ACCOUNTING3030static int do_io_accounting(struct task_struct *task, struct seq_file *m, int whole)3031{3032 struct task_io_accounting acct;3033 int result;3034 3035 result = down_read_killable(&task->signal->exec_update_lock);3036 if (result)3037 return result;3038 3039 if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) {3040 result = -EACCES;3041 goto out_unlock;3042 }3043 3044 if (whole) {3045 struct signal_struct *sig = task->signal;3046 struct task_struct *t;3047 unsigned int seq = 1;3048 unsigned long flags;3049 3050 rcu_read_lock();3051 do {3052 seq++; /* 2 on the 1st/lockless path, otherwise odd */3053 flags = read_seqbegin_or_lock_irqsave(&sig->stats_lock, &seq);3054 3055 acct = sig->ioac;3056 __for_each_thread(sig, t)3057 task_io_accounting_add(&acct, &t->ioac);3058 3059 } while (need_seqretry(&sig->stats_lock, seq));3060 done_seqretry_irqrestore(&sig->stats_lock, seq, flags);3061 rcu_read_unlock();3062 } else {3063 acct = task->ioac;3064 }3065 3066 seq_printf(m,3067 "rchar: %llu\n"3068 "wchar: %llu\n"3069 "syscr: %llu\n"3070 "syscw: %llu\n"3071 "read_bytes: %llu\n"3072 "write_bytes: %llu\n"3073 "cancelled_write_bytes: %llu\n",3074 (unsigned long long)acct.rchar,3075 (unsigned long long)acct.wchar,3076 (unsigned long long)acct.syscr,3077 (unsigned long long)acct.syscw,3078 (unsigned long long)acct.read_bytes,3079 (unsigned long long)acct.write_bytes,3080 (unsigned long long)acct.cancelled_write_bytes);3081 result = 0;3082 3083out_unlock:3084 up_read(&task->signal->exec_update_lock);3085 return result;3086}3087 3088static int proc_tid_io_accounting(struct seq_file *m, struct pid_namespace *ns,3089 struct pid *pid, struct task_struct *task)3090{3091 return do_io_accounting(task, m, 0);3092}3093 3094static int proc_tgid_io_accounting(struct seq_file *m, struct pid_namespace *ns,3095 struct pid *pid, struct task_struct *task)3096{3097 return do_io_accounting(task, m, 1);3098}3099#endif /* CONFIG_TASK_IO_ACCOUNTING */3100 3101#ifdef CONFIG_USER_NS3102static int proc_id_map_open(struct inode *inode, struct file *file,3103 const struct seq_operations *seq_ops)3104{3105 struct user_namespace *ns = NULL;3106 struct task_struct *task;3107 struct seq_file *seq;3108 int ret = -EINVAL;3109 3110 task = get_proc_task(inode);3111 if (task) {3112 rcu_read_lock();3113 ns = get_user_ns(task_cred_xxx(task, user_ns));3114 rcu_read_unlock();3115 put_task_struct(task);3116 }3117 if (!ns)3118 goto err;3119 3120 ret = seq_open(file, seq_ops);3121 if (ret)3122 goto err_put_ns;3123 3124 seq = file->private_data;3125 seq->private = ns;3126 3127 return 0;3128err_put_ns:3129 put_user_ns(ns);3130err:3131 return ret;3132}3133 3134static int proc_id_map_release(struct inode *inode, struct file *file)3135{3136 struct seq_file *seq = file->private_data;3137 struct user_namespace *ns = seq->private;3138 put_user_ns(ns);3139 return seq_release(inode, file);3140}3141 3142static int proc_uid_map_open(struct inode *inode, struct file *file)3143{3144 return proc_id_map_open(inode, file, &proc_uid_seq_operations);3145}3146 3147static int proc_gid_map_open(struct inode *inode, struct file *file)3148{3149 return proc_id_map_open(inode, file, &proc_gid_seq_operations);3150}3151 3152static int proc_projid_map_open(struct inode *inode, struct file *file)3153{3154 return proc_id_map_open(inode, file, &proc_projid_seq_operations);3155}3156 3157static const struct file_operations proc_uid_map_operations = {3158 .open = proc_uid_map_open,3159 .write = proc_uid_map_write,3160 .read = seq_read,3161 .llseek = seq_lseek,3162 .release = proc_id_map_release,3163};3164 3165static const struct file_operations proc_gid_map_operations = {3166 .open = proc_gid_map_open,3167 .write = proc_gid_map_write,3168 .read = seq_read,3169 .llseek = seq_lseek,3170 .release = proc_id_map_release,3171};3172 3173static const struct file_operations proc_projid_map_operations = {3174 .open = proc_projid_map_open,3175 .write = proc_projid_map_write,3176 .read = seq_read,3177 .llseek = seq_lseek,3178 .release = proc_id_map_release,3179};3180 3181static int proc_setgroups_open(struct inode *inode, struct file *file)3182{3183 struct user_namespace *ns = NULL;3184 struct task_struct *task;3185 int ret;3186 3187 ret = -ESRCH;3188 task = get_proc_task(inode);3189 if (task) {3190 rcu_read_lock();3191 ns = get_user_ns(task_cred_xxx(task, user_ns));3192 rcu_read_unlock();3193 put_task_struct(task);3194 }3195 if (!ns)3196 goto err;3197 3198 if (file->f_mode & FMODE_WRITE) {3199 ret = -EACCES;3200 if (!ns_capable(ns, CAP_SYS_ADMIN))3201 goto err_put_ns;3202 }3203 3204 ret = single_open(file, &proc_setgroups_show, ns);3205 if (ret)3206 goto err_put_ns;3207 3208 return 0;3209err_put_ns:3210 put_user_ns(ns);3211err:3212 return ret;3213}3214 3215static int proc_setgroups_release(struct inode *inode, struct file *file)3216{3217 struct seq_file *seq = file->private_data;3218 struct user_namespace *ns = seq->private;3219 int ret = single_release(inode, file);3220 put_user_ns(ns);3221 return ret;3222}3223 3224static const struct file_operations proc_setgroups_operations = {3225 .open = proc_setgroups_open,3226 .write = proc_setgroups_write,3227 .read = seq_read,3228 .llseek = seq_lseek,3229 .release = proc_setgroups_release,3230};3231#endif /* CONFIG_USER_NS */3232 3233static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,3234 struct pid *pid, struct task_struct *task)3235{3236 int err = lock_trace(task);3237 if (!err) {3238 seq_printf(m, "%08x\n", task->personality);3239 unlock_trace(task);3240 }3241 return err;3242}3243 3244#ifdef CONFIG_LIVEPATCH3245static int proc_pid_patch_state(struct seq_file *m, struct pid_namespace *ns,3246 struct pid *pid, struct task_struct *task)3247{3248 seq_printf(m, "%d\n", task->patch_state);3249 return 0;3250}3251#endif /* CONFIG_LIVEPATCH */3252 3253#ifdef CONFIG_KSM3254static int proc_pid_ksm_merging_pages(struct seq_file *m, struct pid_namespace *ns,3255 struct pid *pid, struct task_struct *task)3256{3257 struct mm_struct *mm;3258 3259 mm = get_task_mm(task);3260 if (mm) {3261 seq_printf(m, "%lu\n", mm->ksm_merging_pages);3262 mmput(mm);3263 }3264 3265 return 0;3266}3267static int proc_pid_ksm_stat(struct seq_file *m, struct pid_namespace *ns,3268 struct pid *pid, struct task_struct *task)3269{3270 struct mm_struct *mm;3271 3272 mm = get_task_mm(task);3273 if (mm) {3274 seq_printf(m, "ksm_rmap_items %lu\n", mm->ksm_rmap_items);3275 seq_printf(m, "ksm_zero_pages %ld\n", mm_ksm_zero_pages(mm));3276 seq_printf(m, "ksm_merging_pages %lu\n", mm->ksm_merging_pages);3277 seq_printf(m, "ksm_process_profit %ld\n", ksm_process_profit(mm));3278 mmput(mm);3279 }3280 3281 return 0;3282}3283#endif /* CONFIG_KSM */3284 3285#ifdef CONFIG_STACKLEAK_METRICS3286static int proc_stack_depth(struct seq_file *m, struct pid_namespace *ns,3287 struct pid *pid, struct task_struct *task)3288{3289 unsigned long prev_depth = THREAD_SIZE -3290 (task->prev_lowest_stack & (THREAD_SIZE - 1));3291 unsigned long depth = THREAD_SIZE -3292 (task->lowest_stack & (THREAD_SIZE - 1));3293 3294 seq_printf(m, "previous stack depth: %lu\nstack depth: %lu\n",3295 prev_depth, depth);3296 return 0;3297}3298#endif /* CONFIG_STACKLEAK_METRICS */3299 3300/*3301 * Thread groups3302 */3303static const struct file_operations proc_task_operations;3304static const struct inode_operations proc_task_inode_operations;3305 3306static const struct pid_entry tgid_base_stuff[] = {3307 DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),3308 DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),3309 DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),3310 DIR("fdinfo", S_IRUGO|S_IXUGO, proc_fdinfo_inode_operations, proc_fdinfo_operations),3311 DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),3312#ifdef CONFIG_NET3313 DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),3314#endif3315 REG("environ", S_IRUSR, proc_environ_operations),3316 REG("auxv", S_IRUSR, proc_auxv_operations),3317 ONE("status", S_IRUGO, proc_pid_status),3318 ONE("personality", S_IRUSR, proc_pid_personality),3319 ONE("limits", S_IRUGO, proc_pid_limits),3320#ifdef CONFIG_SCHED_DEBUG3321 REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations),3322#endif3323#ifdef CONFIG_SCHED_AUTOGROUP3324 REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),3325#endif3326#ifdef CONFIG_TIME_NS3327 REG("timens_offsets", S_IRUGO|S_IWUSR, proc_timens_offsets_operations),3328#endif3329 REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),3330#ifdef CONFIG_HAVE_ARCH_TRACEHOOK3331 ONE("syscall", S_IRUSR, proc_pid_syscall),3332#endif3333 REG("cmdline", S_IRUGO, proc_pid_cmdline_ops),3334 ONE("stat", S_IRUGO, proc_tgid_stat),3335 ONE("statm", S_IRUGO, proc_pid_statm),3336 REG("maps", S_IRUGO, proc_pid_maps_operations),3337#ifdef CONFIG_NUMA3338 REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations),3339#endif3340 REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),3341 LNK("cwd", proc_cwd_link),3342 LNK("root", proc_root_link),3343 LNK("exe", proc_exe_link),3344 REG("mounts", S_IRUGO, proc_mounts_operations),3345 REG("mountinfo", S_IRUGO, proc_mountinfo_operations),3346 REG("mountstats", S_IRUSR, proc_mountstats_operations),3347#ifdef CONFIG_PROC_PAGE_MONITOR3348 REG("clear_refs", S_IWUSR, proc_clear_refs_operations),3349 REG("smaps", S_IRUGO, proc_pid_smaps_operations),3350 REG("smaps_rollup", S_IRUGO, proc_pid_smaps_rollup_operations),3351 REG("pagemap", S_IRUSR, proc_pagemap_operations),3352#endif3353#ifdef CONFIG_SECURITY3354 DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),3355#endif3356#ifdef CONFIG_KALLSYMS3357 ONE("wchan", S_IRUGO, proc_pid_wchan),3358#endif3359#ifdef CONFIG_STACKTRACE3360 ONE("stack", S_IRUSR, proc_pid_stack),3361#endif3362#ifdef CONFIG_SCHED_INFO3363 ONE("schedstat", S_IRUGO, proc_pid_schedstat),3364#endif3365#ifdef CONFIG_LATENCYTOP3366 REG("latency", S_IRUGO, proc_lstats_operations),3367#endif3368#ifdef CONFIG_PROC_PID_CPUSET3369 ONE("cpuset", S_IRUGO, proc_cpuset_show),3370#endif3371#ifdef CONFIG_CGROUPS3372 ONE("cgroup", S_IRUGO, proc_cgroup_show),3373#endif3374#ifdef CONFIG_PROC_CPU_RESCTRL3375 ONE("cpu_resctrl_groups", S_IRUGO, proc_resctrl_show),3376#endif3377 ONE("oom_score", S_IRUGO, proc_oom_score),3378 REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations),3379 REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),3380#ifdef CONFIG_AUDIT3381 REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations),3382 REG("sessionid", S_IRUGO, proc_sessionid_operations),3383#endif3384#ifdef CONFIG_FAULT_INJECTION3385 REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),3386 REG("fail-nth", 0644, proc_fail_nth_operations),3387#endif3388#ifdef CONFIG_ELF_CORE3389 REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),3390#endif3391#ifdef CONFIG_TASK_IO_ACCOUNTING3392 ONE("io", S_IRUSR, proc_tgid_io_accounting),3393#endif3394#ifdef CONFIG_USER_NS3395 REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations),3396 REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations),3397 REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),3398 REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations),3399#endif3400#if defined(CONFIG_CHECKPOINT_RESTORE) && defined(CONFIG_POSIX_TIMERS)3401 REG("timers", S_IRUGO, proc_timers_operations),3402#endif3403 REG("timerslack_ns", S_IRUGO|S_IWUGO, proc_pid_set_timerslack_ns_operations),3404#ifdef CONFIG_LIVEPATCH3405 ONE("patch_state", S_IRUSR, proc_pid_patch_state),3406#endif3407#ifdef CONFIG_STACKLEAK_METRICS3408 ONE("stack_depth", S_IRUGO, proc_stack_depth),3409#endif3410#ifdef CONFIG_PROC_PID_ARCH_STATUS3411 ONE("arch_status", S_IRUGO, proc_pid_arch_status),3412#endif3413#ifdef CONFIG_SECCOMP_CACHE_DEBUG3414 ONE("seccomp_cache", S_IRUSR, proc_pid_seccomp_cache),3415#endif3416#ifdef CONFIG_KSM3417 ONE("ksm_merging_pages", S_IRUSR, proc_pid_ksm_merging_pages),3418 ONE("ksm_stat", S_IRUSR, proc_pid_ksm_stat),3419#endif3420};3421 3422static HWJS_SUSPENDS int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)3423{3424 return proc_pident_readdir(file, ctx,3425 tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));3426}3427 3428static const struct file_operations proc_tgid_base_operations = {3429 .read = generic_read_dir,3430 .iterate_shared = proc_tgid_base_readdir,3431 .llseek = generic_file_llseek,3432};3433 3434struct pid *tgid_pidfd_to_pid(const struct file *file)3435{3436 if (file->f_op != &proc_tgid_base_operations)3437 return ERR_PTR(-EBADF);3438 3439 return proc_pid(file_inode(file));3440}3441 3442static HWJS_SUSPENDS struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)3443{3444 return proc_pident_lookup(dir, dentry,3445 tgid_base_stuff,3446 tgid_base_stuff + ARRAY_SIZE(tgid_base_stuff));3447}3448 3449static const struct inode_operations proc_tgid_base_inode_operations = {3450 .lookup = proc_tgid_base_lookup,3451 .getattr = pid_getattr,3452 .setattr = proc_setattr,3453 .permission = proc_pid_permission,3454};3455 3456/**3457 * proc_flush_pid - Remove dcache entries for @pid from the /proc dcache.3458 * @pid: pid that should be flushed.3459 *3460 * This function walks a list of inodes (that belong to any proc3461 * filesystem) that are attached to the pid and flushes them from3462 * the dentry cache.3463 *3464 * It is safe and reasonable to cache /proc entries for a task until3465 * that task exits. After that they just clog up the dcache with3466 * useless entries, possibly causing useful dcache entries to be3467 * flushed instead. This routine is provided to flush those useless3468 * dcache entries when a process is reaped.3469 *3470 * NOTE: This routine is just an optimization so it does not guarantee3471 * that no dcache entries will exist after a process is reaped3472 * it just makes it very unlikely that any will persist.3473 */3474 3475void proc_flush_pid(struct pid *pid)3476{3477 proc_invalidate_siblings_dcache(&pid->inodes, &pid->lock);3478}3479 3480static HWJS_SUSPENDS struct dentry *proc_pid_instantiate(struct dentry * dentry,3481 struct task_struct *task, const void *ptr)3482{3483 struct inode *inode;3484 3485 inode = proc_pid_make_base_inode(dentry->d_sb, task,3486 S_IFDIR | S_IRUGO | S_IXUGO);3487 if (!inode)3488 return ERR_PTR(-ENOENT);3489 3490 inode->i_op = &proc_tgid_base_inode_operations;3491 inode->i_fop = &proc_tgid_base_operations;3492 inode->i_flags|=S_IMMUTABLE;3493 3494 set_nlink(inode, nlink_tgid);3495 pid_update_inode(task, inode);3496 3497 d_set_d_op(dentry, &pid_dentry_operations);3498 return d_splice_alias(inode, dentry);3499}3500 3501struct dentry *proc_pid_lookup(struct dentry *dentry, unsigned int flags)3502{3503 struct task_struct *task;3504 unsigned tgid;3505 struct proc_fs_info *fs_info;3506 struct pid_namespace *ns;3507 struct dentry *result = ERR_PTR(-ENOENT);3508 3509 tgid = name_to_int(&dentry->d_name);3510 if (tgid == ~0U)3511 goto out;3512 3513 fs_info = proc_sb_info(dentry->d_sb);3514 ns = fs_info->pid_ns;3515 rcu_read_lock();3516 task = find_task_by_pid_ns(tgid, ns);3517 if (task)3518 get_task_struct(task);3519 rcu_read_unlock();3520 if (!task)3521 goto out;3522 3523 /* Limit procfs to only ptraceable tasks */3524 if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE) {3525 if (!has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS))3526 goto out_put_task;3527 }3528 3529 result = proc_pid_instantiate(dentry, task, NULL);3530out_put_task:3531 put_task_struct(task);3532out:3533 return result;3534}3535 3536/*3537 * Find the first task with tgid >= tgid3538 *3539 */3540struct tgid_iter {3541 unsigned int tgid;3542 struct task_struct *task;3543};3544static HWJS_SUSPENDS struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)3545{3546 struct pid *pid;3547 3548 if (iter.task)3549 put_task_struct(iter.task);3550 rcu_read_lock();3551retry:3552 iter.task = NULL;3553 pid = find_ge_pid(iter.tgid, ns);3554 if (pid) {3555 iter.tgid = pid_nr_ns(pid, ns);3556 iter.task = pid_task(pid, PIDTYPE_TGID);3557 if (!iter.task) {3558 iter.tgid += 1;3559 goto retry;3560 }3561 get_task_struct(iter.task);3562 }3563 rcu_read_unlock();3564 return iter;3565}3566 3567#define TGID_OFFSET (FIRST_PROCESS_ENTRY + 2)3568 3569/* for the /proc/ directory itself, after non-process stuff has been done */3570int proc_pid_readdir(struct file *file, struct dir_context *ctx)3571{3572 struct tgid_iter iter;3573 struct proc_fs_info *fs_info = proc_sb_info(file_inode(file)->i_sb);3574 struct pid_namespace *ns = proc_pid_ns(file_inode(file)->i_sb);3575 loff_t pos = ctx->pos;3576 3577 if (pos >= PID_MAX_LIMIT + TGID_OFFSET)3578 return 0;3579 3580 if (pos == TGID_OFFSET - 2) {3581 struct inode *inode = d_inode(fs_info->proc_self);3582 if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))3583 return 0;3584 ctx->pos = pos = pos + 1;3585 }3586 if (pos == TGID_OFFSET - 1) {3587 struct inode *inode = d_inode(fs_info->proc_thread_self);3588 if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK))3589 return 0;3590 ctx->pos = pos = pos + 1;3591 }3592 iter.tgid = pos - TGID_OFFSET;3593 iter.task = NULL;3594 for (iter = next_tgid(ns, iter);3595 iter.task;3596 iter.tgid += 1, iter = next_tgid(ns, iter)) {3597 char name[10 + 1];3598 unsigned int len;3599 3600 cond_resched();3601 if (!has_pid_permissions(fs_info, iter.task, HIDEPID_INVISIBLE))3602 continue;3603 3604 len = snprintf(name, sizeof(name), "%u", iter.tgid);3605 ctx->pos = iter.tgid + TGID_OFFSET;3606 if (!proc_fill_cache(file, ctx, name, len,3607 proc_pid_instantiate, iter.task, NULL)) {3608 put_task_struct(iter.task);3609 return 0;3610 }3611 }3612 ctx->pos = PID_MAX_LIMIT + TGID_OFFSET;3613 return 0;3614}3615 3616/*3617 * proc_tid_comm_permission is a special permission function exclusively3618 * used for the node /proc/<pid>/task/<tid>/comm.3619 * It bypasses generic permission checks in the case where a task of the same3620 * task group attempts to access the node.3621 * The rationale behind this is that glibc and bionic access this node for3622 * cross thread naming (pthread_set/getname_np(!self)). However, if3623 * PR_SET_DUMPABLE gets set to 0 this node among others becomes uid=0 gid=0,3624 * which locks out the cross thread naming implementation.3625 * This function makes sure that the node is always accessible for members of3626 * same thread group.3627 */3628static HWJS_SUSPENDS int proc_tid_comm_permission(struct mnt_idmap *idmap,3629 struct inode *inode, int mask)3630{3631 bool is_same_tgroup;3632 struct task_struct *task;3633 3634 task = get_proc_task(inode);3635 if (!task)3636 return -ESRCH;3637 is_same_tgroup = same_thread_group(current, task);3638 put_task_struct(task);3639 3640 if (likely(is_same_tgroup && !(mask & MAY_EXEC))) {3641 /* This file (/proc/<pid>/task/<tid>/comm) can always be3642 * read or written by the members of the corresponding3643 * thread group.3644 */3645 return 0;3646 }3647 3648 return generic_permission(&nop_mnt_idmap, inode, mask);3649}3650 3651static const struct inode_operations proc_tid_comm_inode_operations = {3652 .setattr = proc_setattr,3653 .permission = proc_tid_comm_permission,3654};3655 3656/*3657 * Tasks3658 */3659static const struct pid_entry tid_base_stuff[] = {3660 DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),3661 DIR("fdinfo", S_IRUGO|S_IXUGO, proc_fdinfo_inode_operations, proc_fdinfo_operations),3662 DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),3663#ifdef CONFIG_NET3664 DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),3665#endif3666 REG("environ", S_IRUSR, proc_environ_operations),3667 REG("auxv", S_IRUSR, proc_auxv_operations),3668 ONE("status", S_IRUGO, proc_pid_status),3669 ONE("personality", S_IRUSR, proc_pid_personality),3670 ONE("limits", S_IRUGO, proc_pid_limits),3671#ifdef CONFIG_SCHED_DEBUG3672 REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations),3673#endif3674 NOD("comm", S_IFREG|S_IRUGO|S_IWUSR,3675 &proc_tid_comm_inode_operations,3676 &proc_pid_set_comm_operations, {}),3677#ifdef CONFIG_HAVE_ARCH_TRACEHOOK3678 ONE("syscall", S_IRUSR, proc_pid_syscall),3679#endif3680 REG("cmdline", S_IRUGO, proc_pid_cmdline_ops),3681 ONE("stat", S_IRUGO, proc_tid_stat),3682 ONE("statm", S_IRUGO, proc_pid_statm),3683 REG("maps", S_IRUGO, proc_pid_maps_operations),3684#ifdef CONFIG_PROC_CHILDREN3685 REG("children", S_IRUGO, proc_tid_children_operations),3686#endif3687#ifdef CONFIG_NUMA3688 REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations),3689#endif3690 REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),3691 LNK("cwd", proc_cwd_link),3692 LNK("root", proc_root_link),3693 LNK("exe", proc_exe_link),3694 REG("mounts", S_IRUGO, proc_mounts_operations),3695 REG("mountinfo", S_IRUGO, proc_mountinfo_operations),3696#ifdef CONFIG_PROC_PAGE_MONITOR3697 REG("clear_refs", S_IWUSR, proc_clear_refs_operations),3698 REG("smaps", S_IRUGO, proc_pid_smaps_operations),3699 REG("smaps_rollup", S_IRUGO, proc_pid_smaps_rollup_operations),3700 REG("pagemap", S_IRUSR, proc_pagemap_operations),3701#endif3702#ifdef CONFIG_SECURITY3703 DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),3704#endif3705#ifdef CONFIG_KALLSYMS3706 ONE("wchan", S_IRUGO, proc_pid_wchan),3707#endif3708#ifdef CONFIG_STACKTRACE3709 ONE("stack", S_IRUSR, proc_pid_stack),3710#endif3711#ifdef CONFIG_SCHED_INFO3712 ONE("schedstat", S_IRUGO, proc_pid_schedstat),3713#endif3714#ifdef CONFIG_LATENCYTOP3715 REG("latency", S_IRUGO, proc_lstats_operations),3716#endif3717#ifdef CONFIG_PROC_PID_CPUSET3718 ONE("cpuset", S_IRUGO, proc_cpuset_show),3719#endif3720#ifdef CONFIG_CGROUPS3721 ONE("cgroup", S_IRUGO, proc_cgroup_show),3722#endif3723#ifdef CONFIG_PROC_CPU_RESCTRL3724 ONE("cpu_resctrl_groups", S_IRUGO, proc_resctrl_show),3725#endif3726 ONE("oom_score", S_IRUGO, proc_oom_score),3727 REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations),3728 REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),3729#ifdef CONFIG_AUDIT3730 REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations),3731 REG("sessionid", S_IRUGO, proc_sessionid_operations),3732#endif3733#ifdef CONFIG_FAULT_INJECTION3734 REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),3735 REG("fail-nth", 0644, proc_fail_nth_operations),3736#endif3737#ifdef CONFIG_TASK_IO_ACCOUNTING3738 ONE("io", S_IRUSR, proc_tid_io_accounting),3739#endif3740#ifdef CONFIG_USER_NS3741 REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations),3742 REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations),3743 REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),3744 REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations),3745#endif3746#ifdef CONFIG_LIVEPATCH3747 ONE("patch_state", S_IRUSR, proc_pid_patch_state),3748#endif3749#ifdef CONFIG_PROC_PID_ARCH_STATUS3750 ONE("arch_status", S_IRUGO, proc_pid_arch_status),3751#endif3752#ifdef CONFIG_SECCOMP_CACHE_DEBUG3753 ONE("seccomp_cache", S_IRUSR, proc_pid_seccomp_cache),3754#endif3755#ifdef CONFIG_KSM3756 ONE("ksm_merging_pages", S_IRUSR, proc_pid_ksm_merging_pages),3757 ONE("ksm_stat", S_IRUSR, proc_pid_ksm_stat),3758#endif3759};3760 3761static HWJS_SUSPENDS int proc_tid_base_readdir(struct file *file, struct dir_context *ctx)3762{3763 return proc_pident_readdir(file, ctx,3764 tid_base_stuff, ARRAY_SIZE(tid_base_stuff));3765}3766 3767static HWJS_SUSPENDS struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)3768{3769 return proc_pident_lookup(dir, dentry,3770 tid_base_stuff,3771 tid_base_stuff + ARRAY_SIZE(tid_base_stuff));3772}3773 3774static const struct file_operations proc_tid_base_operations = {3775 .read = generic_read_dir,3776 .iterate_shared = proc_tid_base_readdir,3777 .llseek = generic_file_llseek,3778};3779 3780static const struct inode_operations proc_tid_base_inode_operations = {3781 .lookup = proc_tid_base_lookup,3782 .getattr = pid_getattr,3783 .setattr = proc_setattr,3784};3785 3786static HWJS_SUSPENDS struct dentry *proc_task_instantiate(struct dentry *dentry,3787 struct task_struct *task, const void *ptr)3788{3789 struct inode *inode;3790 inode = proc_pid_make_base_inode(dentry->d_sb, task,3791 S_IFDIR | S_IRUGO | S_IXUGO);3792 if (!inode)3793 return ERR_PTR(-ENOENT);3794 3795 inode->i_op = &proc_tid_base_inode_operations;3796 inode->i_fop = &proc_tid_base_operations;3797 inode->i_flags |= S_IMMUTABLE;3798 3799 set_nlink(inode, nlink_tid);3800 pid_update_inode(task, inode);3801 3802 d_set_d_op(dentry, &pid_dentry_operations);3803 return d_splice_alias(inode, dentry);3804}3805 3806static HWJS_SUSPENDS struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)3807{3808 struct task_struct *task;3809 struct task_struct *leader = get_proc_task(dir);3810 unsigned tid;3811 struct proc_fs_info *fs_info;3812 struct pid_namespace *ns;3813 struct dentry *result = ERR_PTR(-ENOENT);3814 3815 if (!leader)3816 goto out_no_task;3817 3818 tid = name_to_int(&dentry->d_name);3819 if (tid == ~0U)3820 goto out;3821 3822 fs_info = proc_sb_info(dentry->d_sb);3823 ns = fs_info->pid_ns;3824 rcu_read_lock();3825 task = find_task_by_pid_ns(tid, ns);3826 if (task)3827 get_task_struct(task);3828 rcu_read_unlock();3829 if (!task)3830 goto out;3831 if (!same_thread_group(leader, task))3832 goto out_drop_task;3833 3834 result = proc_task_instantiate(dentry, task, NULL);3835out_drop_task:3836 put_task_struct(task);3837out:3838 put_task_struct(leader);3839out_no_task:3840 return result;3841}3842 3843/*3844 * Find the first tid of a thread group to return to user space.3845 *3846 * Usually this is just the thread group leader, but if the users3847 * buffer was too small or there was a seek into the middle of the3848 * directory we have more work todo.3849 *3850 * In the case of a short read we start with find_task_by_pid.3851 *3852 * In the case of a seek we start with the leader and walk nr3853 * threads past it.3854 */3855static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos,3856 struct pid_namespace *ns)3857{3858 struct task_struct *pos, *task;3859 unsigned long nr = f_pos;3860 3861 if (nr != f_pos) /* 32bit overflow? */3862 return NULL;3863 3864 rcu_read_lock();3865 task = pid_task(pid, PIDTYPE_PID);3866 if (!task)3867 goto fail;3868 3869 /* Attempt to start with the tid of a thread */3870 if (tid && nr) {3871 pos = find_task_by_pid_ns(tid, ns);3872 if (pos && same_thread_group(pos, task))3873 goto found;3874 }3875 3876 /* If nr exceeds the number of threads there is nothing todo */3877 if (nr >= get_nr_threads(task))3878 goto fail;3879 3880 /* If we haven't found our starting place yet start3881 * with the leader and walk nr threads forward.3882 */3883 for_each_thread(task, pos) {3884 if (!nr--)3885 goto found;3886 }3887fail:3888 pos = NULL;3889 goto out;3890found:3891 get_task_struct(pos);3892out:3893 rcu_read_unlock();3894 return pos;3895}3896 3897/*3898 * Find the next thread in the thread list.3899 * Return NULL if there is an error or no next thread.3900 *3901 * The reference to the input task_struct is released.3902 */3903static HWJS_SUSPENDS struct task_struct *next_tid(struct task_struct *start)3904{3905 struct task_struct *pos = NULL;3906 rcu_read_lock();3907 if (pid_alive(start)) {3908 pos = __next_thread(start);3909 if (pos)3910 get_task_struct(pos);3911 }3912 rcu_read_unlock();3913 put_task_struct(start);3914 return pos;3915}3916 3917/* for the /proc/TGID/task/ directories */3918static HWJS_SUSPENDS int proc_task_readdir(struct file *file, struct dir_context *ctx)3919{3920 struct inode *inode = file_inode(file);3921 struct task_struct *task;3922 struct pid_namespace *ns;3923 int tid;3924 3925 if (proc_inode_is_dead(inode))3926 return -ENOENT;3927 3928 if (!dir_emit_dots(file, ctx))3929 return 0;3930 3931 /* We cache the tgid value that the last readdir call couldn't3932 * return and lseek resets it to 0.3933 */3934 ns = proc_pid_ns(inode->i_sb);3935 tid = (int)(intptr_t)file->private_data;3936 file->private_data = NULL;3937 for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);3938 task;3939 task = next_tid(task), ctx->pos++) {3940 char name[10 + 1];3941 unsigned int len;3942 3943 tid = task_pid_nr_ns(task, ns);3944 if (!tid)3945 continue; /* The task has just exited. */3946 len = snprintf(name, sizeof(name), "%u", tid);3947 if (!proc_fill_cache(file, ctx, name, len,3948 proc_task_instantiate, task, NULL)) {3949 /* returning this tgid failed, save it as the first3950 * pid for the next readir call */3951 file->private_data = (void *)(intptr_t)tid;3952 put_task_struct(task);3953 break;3954 }3955 }3956 3957 return 0;3958}3959 3960static HWJS_SUSPENDS int proc_task_getattr(struct mnt_idmap *idmap,3961 const struct path *path, struct kstat *stat,3962 u32 request_mask, unsigned int query_flags)3963{3964 struct inode *inode = d_inode(path->dentry);3965 struct task_struct *p = get_proc_task(inode);3966 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);3967 3968 if (p) {3969 stat->nlink += get_nr_threads(p);3970 put_task_struct(p);3971 }3972 3973 return 0;3974}3975 3976/*3977 * proc_task_readdir() set @file->private_data to a positive integer3978 * value, so casting that to u64 is safe. generic_llseek_cookie() will3979 * set @cookie to 0, so casting to an int is safe. The WARN_ON_ONCE() is3980 * here to catch any unexpected change in behavior either in3981 * proc_task_readdir() or generic_llseek_cookie().3982 */3983static loff_t proc_dir_llseek(struct file *file, loff_t offset, int whence)3984{3985 u64 cookie = (u64)(intptr_t)file->private_data;3986 loff_t off;3987 3988 off = generic_llseek_cookie(file, offset, whence, &cookie);3989 WARN_ON_ONCE(cookie > INT_MAX);3990 file->private_data = (void *)(intptr_t)cookie; /* serialized by f_pos_lock */3991 return off;3992}3993 3994static const struct inode_operations proc_task_inode_operations = {3995 .lookup = proc_task_lookup,3996 .getattr = proc_task_getattr,3997 .setattr = proc_setattr,3998 .permission = proc_pid_permission,3999};4000 4001static const struct file_operations proc_task_operations = {4002 .read = generic_read_dir,4003 .iterate_shared = proc_task_readdir,4004 .llseek = proc_dir_llseek,4005};4006 4007void __init set_proc_pid_nlink(void)4008{4009 nlink_tid = pid_entry_nlink(tid_base_stuff, ARRAY_SIZE(tid_base_stuff));4010 nlink_tgid = pid_entry_nlink(tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));4011}4012