1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * linux/fs/proc/base.c 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * proc base directory handling functions 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * 1999, Al Viro. Rewritten. Now it covers the whole per-process part. 101da177e4SLinus Torvalds * Instead of using magical inumbers to determine the kind of object 111da177e4SLinus Torvalds * we allocate and fill in-core inodes upon lookup. They don't even 121da177e4SLinus Torvalds * go into icache. We cache the reference to task_struct upon lookup too. 131da177e4SLinus Torvalds * Eventually it should become a filesystem in its own. We don't use the 141da177e4SLinus Torvalds * rest of procfs anymore. 15e070ad49SMauricio Lin * 16e070ad49SMauricio Lin * 17e070ad49SMauricio Lin * Changelog: 18e070ad49SMauricio Lin * 17-Jan-2005 19e070ad49SMauricio Lin * Allan Bezerra 20e070ad49SMauricio Lin * Bruna Moreira <bruna.moreira@indt.org.br> 21e070ad49SMauricio Lin * Edjard Mota <edjard.mota@indt.org.br> 22e070ad49SMauricio Lin * Ilias Biris <ilias.biris@indt.org.br> 23e070ad49SMauricio Lin * Mauricio Lin <mauricio.lin@indt.org.br> 24e070ad49SMauricio Lin * 25e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 26e070ad49SMauricio Lin * 27e070ad49SMauricio Lin * A new process specific entry (smaps) included in /proc. It shows the 28e070ad49SMauricio Lin * size of rss for each memory area. The maps entry lacks information 29e070ad49SMauricio Lin * about physical memory size (rss) for each mapped file, i.e., 30e070ad49SMauricio Lin * rss information for executables and library files. 31e070ad49SMauricio Lin * This additional information is useful for any tools that need to know 32e070ad49SMauricio Lin * about physical memory consumption for a process specific library. 33e070ad49SMauricio Lin * 34e070ad49SMauricio Lin * Changelog: 35e070ad49SMauricio Lin * 21-Feb-2005 36e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 37e070ad49SMauricio Lin * Pud inclusion in the page table walking. 38e070ad49SMauricio Lin * 39e070ad49SMauricio Lin * ChangeLog: 40e070ad49SMauricio Lin * 10-Mar-2005 41e070ad49SMauricio Lin * 10LE Instituto Nokia de Tecnologia - INdT: 42e070ad49SMauricio Lin * A better way to walks through the page table as suggested by Hugh Dickins. 43e070ad49SMauricio Lin * 44e070ad49SMauricio Lin * Simo Piiroinen <simo.piiroinen@nokia.com>: 45e070ad49SMauricio Lin * Smaps information related to shared, private, clean and dirty pages. 46e070ad49SMauricio Lin * 47e070ad49SMauricio Lin * Paul Mundt <paul.mundt@nokia.com>: 48e070ad49SMauricio Lin * Overall revision about smaps. 491da177e4SLinus Torvalds */ 501da177e4SLinus Torvalds 517c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds #include <linux/errno.h> 541da177e4SLinus Torvalds #include <linux/time.h> 551da177e4SLinus Torvalds #include <linux/proc_fs.h> 561da177e4SLinus Torvalds #include <linux/stat.h> 575995477aSAndrea Righi #include <linux/task_io_accounting_ops.h> 581da177e4SLinus Torvalds #include <linux/init.h> 5916f7e0feSRandy Dunlap #include <linux/capability.h> 601da177e4SLinus Torvalds #include <linux/file.h> 619f3acc31SAl Viro #include <linux/fdtable.h> 6294f8f3b0SKent Overstreet #include <linux/generic-radix-tree.h> 631da177e4SLinus Torvalds #include <linux/string.h> 641da177e4SLinus Torvalds #include <linux/seq_file.h> 651da177e4SLinus Torvalds #include <linux/namei.h> 666b3286edSKirill Korotaev #include <linux/mnt_namespace.h> 671da177e4SLinus Torvalds #include <linux/mm.h> 68a63d83f4SDavid Rientjes #include <linux/swap.h> 69b835996fSDipankar Sarma #include <linux/rcupdate.h> 701da177e4SLinus Torvalds #include <linux/kallsyms.h> 712ec220e2SKen Chen #include <linux/stacktrace.h> 72d85f50d5SNeil Horman #include <linux/resource.h> 735096add8SKees Cook #include <linux/module.h> 741da177e4SLinus Torvalds #include <linux/mount.h> 751da177e4SLinus Torvalds #include <linux/security.h> 761da177e4SLinus Torvalds #include <linux/ptrace.h> 770d094efeSRoland McGrath #include <linux/tracehook.h> 7887ebdc00SAndrew Morton #include <linux/printk.h> 79efb1a57dSAlexey Dobriyan #include <linux/cache.h> 80a424316cSPaul Menage #include <linux/cgroup.h> 811da177e4SLinus Torvalds #include <linux/cpuset.h> 821da177e4SLinus Torvalds #include <linux/audit.h> 835addc5ddSAl Viro #include <linux/poll.h> 841651e14eSSerge E. Hallyn #include <linux/nsproxy.h> 858ac773b4SAlexey Dobriyan #include <linux/oom.h> 863cb4a0bbSKawai, Hidehiro #include <linux/elf.h> 8760347f67SPavel Emelyanov #include <linux/pid_namespace.h> 8822d917d8SEric W. Biederman #include <linux/user_namespace.h> 895ad4e53bSAl Viro #include <linux/fs_struct.h> 905a0e3ad6STejun Heo #include <linux/slab.h> 914eb5aaa3SIngo Molnar #include <linux/sched/autogroup.h> 926e84f315SIngo Molnar #include <linux/sched/mm.h> 93f7ccbae4SIngo Molnar #include <linux/sched/coredump.h> 94b17b0153SIngo Molnar #include <linux/sched/debug.h> 953905f9adSIngo Molnar #include <linux/sched/stat.h> 9648f6a7a5SPavel Emelyanov #include <linux/posix-timers.h> 9704a8682aSAndrei Vagin #include <linux/time_namespace.h> 98e79f15a4SChen Yu #include <linux/resctrl.h> 9943d2b113SKAMEZAWA Hiroyuki #include <trace/events/oom.h> 1001da177e4SLinus Torvalds #include "internal.h" 101faf60af1SCyrill Gorcunov #include "fd.h" 1021da177e4SLinus Torvalds 103ac7f1061SAlexey Dobriyan #include "../../lib/kstrtox.h" 104ac7f1061SAlexey Dobriyan 1050f2fe20fSEric W. Biederman /* NOTE: 1060f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 1070f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 1080f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 1090f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 1100f2fe20fSEric W. Biederman * 1110f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 1120f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 1130f2fe20fSEric W. Biederman */ 1140f2fe20fSEric W. Biederman 115efb1a57dSAlexey Dobriyan static u8 nlink_tid __ro_after_init; 116efb1a57dSAlexey Dobriyan static u8 nlink_tgid __ro_after_init; 1171270dd8dSAlexey Dobriyan 1181da177e4SLinus Torvalds struct pid_entry { 119cedbccabSAlexey Dobriyan const char *name; 120623f594eSAlexey Dobriyan unsigned int len; 121d161a13fSAl Viro umode_t mode; 122c5ef1c42SArjan van de Ven const struct inode_operations *iop; 12300977a59SArjan van de Ven const struct file_operations *fop; 12420cdc894SEric W. Biederman union proc_op op; 1251da177e4SLinus Torvalds }; 1261da177e4SLinus Torvalds 12761a28784SEric W. Biederman #define NOD(NAME, MODE, IOP, FOP, OP) { \ 12820cdc894SEric W. Biederman .name = (NAME), \ 129c5141e6dSEric Dumazet .len = sizeof(NAME) - 1, \ 13020cdc894SEric W. Biederman .mode = MODE, \ 13120cdc894SEric W. Biederman .iop = IOP, \ 13220cdc894SEric W. Biederman .fop = FOP, \ 13320cdc894SEric W. Biederman .op = OP, \ 13420cdc894SEric W. Biederman } 13520cdc894SEric W. Biederman 136631f9c18SAlexey Dobriyan #define DIR(NAME, MODE, iops, fops) \ 137631f9c18SAlexey Dobriyan NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} ) 138631f9c18SAlexey Dobriyan #define LNK(NAME, get_link) \ 13961a28784SEric W. Biederman NOD(NAME, (S_IFLNK|S_IRWXUGO), \ 14020cdc894SEric W. Biederman &proc_pid_link_inode_operations, NULL, \ 141631f9c18SAlexey Dobriyan { .proc_get_link = get_link } ) 142631f9c18SAlexey Dobriyan #define REG(NAME, MODE, fops) \ 143631f9c18SAlexey Dobriyan NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {}) 144631f9c18SAlexey Dobriyan #define ONE(NAME, MODE, show) \ 145be614086SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 146be614086SEric W. Biederman NULL, &proc_single_file_operations, \ 147631f9c18SAlexey Dobriyan { .proc_show = show } ) 1486d9c939dSCasey Schaufler #define ATTR(LSM, NAME, MODE) \ 1496d9c939dSCasey Schaufler NOD(NAME, (S_IFREG|(MODE)), \ 1506d9c939dSCasey Schaufler NULL, &proc_pid_attr_operations, \ 1516d9c939dSCasey Schaufler { .lsm = LSM }) 1521da177e4SLinus Torvalds 153aed54175SVegard Nossum /* 154aed54175SVegard Nossum * Count the number of hardlinks for the pid_entry table, excluding the . 155aed54175SVegard Nossum * and .. links. 156aed54175SVegard Nossum */ 1571270dd8dSAlexey Dobriyan static unsigned int __init pid_entry_nlink(const struct pid_entry *entries, 158aed54175SVegard Nossum unsigned int n) 159aed54175SVegard Nossum { 160aed54175SVegard Nossum unsigned int i; 161aed54175SVegard Nossum unsigned int count; 162aed54175SVegard Nossum 1631270dd8dSAlexey Dobriyan count = 2; 164aed54175SVegard Nossum for (i = 0; i < n; ++i) { 165aed54175SVegard Nossum if (S_ISDIR(entries[i].mode)) 166aed54175SVegard Nossum ++count; 167aed54175SVegard Nossum } 168aed54175SVegard Nossum 169aed54175SVegard Nossum return count; 170aed54175SVegard Nossum } 171aed54175SVegard Nossum 172f7ad3c6bSMiklos Szeredi static int get_task_root(struct task_struct *task, struct path *root) 1731da177e4SLinus Torvalds { 1747c2c7d99SHugh Dickins int result = -ENOENT; 1757c2c7d99SHugh Dickins 1760494f6ecSMiklos Szeredi task_lock(task); 177f7ad3c6bSMiklos Szeredi if (task->fs) { 178f7ad3c6bSMiklos Szeredi get_fs_root(task->fs, root); 1797c2c7d99SHugh Dickins result = 0; 1807c2c7d99SHugh Dickins } 1810494f6ecSMiklos Szeredi task_unlock(task); 1827c2c7d99SHugh Dickins return result; 1830494f6ecSMiklos Szeredi } 1840494f6ecSMiklos Szeredi 1857773fbc5SCyrill Gorcunov static int proc_cwd_link(struct dentry *dentry, struct path *path) 1860494f6ecSMiklos Szeredi { 1872b0143b5SDavid Howells struct task_struct *task = get_proc_task(d_inode(dentry)); 1880494f6ecSMiklos Szeredi int result = -ENOENT; 18999f89551SEric W. Biederman 19099f89551SEric W. Biederman if (task) { 191f7ad3c6bSMiklos Szeredi task_lock(task); 192f7ad3c6bSMiklos Szeredi if (task->fs) { 193f7ad3c6bSMiklos Szeredi get_fs_pwd(task->fs, path); 194f7ad3c6bSMiklos Szeredi result = 0; 195f7ad3c6bSMiklos Szeredi } 196f7ad3c6bSMiklos Szeredi task_unlock(task); 19799f89551SEric W. Biederman put_task_struct(task); 19899f89551SEric W. Biederman } 1991da177e4SLinus Torvalds return result; 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds 2027773fbc5SCyrill Gorcunov static int proc_root_link(struct dentry *dentry, struct path *path) 2031da177e4SLinus Torvalds { 2042b0143b5SDavid Howells struct task_struct *task = get_proc_task(d_inode(dentry)); 2051da177e4SLinus Torvalds int result = -ENOENT; 20699f89551SEric W. Biederman 20799f89551SEric W. Biederman if (task) { 208f7ad3c6bSMiklos Szeredi result = get_task_root(task, path); 20999f89551SEric W. Biederman put_task_struct(task); 21099f89551SEric W. Biederman } 2111da177e4SLinus Torvalds return result; 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds 214d26d0cd9SLinus Torvalds /* 215d26d0cd9SLinus Torvalds * If the user used setproctitle(), we just get the string from 216d26d0cd9SLinus Torvalds * user space at arg_start, and limit it to a maximum of one page. 217d26d0cd9SLinus Torvalds */ 218d26d0cd9SLinus Torvalds static ssize_t get_mm_proctitle(struct mm_struct *mm, char __user *buf, 219d26d0cd9SLinus Torvalds size_t count, unsigned long pos, 220d26d0cd9SLinus Torvalds unsigned long arg_start) 221d26d0cd9SLinus Torvalds { 222d26d0cd9SLinus Torvalds char *page; 223d26d0cd9SLinus Torvalds int ret, got; 224d26d0cd9SLinus Torvalds 225d26d0cd9SLinus Torvalds if (pos >= PAGE_SIZE) 226d26d0cd9SLinus Torvalds return 0; 227d26d0cd9SLinus Torvalds 228d26d0cd9SLinus Torvalds page = (char *)__get_free_page(GFP_KERNEL); 229d26d0cd9SLinus Torvalds if (!page) 230d26d0cd9SLinus Torvalds return -ENOMEM; 231d26d0cd9SLinus Torvalds 232d26d0cd9SLinus Torvalds ret = 0; 233d26d0cd9SLinus Torvalds got = access_remote_vm(mm, arg_start, page, PAGE_SIZE, FOLL_ANON); 234d26d0cd9SLinus Torvalds if (got > 0) { 235d26d0cd9SLinus Torvalds int len = strnlen(page, got); 236d26d0cd9SLinus Torvalds 237d26d0cd9SLinus Torvalds /* Include the NUL character if it was found */ 238d26d0cd9SLinus Torvalds if (len < got) 239d26d0cd9SLinus Torvalds len++; 240d26d0cd9SLinus Torvalds 241d26d0cd9SLinus Torvalds if (len > pos) { 242d26d0cd9SLinus Torvalds len -= pos; 243d26d0cd9SLinus Torvalds if (len > count) 244d26d0cd9SLinus Torvalds len = count; 245d26d0cd9SLinus Torvalds len -= copy_to_user(buf, page+pos, len); 246d26d0cd9SLinus Torvalds if (!len) 247d26d0cd9SLinus Torvalds len = -EFAULT; 248d26d0cd9SLinus Torvalds ret = len; 249d26d0cd9SLinus Torvalds } 250d26d0cd9SLinus Torvalds } 251d26d0cd9SLinus Torvalds free_page((unsigned long)page); 252d26d0cd9SLinus Torvalds return ret; 253d26d0cd9SLinus Torvalds } 254d26d0cd9SLinus Torvalds 255e4b4e441SLinus Torvalds static ssize_t get_mm_cmdline(struct mm_struct *mm, char __user *buf, 2565ab82718SLinus Torvalds size_t count, loff_t *ppos) 2571da177e4SLinus Torvalds { 258c2c0bb44SAlexey Dobriyan unsigned long arg_start, arg_end, env_start, env_end; 2595ab82718SLinus Torvalds unsigned long pos, len; 260d26d0cd9SLinus Torvalds char *page, c; 261c2c0bb44SAlexey Dobriyan 262c2c0bb44SAlexey Dobriyan /* Check if process spawned far enough to have cmdline. */ 263e4b4e441SLinus Torvalds if (!mm->env_end) 264e4b4e441SLinus Torvalds return 0; 265c2c0bb44SAlexey Dobriyan 26688aa7cc6SYang Shi spin_lock(&mm->arg_lock); 267c2c0bb44SAlexey Dobriyan arg_start = mm->arg_start; 268c2c0bb44SAlexey Dobriyan arg_end = mm->arg_end; 269c2c0bb44SAlexey Dobriyan env_start = mm->env_start; 270c2c0bb44SAlexey Dobriyan env_end = mm->env_end; 27188aa7cc6SYang Shi spin_unlock(&mm->arg_lock); 272c2c0bb44SAlexey Dobriyan 2735ab82718SLinus Torvalds if (arg_start >= arg_end) 2745ab82718SLinus Torvalds return 0; 2756a6cbe75SAlexey Dobriyan 276c2c0bb44SAlexey Dobriyan /* 277d26d0cd9SLinus Torvalds * We allow setproctitle() to overwrite the argument 278d26d0cd9SLinus Torvalds * strings, and overflow past the original end. But 279d26d0cd9SLinus Torvalds * only when it overflows into the environment area. 280c2c0bb44SAlexey Dobriyan */ 281d26d0cd9SLinus Torvalds if (env_start != arg_end || env_end < env_start) 2825ab82718SLinus Torvalds env_start = env_end = arg_end; 283d26d0cd9SLinus Torvalds len = env_end - arg_start; 284f5b65348SLinus Torvalds 2855ab82718SLinus Torvalds /* We're not going to care if "*ppos" has high bits set */ 286d26d0cd9SLinus Torvalds pos = *ppos; 287d26d0cd9SLinus Torvalds if (pos >= len) 288d26d0cd9SLinus Torvalds return 0; 289d26d0cd9SLinus Torvalds if (count > len - pos) 290d26d0cd9SLinus Torvalds count = len - pos; 291d26d0cd9SLinus Torvalds if (!count) 2925ab82718SLinus Torvalds return 0; 293c2c0bb44SAlexey Dobriyan 294d26d0cd9SLinus Torvalds /* 295d26d0cd9SLinus Torvalds * Magical special case: if the argv[] end byte is not 296d26d0cd9SLinus Torvalds * zero, the user has overwritten it with setproctitle(3). 297d26d0cd9SLinus Torvalds * 298d26d0cd9SLinus Torvalds * Possible future enhancement: do this only once when 299d26d0cd9SLinus Torvalds * pos is 0, and set a flag in the 'struct file'. 300d26d0cd9SLinus Torvalds */ 301d26d0cd9SLinus Torvalds if (access_remote_vm(mm, arg_end-1, &c, 1, FOLL_ANON) == 1 && c) 302d26d0cd9SLinus Torvalds return get_mm_proctitle(mm, buf, count, pos, arg_start); 303d26d0cd9SLinus Torvalds 304d26d0cd9SLinus Torvalds /* 305d26d0cd9SLinus Torvalds * For the non-setproctitle() case we limit things strictly 306d26d0cd9SLinus Torvalds * to the [arg_start, arg_end[ range. 307d26d0cd9SLinus Torvalds */ 308d26d0cd9SLinus Torvalds pos += arg_start; 3093d712546SLinus Torvalds if (pos < arg_start || pos >= arg_end) 310c2c0bb44SAlexey Dobriyan return 0; 3113d712546SLinus Torvalds if (count > arg_end - pos) 3123d712546SLinus Torvalds count = arg_end - pos; 3133cb4e162SAlexey Dobriyan 3145ab82718SLinus Torvalds page = (char *)__get_free_page(GFP_KERNEL); 3155ab82718SLinus Torvalds if (!page) 3165ab82718SLinus Torvalds return -ENOMEM; 317c2c0bb44SAlexey Dobriyan 3185ab82718SLinus Torvalds len = 0; 3195ab82718SLinus Torvalds while (count) { 3205ab82718SLinus Torvalds int got; 3215ab82718SLinus Torvalds size_t size = min_t(size_t, PAGE_SIZE, count); 3225ab82718SLinus Torvalds 3233d712546SLinus Torvalds got = access_remote_vm(mm, pos, page, size, FOLL_ANON); 3243d712546SLinus Torvalds if (got <= 0) 3255ab82718SLinus Torvalds break; 3263d712546SLinus Torvalds got -= copy_to_user(buf, page, got); 3275ab82718SLinus Torvalds if (unlikely(!got)) { 3285ab82718SLinus Torvalds if (!len) 3295ab82718SLinus Torvalds len = -EFAULT; 3305ab82718SLinus Torvalds break; 3315ab82718SLinus Torvalds } 3325ab82718SLinus Torvalds pos += got; 3335ab82718SLinus Torvalds buf += got; 3345ab82718SLinus Torvalds len += got; 3355ab82718SLinus Torvalds count -= got; 336c2c0bb44SAlexey Dobriyan } 337a0a07b87SAlexey Dobriyan 338c2c0bb44SAlexey Dobriyan free_page((unsigned long)page); 3395ab82718SLinus Torvalds return len; 340c2c0bb44SAlexey Dobriyan } 341c2c0bb44SAlexey Dobriyan 342e4b4e441SLinus Torvalds static ssize_t get_task_cmdline(struct task_struct *tsk, char __user *buf, 343e4b4e441SLinus Torvalds size_t count, loff_t *pos) 344e4b4e441SLinus Torvalds { 345e4b4e441SLinus Torvalds struct mm_struct *mm; 346e4b4e441SLinus Torvalds ssize_t ret; 347e4b4e441SLinus Torvalds 348e4b4e441SLinus Torvalds mm = get_task_mm(tsk); 349e4b4e441SLinus Torvalds if (!mm) 350e4b4e441SLinus Torvalds return 0; 351e4b4e441SLinus Torvalds 352e4b4e441SLinus Torvalds ret = get_mm_cmdline(mm, buf, count, pos); 353c2c0bb44SAlexey Dobriyan mmput(mm); 354e4b4e441SLinus Torvalds return ret; 355e4b4e441SLinus Torvalds } 356e4b4e441SLinus Torvalds 357e4b4e441SLinus Torvalds static ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf, 358e4b4e441SLinus Torvalds size_t count, loff_t *pos) 359e4b4e441SLinus Torvalds { 360e4b4e441SLinus Torvalds struct task_struct *tsk; 361e4b4e441SLinus Torvalds ssize_t ret; 362e4b4e441SLinus Torvalds 363e4b4e441SLinus Torvalds BUG_ON(*pos < 0); 364e4b4e441SLinus Torvalds 365e4b4e441SLinus Torvalds tsk = get_proc_task(file_inode(file)); 366e4b4e441SLinus Torvalds if (!tsk) 367e4b4e441SLinus Torvalds return -ESRCH; 368e4b4e441SLinus Torvalds ret = get_task_cmdline(tsk, buf, count, pos); 369e4b4e441SLinus Torvalds put_task_struct(tsk); 370e4b4e441SLinus Torvalds if (ret > 0) 371e4b4e441SLinus Torvalds *pos += ret; 372e4b4e441SLinus Torvalds return ret; 373c2c0bb44SAlexey Dobriyan } 374c2c0bb44SAlexey Dobriyan 375c2c0bb44SAlexey Dobriyan static const struct file_operations proc_pid_cmdline_ops = { 376c2c0bb44SAlexey Dobriyan .read = proc_pid_cmdline_read, 377c2c0bb44SAlexey Dobriyan .llseek = generic_file_llseek, 378c2c0bb44SAlexey Dobriyan }; 379c2c0bb44SAlexey Dobriyan 3801da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 3811da177e4SLinus Torvalds /* 3821da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 3831da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 3841da177e4SLinus Torvalds */ 385edfcd606SAlexey Dobriyan static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns, 386edfcd606SAlexey Dobriyan struct pid *pid, struct task_struct *task) 3871da177e4SLinus Torvalds { 388ffb45122SAlexey Dobriyan unsigned long wchan; 3899281aceaSTejun Heo char symname[KSYM_NAME_LEN]; 3901da177e4SLinus Torvalds 39124b2ec21SAlexey Dobriyan if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) 39224b2ec21SAlexey Dobriyan goto print0; 39324b2ec21SAlexey Dobriyan 3941da177e4SLinus Torvalds wchan = get_wchan(task); 39524b2ec21SAlexey Dobriyan if (wchan && !lookup_symbol_name(wchan, symname)) { 39621dae0adSAlexey Dobriyan seq_puts(m, symname); 39724b2ec21SAlexey Dobriyan return 0; 39824b2ec21SAlexey Dobriyan } 39925ce3191SJoe Perches 40024b2ec21SAlexey Dobriyan print0: 40124b2ec21SAlexey Dobriyan seq_putc(m, '0'); 40225ce3191SJoe Perches return 0; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 4051da177e4SLinus Torvalds 406a9712bc1SAl Viro static int lock_trace(struct task_struct *task) 407a9712bc1SAl Viro { 4082db9dbf7SBernd Edlinger int err = mutex_lock_killable(&task->signal->exec_update_mutex); 409a9712bc1SAl Viro if (err) 410a9712bc1SAl Viro return err; 411caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) { 4122db9dbf7SBernd Edlinger mutex_unlock(&task->signal->exec_update_mutex); 413a9712bc1SAl Viro return -EPERM; 414a9712bc1SAl Viro } 415a9712bc1SAl Viro return 0; 416a9712bc1SAl Viro } 417a9712bc1SAl Viro 418a9712bc1SAl Viro static void unlock_trace(struct task_struct *task) 419a9712bc1SAl Viro { 4202db9dbf7SBernd Edlinger mutex_unlock(&task->signal->exec_update_mutex); 421a9712bc1SAl Viro } 422a9712bc1SAl Viro 4232ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 4242ec220e2SKen Chen 4252ec220e2SKen Chen #define MAX_STACK_TRACE_DEPTH 64 4262ec220e2SKen Chen 4272ec220e2SKen Chen static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns, 4282ec220e2SKen Chen struct pid *pid, struct task_struct *task) 4292ec220e2SKen Chen { 4302ec220e2SKen Chen unsigned long *entries; 431a9712bc1SAl Viro int err; 4322ec220e2SKen Chen 433f8a00cefSJann Horn /* 434f8a00cefSJann Horn * The ability to racily run the kernel stack unwinder on a running task 435f8a00cefSJann Horn * and then observe the unwinder output is scary; while it is useful for 436f8a00cefSJann Horn * debugging kernel issues, it can also allow an attacker to leak kernel 437f8a00cefSJann Horn * stack contents. 438f8a00cefSJann Horn * Doing this in a manner that is at least safe from races would require 439f8a00cefSJann Horn * some work to ensure that the remote task can not be scheduled; and 440f8a00cefSJann Horn * even then, this would still expose the unwinder as local attack 441f8a00cefSJann Horn * surface. 442f8a00cefSJann Horn * Therefore, this interface is restricted to root. 443f8a00cefSJann Horn */ 444f8a00cefSJann Horn if (!file_ns_capable(m->file, &init_user_ns, CAP_SYS_ADMIN)) 445f8a00cefSJann Horn return -EACCES; 446f8a00cefSJann Horn 4476da2ec56SKees Cook entries = kmalloc_array(MAX_STACK_TRACE_DEPTH, sizeof(*entries), 4486da2ec56SKees Cook GFP_KERNEL); 4492ec220e2SKen Chen if (!entries) 4502ec220e2SKen Chen return -ENOMEM; 4512ec220e2SKen Chen 452a9712bc1SAl Viro err = lock_trace(task); 453a9712bc1SAl Viro if (!err) { 454e988e5ecSThomas Gleixner unsigned int i, nr_entries; 4555d008fb4SAlexey Dobriyan 456e988e5ecSThomas Gleixner nr_entries = stack_trace_save_tsk(task, entries, 457e988e5ecSThomas Gleixner MAX_STACK_TRACE_DEPTH, 0); 4582ec220e2SKen Chen 459e988e5ecSThomas Gleixner for (i = 0; i < nr_entries; i++) { 4608f5abe84SLinus Torvalds seq_printf(m, "[<0>] %pB\n", (void *)entries[i]); 4612ec220e2SKen Chen } 462e988e5ecSThomas Gleixner 463a9712bc1SAl Viro unlock_trace(task); 464a9712bc1SAl Viro } 4652ec220e2SKen Chen kfree(entries); 4662ec220e2SKen Chen 467a9712bc1SAl Viro return err; 4682ec220e2SKen Chen } 4692ec220e2SKen Chen #endif 4702ec220e2SKen Chen 4715968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 4721da177e4SLinus Torvalds /* 4731da177e4SLinus Torvalds * Provides /proc/PID/schedstat 4741da177e4SLinus Torvalds */ 475f6e826caSAlexey Dobriyan static int proc_pid_schedstat(struct seq_file *m, struct pid_namespace *ns, 476f6e826caSAlexey Dobriyan struct pid *pid, struct task_struct *task) 4771da177e4SLinus Torvalds { 4785968ceceSNaveen N. Rao if (unlikely(!sched_info_on())) 47908b55775SAlexey Dobriyan seq_puts(m, "0 0 0\n"); 4805968ceceSNaveen N. Rao else 48125ce3191SJoe Perches seq_printf(m, "%llu %llu %lu\n", 482826e08b0SIngo Molnar (unsigned long long)task->se.sum_exec_runtime, 483826e08b0SIngo Molnar (unsigned long long)task->sched_info.run_delay, 4842d72376bSIngo Molnar task->sched_info.pcount); 48525ce3191SJoe Perches 48625ce3191SJoe Perches return 0; 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds #endif 4891da177e4SLinus Torvalds 4909745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 4919745512cSArjan van de Ven static int lstats_show_proc(struct seq_file *m, void *v) 4929745512cSArjan van de Ven { 4939745512cSArjan van de Ven int i; 49413d77c37SHiroshi Shimamoto struct inode *inode = m->private; 49513d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(inode); 4969745512cSArjan van de Ven 49713d77c37SHiroshi Shimamoto if (!task) 49813d77c37SHiroshi Shimamoto return -ESRCH; 49913d77c37SHiroshi Shimamoto seq_puts(m, "Latency Top version : v0.1\n"); 500f6d2f584SAlexey Dobriyan for (i = 0; i < LT_SAVECOUNT; i++) { 50134e49d4fSJoe Perches struct latency_record *lr = &task->latency_record[i]; 50234e49d4fSJoe Perches if (lr->backtrace[0]) { 5039745512cSArjan van de Ven int q; 5049745512cSArjan van de Ven seq_printf(m, "%i %li %li", 50534e49d4fSJoe Perches lr->count, lr->time, lr->max); 5069745512cSArjan van de Ven for (q = 0; q < LT_BACKTRACEDEPTH; q++) { 50734e49d4fSJoe Perches unsigned long bt = lr->backtrace[q]; 508accddc41SThomas Gleixner 50934e49d4fSJoe Perches if (!bt) 5109745512cSArjan van de Ven break; 51134e49d4fSJoe Perches seq_printf(m, " %ps", (void *)bt); 5129745512cSArjan van de Ven } 5139d6de12fSAlexey Dobriyan seq_putc(m, '\n'); 5149745512cSArjan van de Ven } 5159745512cSArjan van de Ven 5169745512cSArjan van de Ven } 51713d77c37SHiroshi Shimamoto put_task_struct(task); 5189745512cSArjan van de Ven return 0; 5199745512cSArjan van de Ven } 5209745512cSArjan van de Ven 5219745512cSArjan van de Ven static int lstats_open(struct inode *inode, struct file *file) 5229745512cSArjan van de Ven { 52313d77c37SHiroshi Shimamoto return single_open(file, lstats_show_proc, inode); 524d6643d12SHiroshi Shimamoto } 525d6643d12SHiroshi Shimamoto 5269745512cSArjan van de Ven static ssize_t lstats_write(struct file *file, const char __user *buf, 5279745512cSArjan van de Ven size_t count, loff_t *offs) 5289745512cSArjan van de Ven { 529496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 5309745512cSArjan van de Ven 53113d77c37SHiroshi Shimamoto if (!task) 53213d77c37SHiroshi Shimamoto return -ESRCH; 533e02c9b0dSLin Feng clear_tsk_latency_tracing(task); 53413d77c37SHiroshi Shimamoto put_task_struct(task); 5359745512cSArjan van de Ven 5369745512cSArjan van de Ven return count; 5379745512cSArjan van de Ven } 5389745512cSArjan van de Ven 5399745512cSArjan van de Ven static const struct file_operations proc_lstats_operations = { 5409745512cSArjan van de Ven .open = lstats_open, 5419745512cSArjan van de Ven .read = seq_read, 5429745512cSArjan van de Ven .write = lstats_write, 5439745512cSArjan van de Ven .llseek = seq_lseek, 54413d77c37SHiroshi Shimamoto .release = single_release, 5459745512cSArjan van de Ven }; 5469745512cSArjan van de Ven 5479745512cSArjan van de Ven #endif 5489745512cSArjan van de Ven 5496ba51e37SAlexey Dobriyan static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns, 5506ba51e37SAlexey Dobriyan struct pid *pid, struct task_struct *task) 5511da177e4SLinus Torvalds { 552ca79b0c2SArun KS unsigned long totalpages = totalram_pages() + total_swap_pages; 553b95c35e7SOleg Nesterov unsigned long points = 0; 5541da177e4SLinus Torvalds 555ac311a14SShakeel Butt points = oom_badness(task, totalpages) * 1000 / totalpages; 55625ce3191SJoe Perches seq_printf(m, "%lu\n", points); 55725ce3191SJoe Perches 55825ce3191SJoe Perches return 0; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 561d85f50d5SNeil Horman struct limit_names { 562cedbccabSAlexey Dobriyan const char *name; 563cedbccabSAlexey Dobriyan const char *unit; 564d85f50d5SNeil Horman }; 565d85f50d5SNeil Horman 566d85f50d5SNeil Horman static const struct limit_names lnames[RLIM_NLIMITS] = { 567cff4edb5SKees Cook [RLIMIT_CPU] = {"Max cpu time", "seconds"}, 568d85f50d5SNeil Horman [RLIMIT_FSIZE] = {"Max file size", "bytes"}, 569d85f50d5SNeil Horman [RLIMIT_DATA] = {"Max data size", "bytes"}, 570d85f50d5SNeil Horman [RLIMIT_STACK] = {"Max stack size", "bytes"}, 571d85f50d5SNeil Horman [RLIMIT_CORE] = {"Max core file size", "bytes"}, 572d85f50d5SNeil Horman [RLIMIT_RSS] = {"Max resident set", "bytes"}, 573d85f50d5SNeil Horman [RLIMIT_NPROC] = {"Max processes", "processes"}, 574d85f50d5SNeil Horman [RLIMIT_NOFILE] = {"Max open files", "files"}, 575d85f50d5SNeil Horman [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"}, 576d85f50d5SNeil Horman [RLIMIT_AS] = {"Max address space", "bytes"}, 577d85f50d5SNeil Horman [RLIMIT_LOCKS] = {"Max file locks", "locks"}, 578d85f50d5SNeil Horman [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"}, 579d85f50d5SNeil Horman [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"}, 580d85f50d5SNeil Horman [RLIMIT_NICE] = {"Max nice priority", NULL}, 581d85f50d5SNeil Horman [RLIMIT_RTPRIO] = {"Max realtime priority", NULL}, 5828808117cSEugene Teo [RLIMIT_RTTIME] = {"Max realtime timeout", "us"}, 583d85f50d5SNeil Horman }; 584d85f50d5SNeil Horman 585d85f50d5SNeil Horman /* Display limits for a process */ 5861c963eb1SAlexey Dobriyan static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns, 5871c963eb1SAlexey Dobriyan struct pid *pid, struct task_struct *task) 588d85f50d5SNeil Horman { 589d85f50d5SNeil Horman unsigned int i; 590d85f50d5SNeil Horman unsigned long flags; 591d85f50d5SNeil Horman 592d85f50d5SNeil Horman struct rlimit rlim[RLIM_NLIMITS]; 593d85f50d5SNeil Horman 594a6bebbc8SLai Jiangshan if (!lock_task_sighand(task, &flags)) 595d85f50d5SNeil Horman return 0; 596d85f50d5SNeil Horman memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS); 597d85f50d5SNeil Horman unlock_task_sighand(task, &flags); 598d85f50d5SNeil Horman 599d85f50d5SNeil Horman /* 600d85f50d5SNeil Horman * print the file header 601d85f50d5SNeil Horman */ 602afe922c2SAlexey Dobriyan seq_puts(m, "Limit " 603afe922c2SAlexey Dobriyan "Soft Limit " 604afe922c2SAlexey Dobriyan "Hard Limit " 605afe922c2SAlexey Dobriyan "Units \n"); 606d85f50d5SNeil Horman 607d85f50d5SNeil Horman for (i = 0; i < RLIM_NLIMITS; i++) { 608d85f50d5SNeil Horman if (rlim[i].rlim_cur == RLIM_INFINITY) 6091c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s ", 610d85f50d5SNeil Horman lnames[i].name, "unlimited"); 611d85f50d5SNeil Horman else 6121c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20lu ", 613d85f50d5SNeil Horman lnames[i].name, rlim[i].rlim_cur); 614d85f50d5SNeil Horman 615d85f50d5SNeil Horman if (rlim[i].rlim_max == RLIM_INFINITY) 6161c963eb1SAlexey Dobriyan seq_printf(m, "%-20s ", "unlimited"); 617d85f50d5SNeil Horman else 6181c963eb1SAlexey Dobriyan seq_printf(m, "%-20lu ", rlim[i].rlim_max); 619d85f50d5SNeil Horman 620d85f50d5SNeil Horman if (lnames[i].unit) 6211c963eb1SAlexey Dobriyan seq_printf(m, "%-10s\n", lnames[i].unit); 622d85f50d5SNeil Horman else 6231c963eb1SAlexey Dobriyan seq_putc(m, '\n'); 624d85f50d5SNeil Horman } 625d85f50d5SNeil Horman 6261c963eb1SAlexey Dobriyan return 0; 627d85f50d5SNeil Horman } 628d85f50d5SNeil Horman 629ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 63009d93bd6SAlexey Dobriyan static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns, 63109d93bd6SAlexey Dobriyan struct pid *pid, struct task_struct *task) 632ebcb6734SRoland McGrath { 633631b7abaSSteven Rostedt (Red Hat) struct syscall_info info; 634631b7abaSSteven Rostedt (Red Hat) u64 *args = &info.data.args[0]; 63525ce3191SJoe Perches int res; 63625ce3191SJoe Perches 63725ce3191SJoe Perches res = lock_trace(task); 638a9712bc1SAl Viro if (res) 639a9712bc1SAl Viro return res; 640ebcb6734SRoland McGrath 641631b7abaSSteven Rostedt (Red Hat) if (task_current_syscall(task, &info)) 64209d93bd6SAlexey Dobriyan seq_puts(m, "running\n"); 643631b7abaSSteven Rostedt (Red Hat) else if (info.data.nr < 0) 644631b7abaSSteven Rostedt (Red Hat) seq_printf(m, "%d 0x%llx 0x%llx\n", 645631b7abaSSteven Rostedt (Red Hat) info.data.nr, info.sp, info.data.instruction_pointer); 646a9712bc1SAl Viro else 64709d93bd6SAlexey Dobriyan seq_printf(m, 648631b7abaSSteven Rostedt (Red Hat) "%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n", 649631b7abaSSteven Rostedt (Red Hat) info.data.nr, 650ebcb6734SRoland McGrath args[0], args[1], args[2], args[3], args[4], args[5], 651631b7abaSSteven Rostedt (Red Hat) info.sp, info.data.instruction_pointer); 652a9712bc1SAl Viro unlock_trace(task); 65325ce3191SJoe Perches 65425ce3191SJoe Perches return 0; 655ebcb6734SRoland McGrath } 656ebcb6734SRoland McGrath #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */ 657ebcb6734SRoland McGrath 6581da177e4SLinus Torvalds /************************************************************************/ 6591da177e4SLinus Torvalds /* Here the fs part begins */ 6601da177e4SLinus Torvalds /************************************************************************/ 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds /* permission checks */ 663778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 6641da177e4SLinus Torvalds { 665778c1144SEric W. Biederman struct task_struct *task; 666778c1144SEric W. Biederman int allowed = 0; 667df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 668df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 669df26c40eSEric W. Biederman * information. 670778c1144SEric W. Biederman */ 671778c1144SEric W. Biederman task = get_proc_task(inode); 672df26c40eSEric W. Biederman if (task) { 673caaee623SJann Horn allowed = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS); 674778c1144SEric W. Biederman put_task_struct(task); 675df26c40eSEric W. Biederman } 676778c1144SEric W. Biederman return allowed; 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds 6796b4e306aSEric W. Biederman int proc_setattr(struct dentry *dentry, struct iattr *attr) 6806d76fa58SLinus Torvalds { 6816d76fa58SLinus Torvalds int error; 6822b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 6836d76fa58SLinus Torvalds 6846d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 6856d76fa58SLinus Torvalds return -EPERM; 6866d76fa58SLinus Torvalds 68731051c85SJan Kara error = setattr_prepare(dentry, attr); 6881025774cSChristoph Hellwig if (error) 6896d76fa58SLinus Torvalds return error; 6901025774cSChristoph Hellwig 6911025774cSChristoph Hellwig setattr_copy(inode, attr); 6921025774cSChristoph Hellwig mark_inode_dirty(inode); 6931025774cSChristoph Hellwig return 0; 6946d76fa58SLinus Torvalds } 6956d76fa58SLinus Torvalds 6960499680aSVasiliy Kulikov /* 6970499680aSVasiliy Kulikov * May current process learn task's sched/cmdline info (for hide_pid_min=1) 6980499680aSVasiliy Kulikov * or euid/egid (for hide_pid_min=2)? 6990499680aSVasiliy Kulikov */ 7000499680aSVasiliy Kulikov static bool has_pid_permissions(struct pid_namespace *pid, 7010499680aSVasiliy Kulikov struct task_struct *task, 7020499680aSVasiliy Kulikov int hide_pid_min) 7030499680aSVasiliy Kulikov { 7040499680aSVasiliy Kulikov if (pid->hide_pid < hide_pid_min) 7050499680aSVasiliy Kulikov return true; 7060499680aSVasiliy Kulikov if (in_group_p(pid->pid_gid)) 7070499680aSVasiliy Kulikov return true; 708caaee623SJann Horn return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS); 7090499680aSVasiliy Kulikov } 7100499680aSVasiliy Kulikov 7110499680aSVasiliy Kulikov 7120499680aSVasiliy Kulikov static int proc_pid_permission(struct inode *inode, int mask) 7130499680aSVasiliy Kulikov { 71476f668beSChristoph Hellwig struct pid_namespace *pid = proc_pid_ns(inode); 7150499680aSVasiliy Kulikov struct task_struct *task; 7160499680aSVasiliy Kulikov bool has_perms; 7170499680aSVasiliy Kulikov 7180499680aSVasiliy Kulikov task = get_proc_task(inode); 719a2ef990aSXiaotian Feng if (!task) 720a2ef990aSXiaotian Feng return -ESRCH; 721796f571bSLafcadio Wluiki has_perms = has_pid_permissions(pid, task, HIDEPID_NO_ACCESS); 7220499680aSVasiliy Kulikov put_task_struct(task); 7230499680aSVasiliy Kulikov 7240499680aSVasiliy Kulikov if (!has_perms) { 725796f571bSLafcadio Wluiki if (pid->hide_pid == HIDEPID_INVISIBLE) { 7260499680aSVasiliy Kulikov /* 7270499680aSVasiliy Kulikov * Let's make getdents(), stat(), and open() 7280499680aSVasiliy Kulikov * consistent with each other. If a process 7290499680aSVasiliy Kulikov * may not stat() a file, it shouldn't be seen 7300499680aSVasiliy Kulikov * in procfs at all. 7310499680aSVasiliy Kulikov */ 7320499680aSVasiliy Kulikov return -ENOENT; 7330499680aSVasiliy Kulikov } 7340499680aSVasiliy Kulikov 7350499680aSVasiliy Kulikov return -EPERM; 7360499680aSVasiliy Kulikov } 7370499680aSVasiliy Kulikov return generic_permission(inode, mask); 7380499680aSVasiliy Kulikov } 7390499680aSVasiliy Kulikov 7400499680aSVasiliy Kulikov 7410499680aSVasiliy Kulikov 742c5ef1c42SArjan van de Ven static const struct inode_operations proc_def_inode_operations = { 7436d76fa58SLinus Torvalds .setattr = proc_setattr, 7446d76fa58SLinus Torvalds }; 7456d76fa58SLinus Torvalds 746be614086SEric W. Biederman static int proc_single_show(struct seq_file *m, void *v) 747be614086SEric W. Biederman { 748be614086SEric W. Biederman struct inode *inode = m->private; 74976f668beSChristoph Hellwig struct pid_namespace *ns = proc_pid_ns(inode); 75076f668beSChristoph Hellwig struct pid *pid = proc_pid(inode); 751be614086SEric W. Biederman struct task_struct *task; 752be614086SEric W. Biederman int ret; 753be614086SEric W. Biederman 754be614086SEric W. Biederman task = get_pid_task(pid, PIDTYPE_PID); 755be614086SEric W. Biederman if (!task) 756be614086SEric W. Biederman return -ESRCH; 757be614086SEric W. Biederman 758be614086SEric W. Biederman ret = PROC_I(inode)->op.proc_show(m, ns, pid, task); 759be614086SEric W. Biederman 760be614086SEric W. Biederman put_task_struct(task); 761be614086SEric W. Biederman return ret; 762be614086SEric W. Biederman } 763be614086SEric W. Biederman 764be614086SEric W. Biederman static int proc_single_open(struct inode *inode, struct file *filp) 765be614086SEric W. Biederman { 766c6a34058SJovi Zhang return single_open(filp, proc_single_show, inode); 767be614086SEric W. Biederman } 768be614086SEric W. Biederman 769be614086SEric W. Biederman static const struct file_operations proc_single_file_operations = { 770be614086SEric W. Biederman .open = proc_single_open, 771be614086SEric W. Biederman .read = seq_read, 772be614086SEric W. Biederman .llseek = seq_lseek, 773be614086SEric W. Biederman .release = single_release, 774be614086SEric W. Biederman }; 775be614086SEric W. Biederman 7765381e169SOleg Nesterov 7775381e169SOleg Nesterov struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode) 7781da177e4SLinus Torvalds { 7795381e169SOleg Nesterov struct task_struct *task = get_proc_task(inode); 7805381e169SOleg Nesterov struct mm_struct *mm = ERR_PTR(-ESRCH); 781e268337dSLinus Torvalds 7825381e169SOleg Nesterov if (task) { 783caaee623SJann Horn mm = mm_access(task, mode | PTRACE_MODE_FSCREDS); 784e268337dSLinus Torvalds put_task_struct(task); 785e268337dSLinus Torvalds 7865381e169SOleg Nesterov if (!IS_ERR_OR_NULL(mm)) { 7876d08f2c7SOleg Nesterov /* ensure this mm_struct can't be freed */ 788f1f10076SVegard Nossum mmgrab(mm); 7896d08f2c7SOleg Nesterov /* but do not pin its memory */ 7906d08f2c7SOleg Nesterov mmput(mm); 7916d08f2c7SOleg Nesterov } 7925381e169SOleg Nesterov } 7935381e169SOleg Nesterov 7945381e169SOleg Nesterov return mm; 7955381e169SOleg Nesterov } 7965381e169SOleg Nesterov 7975381e169SOleg Nesterov static int __mem_open(struct inode *inode, struct file *file, unsigned int mode) 7985381e169SOleg Nesterov { 7995381e169SOleg Nesterov struct mm_struct *mm = proc_mem_open(inode, mode); 8005381e169SOleg Nesterov 8015381e169SOleg Nesterov if (IS_ERR(mm)) 8025381e169SOleg Nesterov return PTR_ERR(mm); 8036d08f2c7SOleg Nesterov 804e268337dSLinus Torvalds file->private_data = mm; 8051da177e4SLinus Torvalds return 0; 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds 808b409e578SCong Wang static int mem_open(struct inode *inode, struct file *file) 809b409e578SCong Wang { 810bc452b4bSDjalal Harouni int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH); 811bc452b4bSDjalal Harouni 812bc452b4bSDjalal Harouni /* OK to pass negative loff_t, we can catch out-of-range */ 813bc452b4bSDjalal Harouni file->f_mode |= FMODE_UNSIGNED_OFFSET; 814bc452b4bSDjalal Harouni 815bc452b4bSDjalal Harouni return ret; 816b409e578SCong Wang } 817b409e578SCong Wang 818572d34b9SOleg Nesterov static ssize_t mem_rw(struct file *file, char __user *buf, 819572d34b9SOleg Nesterov size_t count, loff_t *ppos, int write) 8201da177e4SLinus Torvalds { 821e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 822572d34b9SOleg Nesterov unsigned long addr = *ppos; 823572d34b9SOleg Nesterov ssize_t copied; 8241da177e4SLinus Torvalds char *page; 825272ddc8bSLinus Torvalds unsigned int flags; 8261da177e4SLinus Torvalds 827e268337dSLinus Torvalds if (!mm) 828e268337dSLinus Torvalds return 0; 8291da177e4SLinus Torvalds 8300ee931c4SMichal Hocko page = (char *)__get_free_page(GFP_KERNEL); 8311da177e4SLinus Torvalds if (!page) 832e268337dSLinus Torvalds return -ENOMEM; 8331da177e4SLinus Torvalds 834f7ca54f4SFrederik Deweerdt copied = 0; 835388f7934SVegard Nossum if (!mmget_not_zero(mm)) 8366d08f2c7SOleg Nesterov goto free; 8376d08f2c7SOleg Nesterov 838f511c0b1SLinus Torvalds flags = FOLL_FORCE | (write ? FOLL_WRITE : 0); 8396347e8d5SLorenzo Stoakes 8401da177e4SLinus Torvalds while (count > 0) { 841572d34b9SOleg Nesterov int this_len = min_t(int, count, PAGE_SIZE); 8421da177e4SLinus Torvalds 843572d34b9SOleg Nesterov if (write && copy_from_user(page, buf, this_len)) { 8441da177e4SLinus Torvalds copied = -EFAULT; 8451da177e4SLinus Torvalds break; 8461da177e4SLinus Torvalds } 847572d34b9SOleg Nesterov 8486347e8d5SLorenzo Stoakes this_len = access_remote_vm(mm, addr, page, this_len, flags); 849572d34b9SOleg Nesterov if (!this_len) { 8501da177e4SLinus Torvalds if (!copied) 8511da177e4SLinus Torvalds copied = -EIO; 8521da177e4SLinus Torvalds break; 8531da177e4SLinus Torvalds } 854572d34b9SOleg Nesterov 855572d34b9SOleg Nesterov if (!write && copy_to_user(buf, page, this_len)) { 856572d34b9SOleg Nesterov copied = -EFAULT; 857572d34b9SOleg Nesterov break; 8581da177e4SLinus Torvalds } 859572d34b9SOleg Nesterov 860572d34b9SOleg Nesterov buf += this_len; 861572d34b9SOleg Nesterov addr += this_len; 862572d34b9SOleg Nesterov copied += this_len; 863572d34b9SOleg Nesterov count -= this_len; 864572d34b9SOleg Nesterov } 865572d34b9SOleg Nesterov *ppos = addr; 86630cd8903SKOSAKI Motohiro 8676d08f2c7SOleg Nesterov mmput(mm); 8686d08f2c7SOleg Nesterov free: 86930cd8903SKOSAKI Motohiro free_page((unsigned long) page); 8701da177e4SLinus Torvalds return copied; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds 873572d34b9SOleg Nesterov static ssize_t mem_read(struct file *file, char __user *buf, 874572d34b9SOleg Nesterov size_t count, loff_t *ppos) 875572d34b9SOleg Nesterov { 876572d34b9SOleg Nesterov return mem_rw(file, buf, count, ppos, 0); 877572d34b9SOleg Nesterov } 878572d34b9SOleg Nesterov 879572d34b9SOleg Nesterov static ssize_t mem_write(struct file *file, const char __user *buf, 880572d34b9SOleg Nesterov size_t count, loff_t *ppos) 881572d34b9SOleg Nesterov { 882572d34b9SOleg Nesterov return mem_rw(file, (char __user*)buf, count, ppos, 1); 883572d34b9SOleg Nesterov } 884572d34b9SOleg Nesterov 88585863e47SMatt Mackall loff_t mem_lseek(struct file *file, loff_t offset, int orig) 8861da177e4SLinus Torvalds { 8871da177e4SLinus Torvalds switch (orig) { 8881da177e4SLinus Torvalds case 0: 8891da177e4SLinus Torvalds file->f_pos = offset; 8901da177e4SLinus Torvalds break; 8911da177e4SLinus Torvalds case 1: 8921da177e4SLinus Torvalds file->f_pos += offset; 8931da177e4SLinus Torvalds break; 8941da177e4SLinus Torvalds default: 8951da177e4SLinus Torvalds return -EINVAL; 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds force_successful_syscall_return(); 8981da177e4SLinus Torvalds return file->f_pos; 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds 901e268337dSLinus Torvalds static int mem_release(struct inode *inode, struct file *file) 902e268337dSLinus Torvalds { 903e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 90471879d3cSOleg Nesterov if (mm) 9056d08f2c7SOleg Nesterov mmdrop(mm); 906e268337dSLinus Torvalds return 0; 907e268337dSLinus Torvalds } 908e268337dSLinus Torvalds 90900977a59SArjan van de Ven static const struct file_operations proc_mem_operations = { 9101da177e4SLinus Torvalds .llseek = mem_lseek, 9111da177e4SLinus Torvalds .read = mem_read, 9121da177e4SLinus Torvalds .write = mem_write, 9131da177e4SLinus Torvalds .open = mem_open, 914e268337dSLinus Torvalds .release = mem_release, 9151da177e4SLinus Torvalds }; 9161da177e4SLinus Torvalds 917b409e578SCong Wang static int environ_open(struct inode *inode, struct file *file) 918b409e578SCong Wang { 919b409e578SCong Wang return __mem_open(inode, file, PTRACE_MODE_READ); 920b409e578SCong Wang } 921b409e578SCong Wang 922315e28c8SJames Pearson static ssize_t environ_read(struct file *file, char __user *buf, 923315e28c8SJames Pearson size_t count, loff_t *ppos) 924315e28c8SJames Pearson { 925315e28c8SJames Pearson char *page; 926315e28c8SJames Pearson unsigned long src = *ppos; 927b409e578SCong Wang int ret = 0; 928b409e578SCong Wang struct mm_struct *mm = file->private_data; 929a3b609efSMateusz Guzik unsigned long env_start, env_end; 930315e28c8SJames Pearson 9318148a73cSMathias Krause /* Ensure the process spawned far enough to have an environment. */ 9328148a73cSMathias Krause if (!mm || !mm->env_end) 933b409e578SCong Wang return 0; 934315e28c8SJames Pearson 9350ee931c4SMichal Hocko page = (char *)__get_free_page(GFP_KERNEL); 936315e28c8SJames Pearson if (!page) 937b409e578SCong Wang return -ENOMEM; 938315e28c8SJames Pearson 939d6f64b89SAl Viro ret = 0; 940388f7934SVegard Nossum if (!mmget_not_zero(mm)) 941b409e578SCong Wang goto free; 942a3b609efSMateusz Guzik 94388aa7cc6SYang Shi spin_lock(&mm->arg_lock); 944a3b609efSMateusz Guzik env_start = mm->env_start; 945a3b609efSMateusz Guzik env_end = mm->env_end; 94688aa7cc6SYang Shi spin_unlock(&mm->arg_lock); 947a3b609efSMateusz Guzik 948315e28c8SJames Pearson while (count > 0) { 949e8905ec2SDjalal Harouni size_t this_len, max_len; 950e8905ec2SDjalal Harouni int retval; 951e8905ec2SDjalal Harouni 952a3b609efSMateusz Guzik if (src >= (env_end - env_start)) 953e8905ec2SDjalal Harouni break; 954315e28c8SJames Pearson 955a3b609efSMateusz Guzik this_len = env_end - (env_start + src); 956315e28c8SJames Pearson 957e8905ec2SDjalal Harouni max_len = min_t(size_t, PAGE_SIZE, count); 958e8905ec2SDjalal Harouni this_len = min(max_len, this_len); 959315e28c8SJames Pearson 9607f7ccc2cSWilly Tarreau retval = access_remote_vm(mm, (env_start + src), page, this_len, FOLL_ANON); 961315e28c8SJames Pearson 962315e28c8SJames Pearson if (retval <= 0) { 963315e28c8SJames Pearson ret = retval; 964315e28c8SJames Pearson break; 965315e28c8SJames Pearson } 966315e28c8SJames Pearson 967315e28c8SJames Pearson if (copy_to_user(buf, page, retval)) { 968315e28c8SJames Pearson ret = -EFAULT; 969315e28c8SJames Pearson break; 970315e28c8SJames Pearson } 971315e28c8SJames Pearson 972315e28c8SJames Pearson ret += retval; 973315e28c8SJames Pearson src += retval; 974315e28c8SJames Pearson buf += retval; 975315e28c8SJames Pearson count -= retval; 976315e28c8SJames Pearson } 977315e28c8SJames Pearson *ppos = src; 978315e28c8SJames Pearson mmput(mm); 979b409e578SCong Wang 980b409e578SCong Wang free: 981315e28c8SJames Pearson free_page((unsigned long) page); 982315e28c8SJames Pearson return ret; 983315e28c8SJames Pearson } 984315e28c8SJames Pearson 985315e28c8SJames Pearson static const struct file_operations proc_environ_operations = { 986b409e578SCong Wang .open = environ_open, 987315e28c8SJames Pearson .read = environ_read, 98887df8424SArnd Bergmann .llseek = generic_file_llseek, 989b409e578SCong Wang .release = mem_release, 990315e28c8SJames Pearson }; 991315e28c8SJames Pearson 992c5317167SAl Viro static int auxv_open(struct inode *inode, struct file *file) 993c5317167SAl Viro { 994c5317167SAl Viro return __mem_open(inode, file, PTRACE_MODE_READ_FSCREDS); 995c5317167SAl Viro } 996c5317167SAl Viro 997c5317167SAl Viro static ssize_t auxv_read(struct file *file, char __user *buf, 998c5317167SAl Viro size_t count, loff_t *ppos) 999c5317167SAl Viro { 1000c5317167SAl Viro struct mm_struct *mm = file->private_data; 1001c5317167SAl Viro unsigned int nwords = 0; 100206b2849dSLeon Yu 100306b2849dSLeon Yu if (!mm) 100406b2849dSLeon Yu return 0; 1005c5317167SAl Viro do { 1006c5317167SAl Viro nwords += 2; 1007c5317167SAl Viro } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 1008c5317167SAl Viro return simple_read_from_buffer(buf, count, ppos, mm->saved_auxv, 1009c5317167SAl Viro nwords * sizeof(mm->saved_auxv[0])); 1010c5317167SAl Viro } 1011c5317167SAl Viro 1012c5317167SAl Viro static const struct file_operations proc_auxv_operations = { 1013c5317167SAl Viro .open = auxv_open, 1014c5317167SAl Viro .read = auxv_read, 1015c5317167SAl Viro .llseek = generic_file_llseek, 1016c5317167SAl Viro .release = mem_release, 1017c5317167SAl Viro }; 1018c5317167SAl Viro 1019fa0cbbf1SDavid Rientjes static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count, 1020fa0cbbf1SDavid Rientjes loff_t *ppos) 1021fa0cbbf1SDavid Rientjes { 1022496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1023fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 1024fa0cbbf1SDavid Rientjes int oom_adj = OOM_ADJUST_MIN; 1025fa0cbbf1SDavid Rientjes size_t len; 1026fa0cbbf1SDavid Rientjes 1027fa0cbbf1SDavid Rientjes if (!task) 1028fa0cbbf1SDavid Rientjes return -ESRCH; 1029fa0cbbf1SDavid Rientjes if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX) 1030fa0cbbf1SDavid Rientjes oom_adj = OOM_ADJUST_MAX; 1031fa0cbbf1SDavid Rientjes else 1032fa0cbbf1SDavid Rientjes oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) / 1033fa0cbbf1SDavid Rientjes OOM_SCORE_ADJ_MAX; 1034fa0cbbf1SDavid Rientjes put_task_struct(task); 1035fa0cbbf1SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj); 1036fa0cbbf1SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1037fa0cbbf1SDavid Rientjes } 1038fa0cbbf1SDavid Rientjes 10391d5f0acbSMichal Hocko static int __set_oom_adj(struct file *file, int oom_adj, bool legacy) 10401d5f0acbSMichal Hocko { 1041f913da59SMichal Hocko static DEFINE_MUTEX(oom_adj_mutex); 104244a70adeSMichal Hocko struct mm_struct *mm = NULL; 10431d5f0acbSMichal Hocko struct task_struct *task; 10441d5f0acbSMichal Hocko int err = 0; 10451d5f0acbSMichal Hocko 10461d5f0acbSMichal Hocko task = get_proc_task(file_inode(file)); 10471d5f0acbSMichal Hocko if (!task) 10481d5f0acbSMichal Hocko return -ESRCH; 10491d5f0acbSMichal Hocko 10501d5f0acbSMichal Hocko mutex_lock(&oom_adj_mutex); 10511d5f0acbSMichal Hocko if (legacy) { 10521d5f0acbSMichal Hocko if (oom_adj < task->signal->oom_score_adj && 10531d5f0acbSMichal Hocko !capable(CAP_SYS_RESOURCE)) { 10541d5f0acbSMichal Hocko err = -EACCES; 10551d5f0acbSMichal Hocko goto err_unlock; 10561d5f0acbSMichal Hocko } 10571d5f0acbSMichal Hocko /* 10581d5f0acbSMichal Hocko * /proc/pid/oom_adj is provided for legacy purposes, ask users to use 10591d5f0acbSMichal Hocko * /proc/pid/oom_score_adj instead. 10601d5f0acbSMichal Hocko */ 10611d5f0acbSMichal Hocko pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n", 10621d5f0acbSMichal Hocko current->comm, task_pid_nr(current), task_pid_nr(task), 10631d5f0acbSMichal Hocko task_pid_nr(task)); 10641d5f0acbSMichal Hocko } else { 10651d5f0acbSMichal Hocko if ((short)oom_adj < task->signal->oom_score_adj_min && 10661d5f0acbSMichal Hocko !capable(CAP_SYS_RESOURCE)) { 10671d5f0acbSMichal Hocko err = -EACCES; 10681d5f0acbSMichal Hocko goto err_unlock; 10691d5f0acbSMichal Hocko } 10701d5f0acbSMichal Hocko } 10711d5f0acbSMichal Hocko 107244a70adeSMichal Hocko /* 107344a70adeSMichal Hocko * Make sure we will check other processes sharing the mm if this is 107444a70adeSMichal Hocko * not vfrok which wants its own oom_score_adj. 107544a70adeSMichal Hocko * pin the mm so it doesn't go away and get reused after task_unlock 107644a70adeSMichal Hocko */ 107744a70adeSMichal Hocko if (!task->vfork_done) { 107844a70adeSMichal Hocko struct task_struct *p = find_lock_task_mm(task); 107944a70adeSMichal Hocko 108044a70adeSMichal Hocko if (p) { 108144a70adeSMichal Hocko if (atomic_read(&p->mm->mm_users) > 1) { 108244a70adeSMichal Hocko mm = p->mm; 1083f1f10076SVegard Nossum mmgrab(mm); 108444a70adeSMichal Hocko } 108544a70adeSMichal Hocko task_unlock(p); 108644a70adeSMichal Hocko } 108744a70adeSMichal Hocko } 108844a70adeSMichal Hocko 10891d5f0acbSMichal Hocko task->signal->oom_score_adj = oom_adj; 10901d5f0acbSMichal Hocko if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE)) 10911d5f0acbSMichal Hocko task->signal->oom_score_adj_min = (short)oom_adj; 10921d5f0acbSMichal Hocko trace_oom_score_adj_update(task); 109344a70adeSMichal Hocko 109444a70adeSMichal Hocko if (mm) { 109544a70adeSMichal Hocko struct task_struct *p; 109644a70adeSMichal Hocko 109744a70adeSMichal Hocko rcu_read_lock(); 109844a70adeSMichal Hocko for_each_process(p) { 109944a70adeSMichal Hocko if (same_thread_group(task, p)) 110044a70adeSMichal Hocko continue; 110144a70adeSMichal Hocko 110244a70adeSMichal Hocko /* do not touch kernel threads or the global init */ 110344a70adeSMichal Hocko if (p->flags & PF_KTHREAD || is_global_init(p)) 110444a70adeSMichal Hocko continue; 110544a70adeSMichal Hocko 110644a70adeSMichal Hocko task_lock(p); 110744a70adeSMichal Hocko if (!p->vfork_done && process_shares_mm(p, mm)) { 110844a70adeSMichal Hocko p->signal->oom_score_adj = oom_adj; 110944a70adeSMichal Hocko if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE)) 111044a70adeSMichal Hocko p->signal->oom_score_adj_min = (short)oom_adj; 111144a70adeSMichal Hocko } 111244a70adeSMichal Hocko task_unlock(p); 111344a70adeSMichal Hocko } 111444a70adeSMichal Hocko rcu_read_unlock(); 111544a70adeSMichal Hocko mmdrop(mm); 111644a70adeSMichal Hocko } 11171d5f0acbSMichal Hocko err_unlock: 11181d5f0acbSMichal Hocko mutex_unlock(&oom_adj_mutex); 11191d5f0acbSMichal Hocko put_task_struct(task); 11201d5f0acbSMichal Hocko return err; 11211d5f0acbSMichal Hocko } 1122f913da59SMichal Hocko 1123b72bdfa7SDavid Rientjes /* 1124b72bdfa7SDavid Rientjes * /proc/pid/oom_adj exists solely for backwards compatibility with previous 1125b72bdfa7SDavid Rientjes * kernels. The effective policy is defined by oom_score_adj, which has a 1126b72bdfa7SDavid Rientjes * different scale: oom_adj grew exponentially and oom_score_adj grows linearly. 1127b72bdfa7SDavid Rientjes * Values written to oom_adj are simply mapped linearly to oom_score_adj. 1128b72bdfa7SDavid Rientjes * Processes that become oom disabled via oom_adj will still be oom disabled 1129b72bdfa7SDavid Rientjes * with this implementation. 1130b72bdfa7SDavid Rientjes * 1131b72bdfa7SDavid Rientjes * oom_adj cannot be removed since existing userspace binaries use it. 1132b72bdfa7SDavid Rientjes */ 1133fa0cbbf1SDavid Rientjes static ssize_t oom_adj_write(struct file *file, const char __user *buf, 1134fa0cbbf1SDavid Rientjes size_t count, loff_t *ppos) 1135fa0cbbf1SDavid Rientjes { 1136fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 1137fa0cbbf1SDavid Rientjes int oom_adj; 1138fa0cbbf1SDavid Rientjes int err; 1139fa0cbbf1SDavid Rientjes 1140fa0cbbf1SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1141fa0cbbf1SDavid Rientjes if (count > sizeof(buffer) - 1) 1142fa0cbbf1SDavid Rientjes count = sizeof(buffer) - 1; 1143fa0cbbf1SDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1144fa0cbbf1SDavid Rientjes err = -EFAULT; 1145fa0cbbf1SDavid Rientjes goto out; 1146fa0cbbf1SDavid Rientjes } 1147fa0cbbf1SDavid Rientjes 1148fa0cbbf1SDavid Rientjes err = kstrtoint(strstrip(buffer), 0, &oom_adj); 1149fa0cbbf1SDavid Rientjes if (err) 1150fa0cbbf1SDavid Rientjes goto out; 1151fa0cbbf1SDavid Rientjes if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) && 1152fa0cbbf1SDavid Rientjes oom_adj != OOM_DISABLE) { 1153fa0cbbf1SDavid Rientjes err = -EINVAL; 1154fa0cbbf1SDavid Rientjes goto out; 1155fa0cbbf1SDavid Rientjes } 1156fa0cbbf1SDavid Rientjes 1157fa0cbbf1SDavid Rientjes /* 1158fa0cbbf1SDavid Rientjes * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum 1159fa0cbbf1SDavid Rientjes * value is always attainable. 1160fa0cbbf1SDavid Rientjes */ 1161fa0cbbf1SDavid Rientjes if (oom_adj == OOM_ADJUST_MAX) 1162fa0cbbf1SDavid Rientjes oom_adj = OOM_SCORE_ADJ_MAX; 1163fa0cbbf1SDavid Rientjes else 1164fa0cbbf1SDavid Rientjes oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE; 1165fa0cbbf1SDavid Rientjes 11661d5f0acbSMichal Hocko err = __set_oom_adj(file, oom_adj, true); 1167fa0cbbf1SDavid Rientjes out: 1168fa0cbbf1SDavid Rientjes return err < 0 ? err : count; 1169fa0cbbf1SDavid Rientjes } 1170fa0cbbf1SDavid Rientjes 1171fa0cbbf1SDavid Rientjes static const struct file_operations proc_oom_adj_operations = { 1172fa0cbbf1SDavid Rientjes .read = oom_adj_read, 1173fa0cbbf1SDavid Rientjes .write = oom_adj_write, 1174fa0cbbf1SDavid Rientjes .llseek = generic_file_llseek, 1175fa0cbbf1SDavid Rientjes }; 1176fa0cbbf1SDavid Rientjes 1177a63d83f4SDavid Rientjes static ssize_t oom_score_adj_read(struct file *file, char __user *buf, 1178a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1179a63d83f4SDavid Rientjes { 1180496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1181a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1182a9c58b90SDavid Rientjes short oom_score_adj = OOM_SCORE_ADJ_MIN; 1183a63d83f4SDavid Rientjes size_t len; 1184a63d83f4SDavid Rientjes 1185a63d83f4SDavid Rientjes if (!task) 1186a63d83f4SDavid Rientjes return -ESRCH; 1187a63d83f4SDavid Rientjes oom_score_adj = task->signal->oom_score_adj; 1188a63d83f4SDavid Rientjes put_task_struct(task); 1189a9c58b90SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj); 1190a63d83f4SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1191a63d83f4SDavid Rientjes } 1192a63d83f4SDavid Rientjes 1193a63d83f4SDavid Rientjes static ssize_t oom_score_adj_write(struct file *file, const char __user *buf, 1194a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1195a63d83f4SDavid Rientjes { 1196a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 11970a8cb8e3SAlexey Dobriyan int oom_score_adj; 1198a63d83f4SDavid Rientjes int err; 1199a63d83f4SDavid Rientjes 1200a63d83f4SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1201a63d83f4SDavid Rientjes if (count > sizeof(buffer) - 1) 1202a63d83f4SDavid Rientjes count = sizeof(buffer) - 1; 1203723548bfSDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1204723548bfSDavid Rientjes err = -EFAULT; 1205723548bfSDavid Rientjes goto out; 1206723548bfSDavid Rientjes } 1207a63d83f4SDavid Rientjes 12080a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &oom_score_adj); 1209a63d83f4SDavid Rientjes if (err) 1210723548bfSDavid Rientjes goto out; 1211a63d83f4SDavid Rientjes if (oom_score_adj < OOM_SCORE_ADJ_MIN || 1212723548bfSDavid Rientjes oom_score_adj > OOM_SCORE_ADJ_MAX) { 1213723548bfSDavid Rientjes err = -EINVAL; 1214723548bfSDavid Rientjes goto out; 1215723548bfSDavid Rientjes } 1216a63d83f4SDavid Rientjes 12171d5f0acbSMichal Hocko err = __set_oom_adj(file, oom_score_adj, false); 1218723548bfSDavid Rientjes out: 1219723548bfSDavid Rientjes return err < 0 ? err : count; 1220a63d83f4SDavid Rientjes } 1221a63d83f4SDavid Rientjes 1222a63d83f4SDavid Rientjes static const struct file_operations proc_oom_score_adj_operations = { 1223a63d83f4SDavid Rientjes .read = oom_score_adj_read, 1224a63d83f4SDavid Rientjes .write = oom_score_adj_write, 12256038f373SArnd Bergmann .llseek = default_llseek, 1226a63d83f4SDavid Rientjes }; 1227a63d83f4SDavid Rientjes 12284b7d248bSRichard Guy Briggs #ifdef CONFIG_AUDIT 1229b4eb4f7fSAlexey Dobriyan #define TMPBUFLEN 11 12301da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 12311da177e4SLinus Torvalds size_t count, loff_t *ppos) 12321da177e4SLinus Torvalds { 1233496ad9aaSAl Viro struct inode * inode = file_inode(file); 123499f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 12351da177e4SLinus Torvalds ssize_t length; 12361da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 12371da177e4SLinus Torvalds 123899f89551SEric W. Biederman if (!task) 123999f89551SEric W. Biederman return -ESRCH; 12401da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 1241e1760bd5SEric W. Biederman from_kuid(file->f_cred->user_ns, 1242e1760bd5SEric W. Biederman audit_get_loginuid(task))); 124399f89551SEric W. Biederman put_task_struct(task); 12441da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 12451da177e4SLinus Torvalds } 12461da177e4SLinus Torvalds 12471da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 12481da177e4SLinus Torvalds size_t count, loff_t *ppos) 12491da177e4SLinus Torvalds { 1250496ad9aaSAl Viro struct inode * inode = file_inode(file); 12511da177e4SLinus Torvalds uid_t loginuid; 1252e1760bd5SEric W. Biederman kuid_t kloginuid; 1253774636e1SAlexey Dobriyan int rv; 12541da177e4SLinus Torvalds 12557dc52157SPaul E. McKenney rcu_read_lock(); 12567dc52157SPaul E. McKenney if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) { 12577dc52157SPaul E. McKenney rcu_read_unlock(); 12581da177e4SLinus Torvalds return -EPERM; 12597dc52157SPaul E. McKenney } 12607dc52157SPaul E. McKenney rcu_read_unlock(); 12611da177e4SLinus Torvalds 12621da177e4SLinus Torvalds if (*ppos != 0) { 12631da177e4SLinus Torvalds /* No partial writes. */ 12641da177e4SLinus Torvalds return -EINVAL; 12651da177e4SLinus Torvalds } 12661da177e4SLinus Torvalds 1267774636e1SAlexey Dobriyan rv = kstrtou32_from_user(buf, count, 10, &loginuid); 1268774636e1SAlexey Dobriyan if (rv < 0) 1269774636e1SAlexey Dobriyan return rv; 127081407c84SEric Paris 127181407c84SEric Paris /* is userspace tring to explicitly UNSET the loginuid? */ 127281407c84SEric Paris if (loginuid == AUDIT_UID_UNSET) { 127381407c84SEric Paris kloginuid = INVALID_UID; 127481407c84SEric Paris } else { 1275e1760bd5SEric W. Biederman kloginuid = make_kuid(file->f_cred->user_ns, loginuid); 1276774636e1SAlexey Dobriyan if (!uid_valid(kloginuid)) 1277774636e1SAlexey Dobriyan return -EINVAL; 127881407c84SEric Paris } 1279e1760bd5SEric W. Biederman 1280774636e1SAlexey Dobriyan rv = audit_set_loginuid(kloginuid); 1281774636e1SAlexey Dobriyan if (rv < 0) 1282774636e1SAlexey Dobriyan return rv; 1283774636e1SAlexey Dobriyan return count; 12841da177e4SLinus Torvalds } 12851da177e4SLinus Torvalds 128600977a59SArjan van de Ven static const struct file_operations proc_loginuid_operations = { 12871da177e4SLinus Torvalds .read = proc_loginuid_read, 12881da177e4SLinus Torvalds .write = proc_loginuid_write, 128987df8424SArnd Bergmann .llseek = generic_file_llseek, 12901da177e4SLinus Torvalds }; 12911e0bd755SEric Paris 12921e0bd755SEric Paris static ssize_t proc_sessionid_read(struct file * file, char __user * buf, 12931e0bd755SEric Paris size_t count, loff_t *ppos) 12941e0bd755SEric Paris { 1295496ad9aaSAl Viro struct inode * inode = file_inode(file); 12961e0bd755SEric Paris struct task_struct *task = get_proc_task(inode); 12971e0bd755SEric Paris ssize_t length; 12981e0bd755SEric Paris char tmpbuf[TMPBUFLEN]; 12991e0bd755SEric Paris 13001e0bd755SEric Paris if (!task) 13011e0bd755SEric Paris return -ESRCH; 13021e0bd755SEric Paris length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 13031e0bd755SEric Paris audit_get_sessionid(task)); 13041e0bd755SEric Paris put_task_struct(task); 13051e0bd755SEric Paris return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 13061e0bd755SEric Paris } 13071e0bd755SEric Paris 13081e0bd755SEric Paris static const struct file_operations proc_sessionid_operations = { 13091e0bd755SEric Paris .read = proc_sessionid_read, 131087df8424SArnd Bergmann .llseek = generic_file_llseek, 13111e0bd755SEric Paris }; 13121da177e4SLinus Torvalds #endif 13131da177e4SLinus Torvalds 1314f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1315f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_read(struct file * file, char __user * buf, 1316f4f154fdSAkinobu Mita size_t count, loff_t *ppos) 1317f4f154fdSAkinobu Mita { 1318496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1319f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF]; 1320f4f154fdSAkinobu Mita size_t len; 1321f4f154fdSAkinobu Mita int make_it_fail; 1322f4f154fdSAkinobu Mita 1323f4f154fdSAkinobu Mita if (!task) 1324f4f154fdSAkinobu Mita return -ESRCH; 1325f4f154fdSAkinobu Mita make_it_fail = task->make_it_fail; 1326f4f154fdSAkinobu Mita put_task_struct(task); 1327f4f154fdSAkinobu Mita 1328f4f154fdSAkinobu Mita len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail); 13290c28f287SAkinobu Mita 13300c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 1331f4f154fdSAkinobu Mita } 1332f4f154fdSAkinobu Mita 1333f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_write(struct file * file, 1334f4f154fdSAkinobu Mita const char __user * buf, size_t count, loff_t *ppos) 1335f4f154fdSAkinobu Mita { 1336f4f154fdSAkinobu Mita struct task_struct *task; 1337774636e1SAlexey Dobriyan char buffer[PROC_NUMBUF]; 1338f4f154fdSAkinobu Mita int make_it_fail; 1339774636e1SAlexey Dobriyan int rv; 1340f4f154fdSAkinobu Mita 1341f4f154fdSAkinobu Mita if (!capable(CAP_SYS_RESOURCE)) 1342f4f154fdSAkinobu Mita return -EPERM; 1343f4f154fdSAkinobu Mita memset(buffer, 0, sizeof(buffer)); 1344f4f154fdSAkinobu Mita if (count > sizeof(buffer) - 1) 1345f4f154fdSAkinobu Mita count = sizeof(buffer) - 1; 1346f4f154fdSAkinobu Mita if (copy_from_user(buffer, buf, count)) 1347f4f154fdSAkinobu Mita return -EFAULT; 1348774636e1SAlexey Dobriyan rv = kstrtoint(strstrip(buffer), 0, &make_it_fail); 1349774636e1SAlexey Dobriyan if (rv < 0) 1350774636e1SAlexey Dobriyan return rv; 135116caed31SDave Jones if (make_it_fail < 0 || make_it_fail > 1) 135216caed31SDave Jones return -EINVAL; 135316caed31SDave Jones 1354496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1355f4f154fdSAkinobu Mita if (!task) 1356f4f154fdSAkinobu Mita return -ESRCH; 1357f4f154fdSAkinobu Mita task->make_it_fail = make_it_fail; 1358f4f154fdSAkinobu Mita put_task_struct(task); 1359cba8aafeSVincent Li 1360cba8aafeSVincent Li return count; 1361f4f154fdSAkinobu Mita } 1362f4f154fdSAkinobu Mita 136300977a59SArjan van de Ven static const struct file_operations proc_fault_inject_operations = { 1364f4f154fdSAkinobu Mita .read = proc_fault_inject_read, 1365f4f154fdSAkinobu Mita .write = proc_fault_inject_write, 136687df8424SArnd Bergmann .llseek = generic_file_llseek, 1367f4f154fdSAkinobu Mita }; 1368e41d5818SDmitry Vyukov 1369e41d5818SDmitry Vyukov static ssize_t proc_fail_nth_write(struct file *file, const char __user *buf, 1370e41d5818SDmitry Vyukov size_t count, loff_t *ppos) 1371e41d5818SDmitry Vyukov { 1372e41d5818SDmitry Vyukov struct task_struct *task; 13739049f2f6SAkinobu Mita int err; 13749049f2f6SAkinobu Mita unsigned int n; 1375e41d5818SDmitry Vyukov 13769049f2f6SAkinobu Mita err = kstrtouint_from_user(buf, count, 0, &n); 1377e41d5818SDmitry Vyukov if (err) 1378e41d5818SDmitry Vyukov return err; 13791203c8e6SAkinobu Mita 13801203c8e6SAkinobu Mita task = get_proc_task(file_inode(file)); 13811203c8e6SAkinobu Mita if (!task) 13821203c8e6SAkinobu Mita return -ESRCH; 13839f7118b2SAlexey Dobriyan task->fail_nth = n; 13841203c8e6SAkinobu Mita put_task_struct(task); 13851203c8e6SAkinobu Mita 1386e41d5818SDmitry Vyukov return count; 1387e41d5818SDmitry Vyukov } 1388e41d5818SDmitry Vyukov 1389e41d5818SDmitry Vyukov static ssize_t proc_fail_nth_read(struct file *file, char __user *buf, 1390e41d5818SDmitry Vyukov size_t count, loff_t *ppos) 1391e41d5818SDmitry Vyukov { 1392e41d5818SDmitry Vyukov struct task_struct *task; 1393bfc74093SAkinobu Mita char numbuf[PROC_NUMBUF]; 1394bfc74093SAkinobu Mita ssize_t len; 1395e41d5818SDmitry Vyukov 1396e41d5818SDmitry Vyukov task = get_proc_task(file_inode(file)); 1397e41d5818SDmitry Vyukov if (!task) 1398e41d5818SDmitry Vyukov return -ESRCH; 13999f7118b2SAlexey Dobriyan len = snprintf(numbuf, sizeof(numbuf), "%u\n", task->fail_nth); 14001203c8e6SAkinobu Mita put_task_struct(task); 1401a44937feSAlexey Dobriyan return simple_read_from_buffer(buf, count, ppos, numbuf, len); 1402e41d5818SDmitry Vyukov } 1403e41d5818SDmitry Vyukov 1404e41d5818SDmitry Vyukov static const struct file_operations proc_fail_nth_operations = { 1405e41d5818SDmitry Vyukov .read = proc_fail_nth_read, 1406e41d5818SDmitry Vyukov .write = proc_fail_nth_write, 1407e41d5818SDmitry Vyukov }; 1408f4f154fdSAkinobu Mita #endif 1409f4f154fdSAkinobu Mita 14109745512cSArjan van de Ven 141143ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 141243ae34cbSIngo Molnar /* 141343ae34cbSIngo Molnar * Print out various scheduling related per-task fields: 141443ae34cbSIngo Molnar */ 141543ae34cbSIngo Molnar static int sched_show(struct seq_file *m, void *v) 141643ae34cbSIngo Molnar { 141743ae34cbSIngo Molnar struct inode *inode = m->private; 141876f668beSChristoph Hellwig struct pid_namespace *ns = proc_pid_ns(inode); 141943ae34cbSIngo Molnar struct task_struct *p; 142043ae34cbSIngo Molnar 142143ae34cbSIngo Molnar p = get_proc_task(inode); 142243ae34cbSIngo Molnar if (!p) 142343ae34cbSIngo Molnar return -ESRCH; 142474dc3384SAleksa Sarai proc_sched_show_task(p, ns, m); 142543ae34cbSIngo Molnar 142643ae34cbSIngo Molnar put_task_struct(p); 142743ae34cbSIngo Molnar 142843ae34cbSIngo Molnar return 0; 142943ae34cbSIngo Molnar } 143043ae34cbSIngo Molnar 143143ae34cbSIngo Molnar static ssize_t 143243ae34cbSIngo Molnar sched_write(struct file *file, const char __user *buf, 143343ae34cbSIngo Molnar size_t count, loff_t *offset) 143443ae34cbSIngo Molnar { 1435496ad9aaSAl Viro struct inode *inode = file_inode(file); 143643ae34cbSIngo Molnar struct task_struct *p; 143743ae34cbSIngo Molnar 143843ae34cbSIngo Molnar p = get_proc_task(inode); 143943ae34cbSIngo Molnar if (!p) 144043ae34cbSIngo Molnar return -ESRCH; 144143ae34cbSIngo Molnar proc_sched_set_task(p); 144243ae34cbSIngo Molnar 144343ae34cbSIngo Molnar put_task_struct(p); 144443ae34cbSIngo Molnar 144543ae34cbSIngo Molnar return count; 144643ae34cbSIngo Molnar } 144743ae34cbSIngo Molnar 144843ae34cbSIngo Molnar static int sched_open(struct inode *inode, struct file *filp) 144943ae34cbSIngo Molnar { 1450c6a34058SJovi Zhang return single_open(filp, sched_show, inode); 145143ae34cbSIngo Molnar } 145243ae34cbSIngo Molnar 145343ae34cbSIngo Molnar static const struct file_operations proc_pid_sched_operations = { 145443ae34cbSIngo Molnar .open = sched_open, 145543ae34cbSIngo Molnar .read = seq_read, 145643ae34cbSIngo Molnar .write = sched_write, 145743ae34cbSIngo Molnar .llseek = seq_lseek, 14585ea473a1SAlexey Dobriyan .release = single_release, 145943ae34cbSIngo Molnar }; 146043ae34cbSIngo Molnar 146143ae34cbSIngo Molnar #endif 146243ae34cbSIngo Molnar 14635091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 14645091faa4SMike Galbraith /* 14655091faa4SMike Galbraith * Print out autogroup related information: 14665091faa4SMike Galbraith */ 14675091faa4SMike Galbraith static int sched_autogroup_show(struct seq_file *m, void *v) 14685091faa4SMike Galbraith { 14695091faa4SMike Galbraith struct inode *inode = m->private; 14705091faa4SMike Galbraith struct task_struct *p; 14715091faa4SMike Galbraith 14725091faa4SMike Galbraith p = get_proc_task(inode); 14735091faa4SMike Galbraith if (!p) 14745091faa4SMike Galbraith return -ESRCH; 14755091faa4SMike Galbraith proc_sched_autogroup_show_task(p, m); 14765091faa4SMike Galbraith 14775091faa4SMike Galbraith put_task_struct(p); 14785091faa4SMike Galbraith 14795091faa4SMike Galbraith return 0; 14805091faa4SMike Galbraith } 14815091faa4SMike Galbraith 14825091faa4SMike Galbraith static ssize_t 14835091faa4SMike Galbraith sched_autogroup_write(struct file *file, const char __user *buf, 14845091faa4SMike Galbraith size_t count, loff_t *offset) 14855091faa4SMike Galbraith { 1486496ad9aaSAl Viro struct inode *inode = file_inode(file); 14875091faa4SMike Galbraith struct task_struct *p; 14885091faa4SMike Galbraith char buffer[PROC_NUMBUF]; 14890a8cb8e3SAlexey Dobriyan int nice; 14905091faa4SMike Galbraith int err; 14915091faa4SMike Galbraith 14925091faa4SMike Galbraith memset(buffer, 0, sizeof(buffer)); 14935091faa4SMike Galbraith if (count > sizeof(buffer) - 1) 14945091faa4SMike Galbraith count = sizeof(buffer) - 1; 14955091faa4SMike Galbraith if (copy_from_user(buffer, buf, count)) 14965091faa4SMike Galbraith return -EFAULT; 14975091faa4SMike Galbraith 14980a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &nice); 14990a8cb8e3SAlexey Dobriyan if (err < 0) 15000a8cb8e3SAlexey Dobriyan return err; 15015091faa4SMike Galbraith 15025091faa4SMike Galbraith p = get_proc_task(inode); 15035091faa4SMike Galbraith if (!p) 15045091faa4SMike Galbraith return -ESRCH; 15055091faa4SMike Galbraith 15062e5b5b3aSHiroshi Shimamoto err = proc_sched_autogroup_set_nice(p, nice); 15075091faa4SMike Galbraith if (err) 15085091faa4SMike Galbraith count = err; 15095091faa4SMike Galbraith 15105091faa4SMike Galbraith put_task_struct(p); 15115091faa4SMike Galbraith 15125091faa4SMike Galbraith return count; 15135091faa4SMike Galbraith } 15145091faa4SMike Galbraith 15155091faa4SMike Galbraith static int sched_autogroup_open(struct inode *inode, struct file *filp) 15165091faa4SMike Galbraith { 15175091faa4SMike Galbraith int ret; 15185091faa4SMike Galbraith 15195091faa4SMike Galbraith ret = single_open(filp, sched_autogroup_show, NULL); 15205091faa4SMike Galbraith if (!ret) { 15215091faa4SMike Galbraith struct seq_file *m = filp->private_data; 15225091faa4SMike Galbraith 15235091faa4SMike Galbraith m->private = inode; 15245091faa4SMike Galbraith } 15255091faa4SMike Galbraith return ret; 15265091faa4SMike Galbraith } 15275091faa4SMike Galbraith 15285091faa4SMike Galbraith static const struct file_operations proc_pid_sched_autogroup_operations = { 15295091faa4SMike Galbraith .open = sched_autogroup_open, 15305091faa4SMike Galbraith .read = seq_read, 15315091faa4SMike Galbraith .write = sched_autogroup_write, 15325091faa4SMike Galbraith .llseek = seq_lseek, 15335091faa4SMike Galbraith .release = single_release, 15345091faa4SMike Galbraith }; 15355091faa4SMike Galbraith 15365091faa4SMike Galbraith #endif /* CONFIG_SCHED_AUTOGROUP */ 15375091faa4SMike Galbraith 153804a8682aSAndrei Vagin #ifdef CONFIG_TIME_NS 153904a8682aSAndrei Vagin static int timens_offsets_show(struct seq_file *m, void *v) 154004a8682aSAndrei Vagin { 154104a8682aSAndrei Vagin struct task_struct *p; 154204a8682aSAndrei Vagin 154304a8682aSAndrei Vagin p = get_proc_task(file_inode(m->file)); 154404a8682aSAndrei Vagin if (!p) 154504a8682aSAndrei Vagin return -ESRCH; 154604a8682aSAndrei Vagin proc_timens_show_offsets(p, m); 154704a8682aSAndrei Vagin 154804a8682aSAndrei Vagin put_task_struct(p); 154904a8682aSAndrei Vagin 155004a8682aSAndrei Vagin return 0; 155104a8682aSAndrei Vagin } 155204a8682aSAndrei Vagin 155304a8682aSAndrei Vagin static ssize_t timens_offsets_write(struct file *file, const char __user *buf, 155404a8682aSAndrei Vagin size_t count, loff_t *ppos) 155504a8682aSAndrei Vagin { 155604a8682aSAndrei Vagin struct inode *inode = file_inode(file); 155704a8682aSAndrei Vagin struct proc_timens_offset offsets[2]; 155804a8682aSAndrei Vagin char *kbuf = NULL, *pos, *next_line; 155904a8682aSAndrei Vagin struct task_struct *p; 156004a8682aSAndrei Vagin int ret, noffsets; 156104a8682aSAndrei Vagin 156204a8682aSAndrei Vagin /* Only allow < page size writes at the beginning of the file */ 156304a8682aSAndrei Vagin if ((*ppos != 0) || (count >= PAGE_SIZE)) 156404a8682aSAndrei Vagin return -EINVAL; 156504a8682aSAndrei Vagin 156604a8682aSAndrei Vagin /* Slurp in the user data */ 156704a8682aSAndrei Vagin kbuf = memdup_user_nul(buf, count); 156804a8682aSAndrei Vagin if (IS_ERR(kbuf)) 156904a8682aSAndrei Vagin return PTR_ERR(kbuf); 157004a8682aSAndrei Vagin 157104a8682aSAndrei Vagin /* Parse the user data */ 157204a8682aSAndrei Vagin ret = -EINVAL; 157304a8682aSAndrei Vagin noffsets = 0; 157404a8682aSAndrei Vagin for (pos = kbuf; pos; pos = next_line) { 157504a8682aSAndrei Vagin struct proc_timens_offset *off = &offsets[noffsets]; 1576*94d440d6SAndrei Vagin char clock[10]; 157704a8682aSAndrei Vagin int err; 157804a8682aSAndrei Vagin 157904a8682aSAndrei Vagin /* Find the end of line and ensure we don't look past it */ 158004a8682aSAndrei Vagin next_line = strchr(pos, '\n'); 158104a8682aSAndrei Vagin if (next_line) { 158204a8682aSAndrei Vagin *next_line = '\0'; 158304a8682aSAndrei Vagin next_line++; 158404a8682aSAndrei Vagin if (*next_line == '\0') 158504a8682aSAndrei Vagin next_line = NULL; 158604a8682aSAndrei Vagin } 158704a8682aSAndrei Vagin 1588*94d440d6SAndrei Vagin err = sscanf(pos, "%9s %lld %lu", clock, 158904a8682aSAndrei Vagin &off->val.tv_sec, &off->val.tv_nsec); 159004a8682aSAndrei Vagin if (err != 3 || off->val.tv_nsec >= NSEC_PER_SEC) 159104a8682aSAndrei Vagin goto out; 1592*94d440d6SAndrei Vagin 1593*94d440d6SAndrei Vagin clock[sizeof(clock) - 1] = 0; 1594*94d440d6SAndrei Vagin if (strcmp(clock, "monotonic") == 0 || 1595*94d440d6SAndrei Vagin strcmp(clock, __stringify(CLOCK_MONOTONIC)) == 0) 1596*94d440d6SAndrei Vagin off->clockid = CLOCK_MONOTONIC; 1597*94d440d6SAndrei Vagin else if (strcmp(clock, "boottime") == 0 || 1598*94d440d6SAndrei Vagin strcmp(clock, __stringify(CLOCK_BOOTTIME)) == 0) 1599*94d440d6SAndrei Vagin off->clockid = CLOCK_BOOTTIME; 1600*94d440d6SAndrei Vagin else 1601*94d440d6SAndrei Vagin goto out; 1602*94d440d6SAndrei Vagin 160304a8682aSAndrei Vagin noffsets++; 160404a8682aSAndrei Vagin if (noffsets == ARRAY_SIZE(offsets)) { 160504a8682aSAndrei Vagin if (next_line) 160604a8682aSAndrei Vagin count = next_line - kbuf; 160704a8682aSAndrei Vagin break; 160804a8682aSAndrei Vagin } 160904a8682aSAndrei Vagin } 161004a8682aSAndrei Vagin 161104a8682aSAndrei Vagin ret = -ESRCH; 161204a8682aSAndrei Vagin p = get_proc_task(inode); 161304a8682aSAndrei Vagin if (!p) 161404a8682aSAndrei Vagin goto out; 161504a8682aSAndrei Vagin ret = proc_timens_set_offset(file, p, offsets, noffsets); 161604a8682aSAndrei Vagin put_task_struct(p); 161704a8682aSAndrei Vagin if (ret) 161804a8682aSAndrei Vagin goto out; 161904a8682aSAndrei Vagin 162004a8682aSAndrei Vagin ret = count; 162104a8682aSAndrei Vagin out: 162204a8682aSAndrei Vagin kfree(kbuf); 162304a8682aSAndrei Vagin return ret; 162404a8682aSAndrei Vagin } 162504a8682aSAndrei Vagin 162604a8682aSAndrei Vagin static int timens_offsets_open(struct inode *inode, struct file *filp) 162704a8682aSAndrei Vagin { 162804a8682aSAndrei Vagin return single_open(filp, timens_offsets_show, inode); 162904a8682aSAndrei Vagin } 163004a8682aSAndrei Vagin 163104a8682aSAndrei Vagin static const struct file_operations proc_timens_offsets_operations = { 163204a8682aSAndrei Vagin .open = timens_offsets_open, 163304a8682aSAndrei Vagin .read = seq_read, 163404a8682aSAndrei Vagin .write = timens_offsets_write, 163504a8682aSAndrei Vagin .llseek = seq_lseek, 163604a8682aSAndrei Vagin .release = single_release, 163704a8682aSAndrei Vagin }; 163804a8682aSAndrei Vagin #endif /* CONFIG_TIME_NS */ 163904a8682aSAndrei Vagin 16404614a696Sjohn stultz static ssize_t comm_write(struct file *file, const char __user *buf, 16414614a696Sjohn stultz size_t count, loff_t *offset) 16424614a696Sjohn stultz { 1643496ad9aaSAl Viro struct inode *inode = file_inode(file); 16444614a696Sjohn stultz struct task_struct *p; 16454614a696Sjohn stultz char buffer[TASK_COMM_LEN]; 1646830e0fc9SDavid Rientjes const size_t maxlen = sizeof(buffer) - 1; 16474614a696Sjohn stultz 16484614a696Sjohn stultz memset(buffer, 0, sizeof(buffer)); 1649830e0fc9SDavid Rientjes if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count)) 16504614a696Sjohn stultz return -EFAULT; 16514614a696Sjohn stultz 16524614a696Sjohn stultz p = get_proc_task(inode); 16534614a696Sjohn stultz if (!p) 16544614a696Sjohn stultz return -ESRCH; 16554614a696Sjohn stultz 16564614a696Sjohn stultz if (same_thread_group(current, p)) 16574614a696Sjohn stultz set_task_comm(p, buffer); 16584614a696Sjohn stultz else 16594614a696Sjohn stultz count = -EINVAL; 16604614a696Sjohn stultz 16614614a696Sjohn stultz put_task_struct(p); 16624614a696Sjohn stultz 16634614a696Sjohn stultz return count; 16644614a696Sjohn stultz } 16654614a696Sjohn stultz 16664614a696Sjohn stultz static int comm_show(struct seq_file *m, void *v) 16674614a696Sjohn stultz { 16684614a696Sjohn stultz struct inode *inode = m->private; 16694614a696Sjohn stultz struct task_struct *p; 16704614a696Sjohn stultz 16714614a696Sjohn stultz p = get_proc_task(inode); 16724614a696Sjohn stultz if (!p) 16734614a696Sjohn stultz return -ESRCH; 16744614a696Sjohn stultz 167588b72b31STejun Heo proc_task_name(m, p, false); 167688b72b31STejun Heo seq_putc(m, '\n'); 16774614a696Sjohn stultz 16784614a696Sjohn stultz put_task_struct(p); 16794614a696Sjohn stultz 16804614a696Sjohn stultz return 0; 16814614a696Sjohn stultz } 16824614a696Sjohn stultz 16834614a696Sjohn stultz static int comm_open(struct inode *inode, struct file *filp) 16844614a696Sjohn stultz { 1685c6a34058SJovi Zhang return single_open(filp, comm_show, inode); 16864614a696Sjohn stultz } 16874614a696Sjohn stultz 16884614a696Sjohn stultz static const struct file_operations proc_pid_set_comm_operations = { 16894614a696Sjohn stultz .open = comm_open, 16904614a696Sjohn stultz .read = seq_read, 16914614a696Sjohn stultz .write = comm_write, 16924614a696Sjohn stultz .llseek = seq_lseek, 16934614a696Sjohn stultz .release = single_release, 16944614a696Sjohn stultz }; 16954614a696Sjohn stultz 16967773fbc5SCyrill Gorcunov static int proc_exe_link(struct dentry *dentry, struct path *exe_path) 1697925d1c40SMatt Helsley { 1698925d1c40SMatt Helsley struct task_struct *task; 1699925d1c40SMatt Helsley struct file *exe_file; 1700925d1c40SMatt Helsley 17012b0143b5SDavid Howells task = get_proc_task(d_inode(dentry)); 1702925d1c40SMatt Helsley if (!task) 1703925d1c40SMatt Helsley return -ENOENT; 1704cd81a917SMateusz Guzik exe_file = get_task_exe_file(task); 1705925d1c40SMatt Helsley put_task_struct(task); 1706925d1c40SMatt Helsley if (exe_file) { 1707925d1c40SMatt Helsley *exe_path = exe_file->f_path; 1708925d1c40SMatt Helsley path_get(&exe_file->f_path); 1709925d1c40SMatt Helsley fput(exe_file); 1710925d1c40SMatt Helsley return 0; 1711925d1c40SMatt Helsley } else 1712925d1c40SMatt Helsley return -ENOENT; 1713925d1c40SMatt Helsley } 1714925d1c40SMatt Helsley 17156b255391SAl Viro static const char *proc_pid_get_link(struct dentry *dentry, 1716fceef393SAl Viro struct inode *inode, 1717fceef393SAl Viro struct delayed_call *done) 17181da177e4SLinus Torvalds { 1719408ef013SChristoph Hellwig struct path path; 17201da177e4SLinus Torvalds int error = -EACCES; 17211da177e4SLinus Torvalds 17226b255391SAl Viro if (!dentry) 17236b255391SAl Viro return ERR_PTR(-ECHILD); 17246b255391SAl Viro 1725778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1726778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 17271da177e4SLinus Torvalds goto out; 17281da177e4SLinus Torvalds 1729408ef013SChristoph Hellwig error = PROC_I(inode)->op.proc_get_link(dentry, &path); 1730408ef013SChristoph Hellwig if (error) 1731408ef013SChristoph Hellwig goto out; 1732408ef013SChristoph Hellwig 17331bc82070SAleksa Sarai error = nd_jump_link(&path); 17341da177e4SLinus Torvalds out: 1735008b150aSAl Viro return ERR_PTR(error); 17361da177e4SLinus Torvalds } 17371da177e4SLinus Torvalds 17383dcd25f3SJan Blunck static int do_proc_readlink(struct path *path, char __user *buffer, int buflen) 17391da177e4SLinus Torvalds { 17400ee931c4SMichal Hocko char *tmp = (char *)__get_free_page(GFP_KERNEL); 17413dcd25f3SJan Blunck char *pathname; 17421da177e4SLinus Torvalds int len; 17431da177e4SLinus Torvalds 17441da177e4SLinus Torvalds if (!tmp) 17451da177e4SLinus Torvalds return -ENOMEM; 17461da177e4SLinus Torvalds 17477b2a69baSEric W. Biederman pathname = d_path(path, tmp, PAGE_SIZE); 17483dcd25f3SJan Blunck len = PTR_ERR(pathname); 17493dcd25f3SJan Blunck if (IS_ERR(pathname)) 17501da177e4SLinus Torvalds goto out; 17513dcd25f3SJan Blunck len = tmp + PAGE_SIZE - 1 - pathname; 17521da177e4SLinus Torvalds 17531da177e4SLinus Torvalds if (len > buflen) 17541da177e4SLinus Torvalds len = buflen; 17553dcd25f3SJan Blunck if (copy_to_user(buffer, pathname, len)) 17561da177e4SLinus Torvalds len = -EFAULT; 17571da177e4SLinus Torvalds out: 17581da177e4SLinus Torvalds free_page((unsigned long)tmp); 17591da177e4SLinus Torvalds return len; 17601da177e4SLinus Torvalds } 17611da177e4SLinus Torvalds 17621da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 17631da177e4SLinus Torvalds { 17641da177e4SLinus Torvalds int error = -EACCES; 17652b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 17663dcd25f3SJan Blunck struct path path; 17671da177e4SLinus Torvalds 1768778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1769778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 17701da177e4SLinus Torvalds goto out; 17711da177e4SLinus Torvalds 17727773fbc5SCyrill Gorcunov error = PROC_I(inode)->op.proc_get_link(dentry, &path); 17731da177e4SLinus Torvalds if (error) 17741da177e4SLinus Torvalds goto out; 17751da177e4SLinus Torvalds 17763dcd25f3SJan Blunck error = do_proc_readlink(&path, buffer, buflen); 17773dcd25f3SJan Blunck path_put(&path); 17781da177e4SLinus Torvalds out: 17791da177e4SLinus Torvalds return error; 17801da177e4SLinus Torvalds } 17811da177e4SLinus Torvalds 1782faf60af1SCyrill Gorcunov const struct inode_operations proc_pid_link_inode_operations = { 17831da177e4SLinus Torvalds .readlink = proc_pid_readlink, 17846b255391SAl Viro .get_link = proc_pid_get_link, 17856d76fa58SLinus Torvalds .setattr = proc_setattr, 17861da177e4SLinus Torvalds }; 17871da177e4SLinus Torvalds 178828a6d671SEric W. Biederman 178928a6d671SEric W. Biederman /* building an inode */ 179028a6d671SEric W. Biederman 1791c6eb50d2SAl Viro void task_dump_owner(struct task_struct *task, umode_t mode, 179268eb94f1SEric W. Biederman kuid_t *ruid, kgid_t *rgid) 179368eb94f1SEric W. Biederman { 179468eb94f1SEric W. Biederman /* Depending on the state of dumpable compute who should own a 179568eb94f1SEric W. Biederman * proc file for a task. 179668eb94f1SEric W. Biederman */ 179768eb94f1SEric W. Biederman const struct cred *cred; 179868eb94f1SEric W. Biederman kuid_t uid; 179968eb94f1SEric W. Biederman kgid_t gid; 180068eb94f1SEric W. Biederman 18012e0ad552SAlexey Dobriyan if (unlikely(task->flags & PF_KTHREAD)) { 18022e0ad552SAlexey Dobriyan *ruid = GLOBAL_ROOT_UID; 18032e0ad552SAlexey Dobriyan *rgid = GLOBAL_ROOT_GID; 18042e0ad552SAlexey Dobriyan return; 18052e0ad552SAlexey Dobriyan } 18062e0ad552SAlexey Dobriyan 180768eb94f1SEric W. Biederman /* Default to the tasks effective ownership */ 180868eb94f1SEric W. Biederman rcu_read_lock(); 180968eb94f1SEric W. Biederman cred = __task_cred(task); 181068eb94f1SEric W. Biederman uid = cred->euid; 181168eb94f1SEric W. Biederman gid = cred->egid; 181268eb94f1SEric W. Biederman rcu_read_unlock(); 181368eb94f1SEric W. Biederman 181468eb94f1SEric W. Biederman /* 181568eb94f1SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 181668eb94f1SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 181768eb94f1SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 181868eb94f1SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 181968eb94f1SEric W. Biederman * made this apply to all per process world readable and executable 182068eb94f1SEric W. Biederman * directories. 182168eb94f1SEric W. Biederman */ 182268eb94f1SEric W. Biederman if (mode != (S_IFDIR|S_IRUGO|S_IXUGO)) { 182368eb94f1SEric W. Biederman struct mm_struct *mm; 182468eb94f1SEric W. Biederman task_lock(task); 182568eb94f1SEric W. Biederman mm = task->mm; 182668eb94f1SEric W. Biederman /* Make non-dumpable tasks owned by some root */ 182768eb94f1SEric W. Biederman if (mm) { 182868eb94f1SEric W. Biederman if (get_dumpable(mm) != SUID_DUMP_USER) { 182968eb94f1SEric W. Biederman struct user_namespace *user_ns = mm->user_ns; 183068eb94f1SEric W. Biederman 183168eb94f1SEric W. Biederman uid = make_kuid(user_ns, 0); 183268eb94f1SEric W. Biederman if (!uid_valid(uid)) 183368eb94f1SEric W. Biederman uid = GLOBAL_ROOT_UID; 183468eb94f1SEric W. Biederman 183568eb94f1SEric W. Biederman gid = make_kgid(user_ns, 0); 183668eb94f1SEric W. Biederman if (!gid_valid(gid)) 183768eb94f1SEric W. Biederman gid = GLOBAL_ROOT_GID; 183868eb94f1SEric W. Biederman } 183968eb94f1SEric W. Biederman } else { 184068eb94f1SEric W. Biederman uid = GLOBAL_ROOT_UID; 184168eb94f1SEric W. Biederman gid = GLOBAL_ROOT_GID; 184268eb94f1SEric W. Biederman } 184368eb94f1SEric W. Biederman task_unlock(task); 184468eb94f1SEric W. Biederman } 184568eb94f1SEric W. Biederman *ruid = uid; 184668eb94f1SEric W. Biederman *rgid = gid; 184768eb94f1SEric W. Biederman } 184868eb94f1SEric W. Biederman 18497bc3e6e5SEric W. Biederman void proc_pid_evict_inode(struct proc_inode *ei) 18507bc3e6e5SEric W. Biederman { 18517bc3e6e5SEric W. Biederman struct pid *pid = ei->pid; 18527bc3e6e5SEric W. Biederman 18537bc3e6e5SEric W. Biederman if (S_ISDIR(ei->vfs_inode.i_mode)) { 185463f818f4SEric W. Biederman spin_lock(&pid->lock); 18557bc3e6e5SEric W. Biederman hlist_del_init_rcu(&ei->sibling_inodes); 185663f818f4SEric W. Biederman spin_unlock(&pid->lock); 18577bc3e6e5SEric W. Biederman } 18587bc3e6e5SEric W. Biederman 18597bc3e6e5SEric W. Biederman put_pid(pid); 18607bc3e6e5SEric W. Biederman } 18617bc3e6e5SEric W. Biederman 1862db978da8SAndreas Gruenbacher struct inode *proc_pid_make_inode(struct super_block * sb, 1863db978da8SAndreas Gruenbacher struct task_struct *task, umode_t mode) 186428a6d671SEric W. Biederman { 186528a6d671SEric W. Biederman struct inode * inode; 186628a6d671SEric W. Biederman struct proc_inode *ei; 18677bc3e6e5SEric W. Biederman struct pid *pid; 186828a6d671SEric W. Biederman 186928a6d671SEric W. Biederman /* We need a new inode */ 187028a6d671SEric W. Biederman 187128a6d671SEric W. Biederman inode = new_inode(sb); 187228a6d671SEric W. Biederman if (!inode) 187328a6d671SEric W. Biederman goto out; 187428a6d671SEric W. Biederman 187528a6d671SEric W. Biederman /* Common stuff */ 187628a6d671SEric W. Biederman ei = PROC_I(inode); 1877db978da8SAndreas Gruenbacher inode->i_mode = mode; 187885fe4025SChristoph Hellwig inode->i_ino = get_next_ino(); 1879078cd827SDeepa Dinamani inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); 188028a6d671SEric W. Biederman inode->i_op = &proc_def_inode_operations; 188128a6d671SEric W. Biederman 188228a6d671SEric W. Biederman /* 188328a6d671SEric W. Biederman * grab the reference to task. 188428a6d671SEric W. Biederman */ 18857bc3e6e5SEric W. Biederman pid = get_task_pid(task, PIDTYPE_PID); 18867bc3e6e5SEric W. Biederman if (!pid) 188728a6d671SEric W. Biederman goto out_unlock; 188828a6d671SEric W. Biederman 18897bc3e6e5SEric W. Biederman /* Let the pid remember us for quick removal */ 18907bc3e6e5SEric W. Biederman ei->pid = pid; 18917bc3e6e5SEric W. Biederman if (S_ISDIR(mode)) { 189263f818f4SEric W. Biederman spin_lock(&pid->lock); 18937bc3e6e5SEric W. Biederman hlist_add_head_rcu(&ei->sibling_inodes, &pid->inodes); 189463f818f4SEric W. Biederman spin_unlock(&pid->lock); 18957bc3e6e5SEric W. Biederman } 18967bc3e6e5SEric W. Biederman 189768eb94f1SEric W. Biederman task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid); 189828a6d671SEric W. Biederman security_task_to_inode(task, inode); 189928a6d671SEric W. Biederman 190028a6d671SEric W. Biederman out: 190128a6d671SEric W. Biederman return inode; 190228a6d671SEric W. Biederman 190328a6d671SEric W. Biederman out_unlock: 190428a6d671SEric W. Biederman iput(inode); 190528a6d671SEric W. Biederman return NULL; 190628a6d671SEric W. Biederman } 190728a6d671SEric W. Biederman 1908a528d35eSDavid Howells int pid_getattr(const struct path *path, struct kstat *stat, 1909a528d35eSDavid Howells u32 request_mask, unsigned int query_flags) 191028a6d671SEric W. Biederman { 1911a528d35eSDavid Howells struct inode *inode = d_inode(path->dentry); 191276f668beSChristoph Hellwig struct pid_namespace *pid = proc_pid_ns(inode); 191328a6d671SEric W. Biederman struct task_struct *task; 1914c69e8d9cSDavid Howells 191528a6d671SEric W. Biederman generic_fillattr(inode, stat); 191628a6d671SEric W. Biederman 1917dcb0f222SEric W. Biederman stat->uid = GLOBAL_ROOT_UID; 1918dcb0f222SEric W. Biederman stat->gid = GLOBAL_ROOT_GID; 191994116929SAlexey Dobriyan rcu_read_lock(); 192028a6d671SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 192128a6d671SEric W. Biederman if (task) { 1922796f571bSLafcadio Wluiki if (!has_pid_permissions(pid, task, HIDEPID_INVISIBLE)) { 19230499680aSVasiliy Kulikov rcu_read_unlock(); 19240499680aSVasiliy Kulikov /* 19250499680aSVasiliy Kulikov * This doesn't prevent learning whether PID exists, 19260499680aSVasiliy Kulikov * it only makes getattr() consistent with readdir(). 19270499680aSVasiliy Kulikov */ 19280499680aSVasiliy Kulikov return -ENOENT; 19290499680aSVasiliy Kulikov } 193068eb94f1SEric W. Biederman task_dump_owner(task, inode->i_mode, &stat->uid, &stat->gid); 193128a6d671SEric W. Biederman } 193228a6d671SEric W. Biederman rcu_read_unlock(); 193328a6d671SEric W. Biederman return 0; 193428a6d671SEric W. Biederman } 193528a6d671SEric W. Biederman 193628a6d671SEric W. Biederman /* dentry stuff */ 193728a6d671SEric W. Biederman 193828a6d671SEric W. Biederman /* 19391bbc5513SAl Viro * Set <pid>/... inode ownership (can change due to setuid(), etc.) 19401bbc5513SAl Viro */ 19411bbc5513SAl Viro void pid_update_inode(struct task_struct *task, struct inode *inode) 19421bbc5513SAl Viro { 19431bbc5513SAl Viro task_dump_owner(task, inode->i_mode, &inode->i_uid, &inode->i_gid); 19441bbc5513SAl Viro 19451bbc5513SAl Viro inode->i_mode &= ~(S_ISUID | S_ISGID); 19461bbc5513SAl Viro security_task_to_inode(task, inode); 19471bbc5513SAl Viro } 19481bbc5513SAl Viro 19491bbc5513SAl Viro /* 195028a6d671SEric W. Biederman * Rewrite the inode's ownerships here because the owning task may have 195128a6d671SEric W. Biederman * performed a setuid(), etc. 195228a6d671SEric W. Biederman * 195328a6d671SEric W. Biederman */ 19541bbc5513SAl Viro static int pid_revalidate(struct dentry *dentry, unsigned int flags) 195528a6d671SEric W. Biederman { 195634286d66SNick Piggin struct inode *inode; 195734286d66SNick Piggin struct task_struct *task; 1958c69e8d9cSDavid Howells 19590b728e19SAl Viro if (flags & LOOKUP_RCU) 196034286d66SNick Piggin return -ECHILD; 196134286d66SNick Piggin 19622b0143b5SDavid Howells inode = d_inode(dentry); 196334286d66SNick Piggin task = get_proc_task(inode); 196434286d66SNick Piggin 196528a6d671SEric W. Biederman if (task) { 19661bbc5513SAl Viro pid_update_inode(task, inode); 196728a6d671SEric W. Biederman put_task_struct(task); 196828a6d671SEric W. Biederman return 1; 196928a6d671SEric W. Biederman } 197028a6d671SEric W. Biederman return 0; 197128a6d671SEric W. Biederman } 197228a6d671SEric W. Biederman 1973d855a4b7SOleg Nesterov static inline bool proc_inode_is_dead(struct inode *inode) 1974d855a4b7SOleg Nesterov { 1975d855a4b7SOleg Nesterov return !proc_pid(inode)->tasks[PIDTYPE_PID].first; 1976d855a4b7SOleg Nesterov } 1977d855a4b7SOleg Nesterov 19781dd704b6SDavid Howells int pid_delete_dentry(const struct dentry *dentry) 19791dd704b6SDavid Howells { 19801dd704b6SDavid Howells /* Is the task we represent dead? 19811dd704b6SDavid Howells * If so, then don't put the dentry on the lru list, 19821dd704b6SDavid Howells * kill it immediately. 19831dd704b6SDavid Howells */ 19842b0143b5SDavid Howells return proc_inode_is_dead(d_inode(dentry)); 19851dd704b6SDavid Howells } 19861dd704b6SDavid Howells 19876b4e306aSEric W. Biederman const struct dentry_operations pid_dentry_operations = 198828a6d671SEric W. Biederman { 198928a6d671SEric W. Biederman .d_revalidate = pid_revalidate, 199028a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 199128a6d671SEric W. Biederman }; 199228a6d671SEric W. Biederman 199328a6d671SEric W. Biederman /* Lookups */ 199428a6d671SEric W. Biederman 19951c0d04c9SEric W. Biederman /* 19961c0d04c9SEric W. Biederman * Fill a directory entry. 19971c0d04c9SEric W. Biederman * 19981c0d04c9SEric W. Biederman * If possible create the dcache entry and derive our inode number and 19991c0d04c9SEric W. Biederman * file type from dcache entry. 20001c0d04c9SEric W. Biederman * 20011c0d04c9SEric W. Biederman * Since all of the proc inode numbers are dynamically generated, the inode 20021c0d04c9SEric W. Biederman * numbers do not exist until the inode is cache. This means creating the 20031c0d04c9SEric W. Biederman * the dcache entry in readdir is necessary to keep the inode numbers 20041c0d04c9SEric W. Biederman * reported by readdir in sync with the inode numbers reported 20051c0d04c9SEric W. Biederman * by stat. 20061c0d04c9SEric W. Biederman */ 2007f0c3b509SAl Viro bool proc_fill_cache(struct file *file, struct dir_context *ctx, 2008a4ef3895SAlexey Dobriyan const char *name, unsigned int len, 2009c5141e6dSEric Dumazet instantiate_t instantiate, struct task_struct *task, const void *ptr) 201061a28784SEric W. Biederman { 2011f0c3b509SAl Viro struct dentry *child, *dir = file->f_path.dentry; 20121df98b8bSAl Viro struct qstr qname = QSTR_INIT(name, len); 201361a28784SEric W. Biederman struct inode *inode; 20140168b9e3SAl Viro unsigned type = DT_UNKNOWN; 20150168b9e3SAl Viro ino_t ino = 1; 201661a28784SEric W. Biederman 20171df98b8bSAl Viro child = d_hash_and_lookup(dir, &qname); 201861a28784SEric W. Biederman if (!child) { 20193781764bSAl Viro DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 20203781764bSAl Viro child = d_alloc_parallel(dir, &qname, &wq); 20213781764bSAl Viro if (IS_ERR(child)) 202261a28784SEric W. Biederman goto end_instantiate; 20233781764bSAl Viro if (d_in_lookup(child)) { 20240168b9e3SAl Viro struct dentry *res; 20250168b9e3SAl Viro res = instantiate(child, task, ptr); 20263781764bSAl Viro d_lookup_done(child); 20270168b9e3SAl Viro if (unlikely(res)) { 20280168b9e3SAl Viro dput(child); 20290168b9e3SAl Viro child = res; 2030d85b399bSAl Viro if (IS_ERR(child)) 2031d85b399bSAl Viro goto end_instantiate; 20321df98b8bSAl Viro } 20331df98b8bSAl Viro } 20343781764bSAl Viro } 20352b0143b5SDavid Howells inode = d_inode(child); 203661a28784SEric W. Biederman ino = inode->i_ino; 203761a28784SEric W. Biederman type = inode->i_mode >> 12; 203861a28784SEric W. Biederman dput(child); 2039d85b399bSAl Viro end_instantiate: 2040f0c3b509SAl Viro return dir_emit(ctx, name, len, ino, type); 204161a28784SEric W. Biederman } 204261a28784SEric W. Biederman 2043640708a2SPavel Emelyanov /* 2044640708a2SPavel Emelyanov * dname_to_vma_addr - maps a dentry name into two unsigned longs 2045640708a2SPavel Emelyanov * which represent vma start and end addresses. 2046640708a2SPavel Emelyanov */ 2047640708a2SPavel Emelyanov static int dname_to_vma_addr(struct dentry *dentry, 2048640708a2SPavel Emelyanov unsigned long *start, unsigned long *end) 2049640708a2SPavel Emelyanov { 2050ac7f1061SAlexey Dobriyan const char *str = dentry->d_name.name; 2051ac7f1061SAlexey Dobriyan unsigned long long sval, eval; 2052ac7f1061SAlexey Dobriyan unsigned int len; 2053ac7f1061SAlexey Dobriyan 205435318db5SAlexey Dobriyan if (str[0] == '0' && str[1] != '-') 205535318db5SAlexey Dobriyan return -EINVAL; 2056ac7f1061SAlexey Dobriyan len = _parse_integer(str, 16, &sval); 2057ac7f1061SAlexey Dobriyan if (len & KSTRTOX_OVERFLOW) 2058640708a2SPavel Emelyanov return -EINVAL; 2059ac7f1061SAlexey Dobriyan if (sval != (unsigned long)sval) 2060ac7f1061SAlexey Dobriyan return -EINVAL; 2061ac7f1061SAlexey Dobriyan str += len; 2062ac7f1061SAlexey Dobriyan 2063ac7f1061SAlexey Dobriyan if (*str != '-') 2064ac7f1061SAlexey Dobriyan return -EINVAL; 2065ac7f1061SAlexey Dobriyan str++; 2066ac7f1061SAlexey Dobriyan 206735318db5SAlexey Dobriyan if (str[0] == '0' && str[1]) 206835318db5SAlexey Dobriyan return -EINVAL; 2069ac7f1061SAlexey Dobriyan len = _parse_integer(str, 16, &eval); 2070ac7f1061SAlexey Dobriyan if (len & KSTRTOX_OVERFLOW) 2071ac7f1061SAlexey Dobriyan return -EINVAL; 2072ac7f1061SAlexey Dobriyan if (eval != (unsigned long)eval) 2073ac7f1061SAlexey Dobriyan return -EINVAL; 2074ac7f1061SAlexey Dobriyan str += len; 2075ac7f1061SAlexey Dobriyan 2076ac7f1061SAlexey Dobriyan if (*str != '\0') 2077ac7f1061SAlexey Dobriyan return -EINVAL; 2078ac7f1061SAlexey Dobriyan 2079ac7f1061SAlexey Dobriyan *start = sval; 2080ac7f1061SAlexey Dobriyan *end = eval; 2081640708a2SPavel Emelyanov 2082640708a2SPavel Emelyanov return 0; 2083640708a2SPavel Emelyanov } 2084640708a2SPavel Emelyanov 20850b728e19SAl Viro static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags) 2086640708a2SPavel Emelyanov { 2087640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 2088640708a2SPavel Emelyanov bool exact_vma_exists = false; 2089640708a2SPavel Emelyanov struct mm_struct *mm = NULL; 2090640708a2SPavel Emelyanov struct task_struct *task; 2091640708a2SPavel Emelyanov struct inode *inode; 2092640708a2SPavel Emelyanov int status = 0; 2093640708a2SPavel Emelyanov 20940b728e19SAl Viro if (flags & LOOKUP_RCU) 2095640708a2SPavel Emelyanov return -ECHILD; 2096640708a2SPavel Emelyanov 20972b0143b5SDavid Howells inode = d_inode(dentry); 2098640708a2SPavel Emelyanov task = get_proc_task(inode); 2099640708a2SPavel Emelyanov if (!task) 2100640708a2SPavel Emelyanov goto out_notask; 2101640708a2SPavel Emelyanov 2102caaee623SJann Horn mm = mm_access(task, PTRACE_MODE_READ_FSCREDS); 21032344bec7SCong Wang if (IS_ERR_OR_NULL(mm)) 2104640708a2SPavel Emelyanov goto out; 2105640708a2SPavel Emelyanov 2106640708a2SPavel Emelyanov if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) { 2107cd9e2bb8SKonstantin Khlebnikov status = down_read_killable(&mm->mmap_sem); 2108cd9e2bb8SKonstantin Khlebnikov if (!status) { 2109cd9e2bb8SKonstantin Khlebnikov exact_vma_exists = !!find_exact_vma(mm, vm_start, 2110cd9e2bb8SKonstantin Khlebnikov vm_end); 2111640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2112640708a2SPavel Emelyanov } 2113cd9e2bb8SKonstantin Khlebnikov } 2114640708a2SPavel Emelyanov 2115640708a2SPavel Emelyanov mmput(mm); 2116640708a2SPavel Emelyanov 2117640708a2SPavel Emelyanov if (exact_vma_exists) { 211868eb94f1SEric W. Biederman task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid); 211968eb94f1SEric W. Biederman 2120640708a2SPavel Emelyanov security_task_to_inode(task, inode); 2121640708a2SPavel Emelyanov status = 1; 2122640708a2SPavel Emelyanov } 2123640708a2SPavel Emelyanov 2124640708a2SPavel Emelyanov out: 2125640708a2SPavel Emelyanov put_task_struct(task); 2126640708a2SPavel Emelyanov 2127640708a2SPavel Emelyanov out_notask: 2128640708a2SPavel Emelyanov return status; 2129640708a2SPavel Emelyanov } 2130640708a2SPavel Emelyanov 2131640708a2SPavel Emelyanov static const struct dentry_operations tid_map_files_dentry_operations = { 2132640708a2SPavel Emelyanov .d_revalidate = map_files_d_revalidate, 2133640708a2SPavel Emelyanov .d_delete = pid_delete_dentry, 2134640708a2SPavel Emelyanov }; 2135640708a2SPavel Emelyanov 21366b255391SAl Viro static int map_files_get_link(struct dentry *dentry, struct path *path) 2137640708a2SPavel Emelyanov { 2138640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 2139640708a2SPavel Emelyanov struct vm_area_struct *vma; 2140640708a2SPavel Emelyanov struct task_struct *task; 2141640708a2SPavel Emelyanov struct mm_struct *mm; 2142640708a2SPavel Emelyanov int rc; 2143640708a2SPavel Emelyanov 2144640708a2SPavel Emelyanov rc = -ENOENT; 21452b0143b5SDavid Howells task = get_proc_task(d_inode(dentry)); 2146640708a2SPavel Emelyanov if (!task) 2147640708a2SPavel Emelyanov goto out; 2148640708a2SPavel Emelyanov 2149640708a2SPavel Emelyanov mm = get_task_mm(task); 2150640708a2SPavel Emelyanov put_task_struct(task); 2151640708a2SPavel Emelyanov if (!mm) 2152640708a2SPavel Emelyanov goto out; 2153640708a2SPavel Emelyanov 2154640708a2SPavel Emelyanov rc = dname_to_vma_addr(dentry, &vm_start, &vm_end); 2155640708a2SPavel Emelyanov if (rc) 2156640708a2SPavel Emelyanov goto out_mmput; 2157640708a2SPavel Emelyanov 2158cd9e2bb8SKonstantin Khlebnikov rc = down_read_killable(&mm->mmap_sem); 2159cd9e2bb8SKonstantin Khlebnikov if (rc) 2160cd9e2bb8SKonstantin Khlebnikov goto out_mmput; 2161cd9e2bb8SKonstantin Khlebnikov 216270335abbSArtem Fetishev rc = -ENOENT; 2163640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 2164640708a2SPavel Emelyanov if (vma && vma->vm_file) { 2165640708a2SPavel Emelyanov *path = vma->vm_file->f_path; 2166640708a2SPavel Emelyanov path_get(path); 2167640708a2SPavel Emelyanov rc = 0; 2168640708a2SPavel Emelyanov } 2169640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2170640708a2SPavel Emelyanov 2171640708a2SPavel Emelyanov out_mmput: 2172640708a2SPavel Emelyanov mmput(mm); 2173640708a2SPavel Emelyanov out: 2174640708a2SPavel Emelyanov return rc; 2175640708a2SPavel Emelyanov } 2176640708a2SPavel Emelyanov 2177640708a2SPavel Emelyanov struct map_files_info { 217820d28cdeSAlexey Dobriyan unsigned long start; 217920d28cdeSAlexey Dobriyan unsigned long end; 21807b540d06SAl Viro fmode_t mode; 2181640708a2SPavel Emelyanov }; 2182640708a2SPavel Emelyanov 2183bdb4d100SCalvin Owens /* 2184bdb4d100SCalvin Owens * Only allow CAP_SYS_ADMIN to follow the links, due to concerns about how the 2185bdb4d100SCalvin Owens * symlinks may be used to bypass permissions on ancestor directories in the 2186bdb4d100SCalvin Owens * path to the file in question. 2187bdb4d100SCalvin Owens */ 2188bdb4d100SCalvin Owens static const char * 21896b255391SAl Viro proc_map_files_get_link(struct dentry *dentry, 2190fceef393SAl Viro struct inode *inode, 2191fceef393SAl Viro struct delayed_call *done) 2192bdb4d100SCalvin Owens { 2193bdb4d100SCalvin Owens if (!capable(CAP_SYS_ADMIN)) 2194bdb4d100SCalvin Owens return ERR_PTR(-EPERM); 2195bdb4d100SCalvin Owens 2196fceef393SAl Viro return proc_pid_get_link(dentry, inode, done); 2197bdb4d100SCalvin Owens } 2198bdb4d100SCalvin Owens 2199bdb4d100SCalvin Owens /* 22006b255391SAl Viro * Identical to proc_pid_link_inode_operations except for get_link() 2201bdb4d100SCalvin Owens */ 2202bdb4d100SCalvin Owens static const struct inode_operations proc_map_files_link_inode_operations = { 2203bdb4d100SCalvin Owens .readlink = proc_pid_readlink, 22046b255391SAl Viro .get_link = proc_map_files_get_link, 2205bdb4d100SCalvin Owens .setattr = proc_setattr, 2206bdb4d100SCalvin Owens }; 2207bdb4d100SCalvin Owens 22080168b9e3SAl Viro static struct dentry * 22090168b9e3SAl Viro proc_map_files_instantiate(struct dentry *dentry, 2210640708a2SPavel Emelyanov struct task_struct *task, const void *ptr) 2211640708a2SPavel Emelyanov { 22127b540d06SAl Viro fmode_t mode = (fmode_t)(unsigned long)ptr; 2213640708a2SPavel Emelyanov struct proc_inode *ei; 2214640708a2SPavel Emelyanov struct inode *inode; 2215640708a2SPavel Emelyanov 22160168b9e3SAl Viro inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK | 2217db978da8SAndreas Gruenbacher ((mode & FMODE_READ ) ? S_IRUSR : 0) | 2218db978da8SAndreas Gruenbacher ((mode & FMODE_WRITE) ? S_IWUSR : 0)); 2219640708a2SPavel Emelyanov if (!inode) 22200168b9e3SAl Viro return ERR_PTR(-ENOENT); 2221640708a2SPavel Emelyanov 2222640708a2SPavel Emelyanov ei = PROC_I(inode); 22236b255391SAl Viro ei->op.proc_get_link = map_files_get_link; 2224640708a2SPavel Emelyanov 2225bdb4d100SCalvin Owens inode->i_op = &proc_map_files_link_inode_operations; 2226640708a2SPavel Emelyanov inode->i_size = 64; 2227640708a2SPavel Emelyanov 2228640708a2SPavel Emelyanov d_set_d_op(dentry, &tid_map_files_dentry_operations); 22290168b9e3SAl Viro return d_splice_alias(inode, dentry); 2230640708a2SPavel Emelyanov } 2231640708a2SPavel Emelyanov 2232640708a2SPavel Emelyanov static struct dentry *proc_map_files_lookup(struct inode *dir, 223300cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 2234640708a2SPavel Emelyanov { 2235640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 2236640708a2SPavel Emelyanov struct vm_area_struct *vma; 2237640708a2SPavel Emelyanov struct task_struct *task; 22380168b9e3SAl Viro struct dentry *result; 2239640708a2SPavel Emelyanov struct mm_struct *mm; 2240640708a2SPavel Emelyanov 22410168b9e3SAl Viro result = ERR_PTR(-ENOENT); 2242640708a2SPavel Emelyanov task = get_proc_task(dir); 2243640708a2SPavel Emelyanov if (!task) 2244640708a2SPavel Emelyanov goto out; 2245640708a2SPavel Emelyanov 22460168b9e3SAl Viro result = ERR_PTR(-EACCES); 2247caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) 2248640708a2SPavel Emelyanov goto out_put_task; 2249640708a2SPavel Emelyanov 22500168b9e3SAl Viro result = ERR_PTR(-ENOENT); 2251640708a2SPavel Emelyanov if (dname_to_vma_addr(dentry, &vm_start, &vm_end)) 2252eb94cd96SCyrill Gorcunov goto out_put_task; 2253640708a2SPavel Emelyanov 2254640708a2SPavel Emelyanov mm = get_task_mm(task); 2255640708a2SPavel Emelyanov if (!mm) 2256eb94cd96SCyrill Gorcunov goto out_put_task; 2257640708a2SPavel Emelyanov 2258cd9e2bb8SKonstantin Khlebnikov result = ERR_PTR(-EINTR); 2259cd9e2bb8SKonstantin Khlebnikov if (down_read_killable(&mm->mmap_sem)) 2260cd9e2bb8SKonstantin Khlebnikov goto out_put_mm; 2261cd9e2bb8SKonstantin Khlebnikov 2262cd9e2bb8SKonstantin Khlebnikov result = ERR_PTR(-ENOENT); 2263640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 2264640708a2SPavel Emelyanov if (!vma) 2265640708a2SPavel Emelyanov goto out_no_vma; 2266640708a2SPavel Emelyanov 226705f56484SStanislav Kinsbursky if (vma->vm_file) 22680168b9e3SAl Viro result = proc_map_files_instantiate(dentry, task, 22697b540d06SAl Viro (void *)(unsigned long)vma->vm_file->f_mode); 2270640708a2SPavel Emelyanov 2271640708a2SPavel Emelyanov out_no_vma: 2272640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2273cd9e2bb8SKonstantin Khlebnikov out_put_mm: 2274640708a2SPavel Emelyanov mmput(mm); 2275640708a2SPavel Emelyanov out_put_task: 2276640708a2SPavel Emelyanov put_task_struct(task); 2277640708a2SPavel Emelyanov out: 22780168b9e3SAl Viro return result; 2279640708a2SPavel Emelyanov } 2280640708a2SPavel Emelyanov 2281640708a2SPavel Emelyanov static const struct inode_operations proc_map_files_inode_operations = { 2282640708a2SPavel Emelyanov .lookup = proc_map_files_lookup, 2283640708a2SPavel Emelyanov .permission = proc_fd_permission, 2284640708a2SPavel Emelyanov .setattr = proc_setattr, 2285640708a2SPavel Emelyanov }; 2286640708a2SPavel Emelyanov 2287640708a2SPavel Emelyanov static int 2288f0c3b509SAl Viro proc_map_files_readdir(struct file *file, struct dir_context *ctx) 2289640708a2SPavel Emelyanov { 2290640708a2SPavel Emelyanov struct vm_area_struct *vma; 2291640708a2SPavel Emelyanov struct task_struct *task; 2292640708a2SPavel Emelyanov struct mm_struct *mm; 2293f0c3b509SAl Viro unsigned long nr_files, pos, i; 229494f8f3b0SKent Overstreet GENRADIX(struct map_files_info) fa; 2295f0c3b509SAl Viro struct map_files_info *p; 2296640708a2SPavel Emelyanov int ret; 2297640708a2SPavel Emelyanov 229894f8f3b0SKent Overstreet genradix_init(&fa); 229994f8f3b0SKent Overstreet 2300640708a2SPavel Emelyanov ret = -ENOENT; 2301f0c3b509SAl Viro task = get_proc_task(file_inode(file)); 2302640708a2SPavel Emelyanov if (!task) 2303640708a2SPavel Emelyanov goto out; 2304640708a2SPavel Emelyanov 2305640708a2SPavel Emelyanov ret = -EACCES; 2306caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) 2307640708a2SPavel Emelyanov goto out_put_task; 2308640708a2SPavel Emelyanov 2309640708a2SPavel Emelyanov ret = 0; 2310f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 2311eb94cd96SCyrill Gorcunov goto out_put_task; 2312640708a2SPavel Emelyanov 2313640708a2SPavel Emelyanov mm = get_task_mm(task); 2314640708a2SPavel Emelyanov if (!mm) 2315eb94cd96SCyrill Gorcunov goto out_put_task; 2316cd9e2bb8SKonstantin Khlebnikov 2317cd9e2bb8SKonstantin Khlebnikov ret = down_read_killable(&mm->mmap_sem); 2318cd9e2bb8SKonstantin Khlebnikov if (ret) { 2319cd9e2bb8SKonstantin Khlebnikov mmput(mm); 2320cd9e2bb8SKonstantin Khlebnikov goto out_put_task; 2321cd9e2bb8SKonstantin Khlebnikov } 2322640708a2SPavel Emelyanov 2323640708a2SPavel Emelyanov nr_files = 0; 2324640708a2SPavel Emelyanov 2325640708a2SPavel Emelyanov /* 2326640708a2SPavel Emelyanov * We need two passes here: 2327640708a2SPavel Emelyanov * 2328640708a2SPavel Emelyanov * 1) Collect vmas of mapped files with mmap_sem taken 2329640708a2SPavel Emelyanov * 2) Release mmap_sem and instantiate entries 2330640708a2SPavel Emelyanov * 2331640708a2SPavel Emelyanov * otherwise we get lockdep complained, since filldir() 2332640708a2SPavel Emelyanov * routine might require mmap_sem taken in might_fault(). 2333640708a2SPavel Emelyanov */ 2334640708a2SPavel Emelyanov 2335640708a2SPavel Emelyanov for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) { 2336640708a2SPavel Emelyanov if (!vma->vm_file) 2337640708a2SPavel Emelyanov continue; 2338f0c3b509SAl Viro if (++pos <= ctx->pos) 2339640708a2SPavel Emelyanov continue; 2340640708a2SPavel Emelyanov 234194f8f3b0SKent Overstreet p = genradix_ptr_alloc(&fa, nr_files++, GFP_KERNEL); 234294f8f3b0SKent Overstreet if (!p) { 234394f8f3b0SKent Overstreet ret = -ENOMEM; 234494f8f3b0SKent Overstreet up_read(&mm->mmap_sem); 234594f8f3b0SKent Overstreet mmput(mm); 234694f8f3b0SKent Overstreet goto out_put_task; 2347640708a2SPavel Emelyanov } 234894f8f3b0SKent Overstreet 234994f8f3b0SKent Overstreet p->start = vma->vm_start; 235094f8f3b0SKent Overstreet p->end = vma->vm_end; 235194f8f3b0SKent Overstreet p->mode = vma->vm_file->f_mode; 2352640708a2SPavel Emelyanov } 2353640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2354fe079a5eSAlexey Dobriyan mmput(mm); 2355640708a2SPavel Emelyanov 2356640708a2SPavel Emelyanov for (i = 0; i < nr_files; i++) { 235720d28cdeSAlexey Dobriyan char buf[4 * sizeof(long) + 2]; /* max: %lx-%lx\0 */ 235820d28cdeSAlexey Dobriyan unsigned int len; 235920d28cdeSAlexey Dobriyan 236094f8f3b0SKent Overstreet p = genradix_ptr(&fa, i); 236120d28cdeSAlexey Dobriyan len = snprintf(buf, sizeof(buf), "%lx-%lx", p->start, p->end); 2362f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, 236320d28cdeSAlexey Dobriyan buf, len, 2364640708a2SPavel Emelyanov proc_map_files_instantiate, 23657b540d06SAl Viro task, 2366f0c3b509SAl Viro (void *)(unsigned long)p->mode)) 2367640708a2SPavel Emelyanov break; 2368f0c3b509SAl Viro ctx->pos++; 2369640708a2SPavel Emelyanov } 2370640708a2SPavel Emelyanov 2371640708a2SPavel Emelyanov out_put_task: 2372640708a2SPavel Emelyanov put_task_struct(task); 2373640708a2SPavel Emelyanov out: 237494f8f3b0SKent Overstreet genradix_free(&fa); 2375640708a2SPavel Emelyanov return ret; 2376640708a2SPavel Emelyanov } 2377640708a2SPavel Emelyanov 2378640708a2SPavel Emelyanov static const struct file_operations proc_map_files_operations = { 2379640708a2SPavel Emelyanov .read = generic_read_dir, 2380f50752eaSAl Viro .iterate_shared = proc_map_files_readdir, 2381f50752eaSAl Viro .llseek = generic_file_llseek, 2382640708a2SPavel Emelyanov }; 2383640708a2SPavel Emelyanov 2384b18b6a9cSNicolas Pitre #if defined(CONFIG_CHECKPOINT_RESTORE) && defined(CONFIG_POSIX_TIMERS) 238548f6a7a5SPavel Emelyanov struct timers_private { 238648f6a7a5SPavel Emelyanov struct pid *pid; 238748f6a7a5SPavel Emelyanov struct task_struct *task; 238848f6a7a5SPavel Emelyanov struct sighand_struct *sighand; 238957b8015eSPavel Emelyanov struct pid_namespace *ns; 239048f6a7a5SPavel Emelyanov unsigned long flags; 239148f6a7a5SPavel Emelyanov }; 239248f6a7a5SPavel Emelyanov 239348f6a7a5SPavel Emelyanov static void *timers_start(struct seq_file *m, loff_t *pos) 239448f6a7a5SPavel Emelyanov { 239548f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 239648f6a7a5SPavel Emelyanov 239748f6a7a5SPavel Emelyanov tp->task = get_pid_task(tp->pid, PIDTYPE_PID); 239848f6a7a5SPavel Emelyanov if (!tp->task) 239948f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 240048f6a7a5SPavel Emelyanov 240148f6a7a5SPavel Emelyanov tp->sighand = lock_task_sighand(tp->task, &tp->flags); 240248f6a7a5SPavel Emelyanov if (!tp->sighand) 240348f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 240448f6a7a5SPavel Emelyanov 240548f6a7a5SPavel Emelyanov return seq_list_start(&tp->task->signal->posix_timers, *pos); 240648f6a7a5SPavel Emelyanov } 240748f6a7a5SPavel Emelyanov 240848f6a7a5SPavel Emelyanov static void *timers_next(struct seq_file *m, void *v, loff_t *pos) 240948f6a7a5SPavel Emelyanov { 241048f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 241148f6a7a5SPavel Emelyanov return seq_list_next(v, &tp->task->signal->posix_timers, pos); 241248f6a7a5SPavel Emelyanov } 241348f6a7a5SPavel Emelyanov 241448f6a7a5SPavel Emelyanov static void timers_stop(struct seq_file *m, void *v) 241548f6a7a5SPavel Emelyanov { 241648f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 241748f6a7a5SPavel Emelyanov 241848f6a7a5SPavel Emelyanov if (tp->sighand) { 241948f6a7a5SPavel Emelyanov unlock_task_sighand(tp->task, &tp->flags); 242048f6a7a5SPavel Emelyanov tp->sighand = NULL; 242148f6a7a5SPavel Emelyanov } 242248f6a7a5SPavel Emelyanov 242348f6a7a5SPavel Emelyanov if (tp->task) { 242448f6a7a5SPavel Emelyanov put_task_struct(tp->task); 242548f6a7a5SPavel Emelyanov tp->task = NULL; 242648f6a7a5SPavel Emelyanov } 242748f6a7a5SPavel Emelyanov } 242848f6a7a5SPavel Emelyanov 242948f6a7a5SPavel Emelyanov static int show_timer(struct seq_file *m, void *v) 243048f6a7a5SPavel Emelyanov { 243148f6a7a5SPavel Emelyanov struct k_itimer *timer; 243257b8015eSPavel Emelyanov struct timers_private *tp = m->private; 243357b8015eSPavel Emelyanov int notify; 2434cedbccabSAlexey Dobriyan static const char * const nstr[] = { 243557b8015eSPavel Emelyanov [SIGEV_SIGNAL] = "signal", 243657b8015eSPavel Emelyanov [SIGEV_NONE] = "none", 243757b8015eSPavel Emelyanov [SIGEV_THREAD] = "thread", 243857b8015eSPavel Emelyanov }; 243948f6a7a5SPavel Emelyanov 244048f6a7a5SPavel Emelyanov timer = list_entry((struct list_head *)v, struct k_itimer, list); 244157b8015eSPavel Emelyanov notify = timer->it_sigev_notify; 244257b8015eSPavel Emelyanov 244348f6a7a5SPavel Emelyanov seq_printf(m, "ID: %d\n", timer->it_id); 2444ba3edf1fSLinus Torvalds seq_printf(m, "signal: %d/%px\n", 244525ce3191SJoe Perches timer->sigq->info.si_signo, 244657b8015eSPavel Emelyanov timer->sigq->info.si_value.sival_ptr); 244757b8015eSPavel Emelyanov seq_printf(m, "notify: %s/%s.%d\n", 244857b8015eSPavel Emelyanov nstr[notify & ~SIGEV_THREAD_ID], 244957b8015eSPavel Emelyanov (notify & SIGEV_THREAD_ID) ? "tid" : "pid", 245057b8015eSPavel Emelyanov pid_nr_ns(timer->it_pid, tp->ns)); 245115ef0298SPavel Tikhomirov seq_printf(m, "ClockID: %d\n", timer->it_clock); 245248f6a7a5SPavel Emelyanov 245348f6a7a5SPavel Emelyanov return 0; 245448f6a7a5SPavel Emelyanov } 245548f6a7a5SPavel Emelyanov 245648f6a7a5SPavel Emelyanov static const struct seq_operations proc_timers_seq_ops = { 245748f6a7a5SPavel Emelyanov .start = timers_start, 245848f6a7a5SPavel Emelyanov .next = timers_next, 245948f6a7a5SPavel Emelyanov .stop = timers_stop, 246048f6a7a5SPavel Emelyanov .show = show_timer, 246148f6a7a5SPavel Emelyanov }; 246248f6a7a5SPavel Emelyanov 246348f6a7a5SPavel Emelyanov static int proc_timers_open(struct inode *inode, struct file *file) 246448f6a7a5SPavel Emelyanov { 246548f6a7a5SPavel Emelyanov struct timers_private *tp; 246648f6a7a5SPavel Emelyanov 246748f6a7a5SPavel Emelyanov tp = __seq_open_private(file, &proc_timers_seq_ops, 246848f6a7a5SPavel Emelyanov sizeof(struct timers_private)); 246948f6a7a5SPavel Emelyanov if (!tp) 247048f6a7a5SPavel Emelyanov return -ENOMEM; 247148f6a7a5SPavel Emelyanov 247248f6a7a5SPavel Emelyanov tp->pid = proc_pid(inode); 247376f668beSChristoph Hellwig tp->ns = proc_pid_ns(inode); 247448f6a7a5SPavel Emelyanov return 0; 247548f6a7a5SPavel Emelyanov } 247648f6a7a5SPavel Emelyanov 247748f6a7a5SPavel Emelyanov static const struct file_operations proc_timers_operations = { 247848f6a7a5SPavel Emelyanov .open = proc_timers_open, 247948f6a7a5SPavel Emelyanov .read = seq_read, 248048f6a7a5SPavel Emelyanov .llseek = seq_lseek, 248148f6a7a5SPavel Emelyanov .release = seq_release_private, 248248f6a7a5SPavel Emelyanov }; 2483b5946beaSEric Engestrom #endif 2484640708a2SPavel Emelyanov 24855de23d43SJohn Stultz static ssize_t timerslack_ns_write(struct file *file, const char __user *buf, 24865de23d43SJohn Stultz size_t count, loff_t *offset) 24875de23d43SJohn Stultz { 24885de23d43SJohn Stultz struct inode *inode = file_inode(file); 24895de23d43SJohn Stultz struct task_struct *p; 24905de23d43SJohn Stultz u64 slack_ns; 24915de23d43SJohn Stultz int err; 24925de23d43SJohn Stultz 24935de23d43SJohn Stultz err = kstrtoull_from_user(buf, count, 10, &slack_ns); 24945de23d43SJohn Stultz if (err < 0) 24955de23d43SJohn Stultz return err; 24965de23d43SJohn Stultz 24975de23d43SJohn Stultz p = get_proc_task(inode); 24985de23d43SJohn Stultz if (!p) 24995de23d43SJohn Stultz return -ESRCH; 25005de23d43SJohn Stultz 25014b2bd5feSJohn Stultz if (p != current) { 25028da0b4f6SBenjamin Gordon rcu_read_lock(); 25038da0b4f6SBenjamin Gordon if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) { 25048da0b4f6SBenjamin Gordon rcu_read_unlock(); 25057abbaf94SJohn Stultz count = -EPERM; 25067abbaf94SJohn Stultz goto out; 25077abbaf94SJohn Stultz } 25088da0b4f6SBenjamin Gordon rcu_read_unlock(); 25097abbaf94SJohn Stultz 2510904763e1SJohn Stultz err = security_task_setscheduler(p); 2511904763e1SJohn Stultz if (err) { 2512904763e1SJohn Stultz count = err; 2513904763e1SJohn Stultz goto out; 2514904763e1SJohn Stultz } 25154b2bd5feSJohn Stultz } 2516904763e1SJohn Stultz 25175de23d43SJohn Stultz task_lock(p); 25185de23d43SJohn Stultz if (slack_ns == 0) 25195de23d43SJohn Stultz p->timer_slack_ns = p->default_timer_slack_ns; 25205de23d43SJohn Stultz else 25215de23d43SJohn Stultz p->timer_slack_ns = slack_ns; 25225de23d43SJohn Stultz task_unlock(p); 25235de23d43SJohn Stultz 25247abbaf94SJohn Stultz out: 25255de23d43SJohn Stultz put_task_struct(p); 25265de23d43SJohn Stultz 25275de23d43SJohn Stultz return count; 25285de23d43SJohn Stultz } 25295de23d43SJohn Stultz 25305de23d43SJohn Stultz static int timerslack_ns_show(struct seq_file *m, void *v) 25315de23d43SJohn Stultz { 25325de23d43SJohn Stultz struct inode *inode = m->private; 25335de23d43SJohn Stultz struct task_struct *p; 25345de23d43SJohn Stultz int err = 0; 25355de23d43SJohn Stultz 25365de23d43SJohn Stultz p = get_proc_task(inode); 25375de23d43SJohn Stultz if (!p) 25385de23d43SJohn Stultz return -ESRCH; 25395de23d43SJohn Stultz 25404b2bd5feSJohn Stultz if (p != current) { 25418da0b4f6SBenjamin Gordon rcu_read_lock(); 25428da0b4f6SBenjamin Gordon if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) { 25438da0b4f6SBenjamin Gordon rcu_read_unlock(); 25447abbaf94SJohn Stultz err = -EPERM; 25457abbaf94SJohn Stultz goto out; 25467abbaf94SJohn Stultz } 25478da0b4f6SBenjamin Gordon rcu_read_unlock(); 25488da0b4f6SBenjamin Gordon 2549904763e1SJohn Stultz err = security_task_getscheduler(p); 2550904763e1SJohn Stultz if (err) 2551904763e1SJohn Stultz goto out; 25524b2bd5feSJohn Stultz } 2553904763e1SJohn Stultz 25545de23d43SJohn Stultz task_lock(p); 25555de23d43SJohn Stultz seq_printf(m, "%llu\n", p->timer_slack_ns); 25565de23d43SJohn Stultz task_unlock(p); 25575de23d43SJohn Stultz 25587abbaf94SJohn Stultz out: 25595de23d43SJohn Stultz put_task_struct(p); 25605de23d43SJohn Stultz 25615de23d43SJohn Stultz return err; 25625de23d43SJohn Stultz } 25635de23d43SJohn Stultz 25645de23d43SJohn Stultz static int timerslack_ns_open(struct inode *inode, struct file *filp) 25655de23d43SJohn Stultz { 25665de23d43SJohn Stultz return single_open(filp, timerslack_ns_show, inode); 25675de23d43SJohn Stultz } 25685de23d43SJohn Stultz 25695de23d43SJohn Stultz static const struct file_operations proc_pid_set_timerslack_ns_operations = { 25705de23d43SJohn Stultz .open = timerslack_ns_open, 25715de23d43SJohn Stultz .read = seq_read, 25725de23d43SJohn Stultz .write = timerslack_ns_write, 25735de23d43SJohn Stultz .llseek = seq_lseek, 25745de23d43SJohn Stultz .release = single_release, 25755de23d43SJohn Stultz }; 25765de23d43SJohn Stultz 25770168b9e3SAl Viro static struct dentry *proc_pident_instantiate(struct dentry *dentry, 25780168b9e3SAl Viro struct task_struct *task, const void *ptr) 2579444ceed8SEric W. Biederman { 2580c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2581444ceed8SEric W. Biederman struct inode *inode; 2582444ceed8SEric W. Biederman struct proc_inode *ei; 2583444ceed8SEric W. Biederman 25840168b9e3SAl Viro inode = proc_pid_make_inode(dentry->d_sb, task, p->mode); 2585444ceed8SEric W. Biederman if (!inode) 25860168b9e3SAl Viro return ERR_PTR(-ENOENT); 2587444ceed8SEric W. Biederman 2588444ceed8SEric W. Biederman ei = PROC_I(inode); 2589444ceed8SEric W. Biederman if (S_ISDIR(inode->i_mode)) 2590bfe86848SMiklos Szeredi set_nlink(inode, 2); /* Use getattr to fix if necessary */ 2591444ceed8SEric W. Biederman if (p->iop) 2592444ceed8SEric W. Biederman inode->i_op = p->iop; 2593444ceed8SEric W. Biederman if (p->fop) 2594444ceed8SEric W. Biederman inode->i_fop = p->fop; 2595444ceed8SEric W. Biederman ei->op = p->op; 25961bbc5513SAl Viro pid_update_inode(task, inode); 2597fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 25980168b9e3SAl Viro return d_splice_alias(inode, dentry); 2599444ceed8SEric W. Biederman } 2600444ceed8SEric W. Biederman 26011da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 26021da177e4SLinus Torvalds struct dentry *dentry, 2603d5a572a4SAlexey Dobriyan const struct pid_entry *p, 2604d5a572a4SAlexey Dobriyan const struct pid_entry *end) 26051da177e4SLinus Torvalds { 260699f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 26070168b9e3SAl Viro struct dentry *res = ERR_PTR(-ENOENT); 26081da177e4SLinus Torvalds 260999f89551SEric W. Biederman if (!task) 261099f89551SEric W. Biederman goto out_no_task; 26111da177e4SLinus Torvalds 261220cdc894SEric W. Biederman /* 261320cdc894SEric W. Biederman * Yes, it does not scale. And it should not. Don't add 261420cdc894SEric W. Biederman * new entries into /proc/<tgid>/ without very good reasons. 261520cdc894SEric W. Biederman */ 2616d5a572a4SAlexey Dobriyan for (; p < end; p++) { 26171da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 26181da177e4SLinus Torvalds continue; 261926b95137SAlexey Dobriyan if (!memcmp(dentry->d_name.name, p->name, p->len)) { 262026b95137SAlexey Dobriyan res = proc_pident_instantiate(dentry, task, p); 26211da177e4SLinus Torvalds break; 26221da177e4SLinus Torvalds } 262326b95137SAlexey Dobriyan } 262499f89551SEric W. Biederman put_task_struct(task); 262599f89551SEric W. Biederman out_no_task: 26260168b9e3SAl Viro return res; 26271da177e4SLinus Torvalds } 26281da177e4SLinus Torvalds 2629f0c3b509SAl Viro static int proc_pident_readdir(struct file *file, struct dir_context *ctx, 2630c5141e6dSEric Dumazet const struct pid_entry *ents, unsigned int nents) 263128a6d671SEric W. Biederman { 2632f0c3b509SAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 2633f0c3b509SAl Viro const struct pid_entry *p; 263428a6d671SEric W. Biederman 263528a6d671SEric W. Biederman if (!task) 2636f0c3b509SAl Viro return -ENOENT; 263728a6d671SEric W. Biederman 2638f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 263928a6d671SEric W. Biederman goto out; 26401da177e4SLinus Torvalds 2641f0c3b509SAl Viro if (ctx->pos >= nents + 2) 2642f0c3b509SAl Viro goto out; 2643f0c3b509SAl Viro 2644bac5f5d5SAlexey Dobriyan for (p = ents + (ctx->pos - 2); p < ents + nents; p++) { 2645f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, p->name, p->len, 2646f0c3b509SAl Viro proc_pident_instantiate, task, p)) 2647f0c3b509SAl Viro break; 2648f0c3b509SAl Viro ctx->pos++; 2649f0c3b509SAl Viro } 265028a6d671SEric W. Biederman out: 265161a28784SEric W. Biederman put_task_struct(task); 2652f0c3b509SAl Viro return 0; 26531da177e4SLinus Torvalds } 26541da177e4SLinus Torvalds 26551da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 265628a6d671SEric W. Biederman static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 265728a6d671SEric W. Biederman size_t count, loff_t *ppos) 265828a6d671SEric W. Biederman { 2659496ad9aaSAl Viro struct inode * inode = file_inode(file); 266004ff9708SAl Viro char *p = NULL; 266128a6d671SEric W. Biederman ssize_t length; 266228a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 266328a6d671SEric W. Biederman 266428a6d671SEric W. Biederman if (!task) 266504ff9708SAl Viro return -ESRCH; 266628a6d671SEric W. Biederman 26676d9c939dSCasey Schaufler length = security_getprocattr(task, PROC_I(inode)->op.lsm, 26682fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 266904ff9708SAl Viro &p); 267028a6d671SEric W. Biederman put_task_struct(task); 267104ff9708SAl Viro if (length > 0) 267204ff9708SAl Viro length = simple_read_from_buffer(buf, count, ppos, p, length); 267304ff9708SAl Viro kfree(p); 267428a6d671SEric W. Biederman return length; 267528a6d671SEric W. Biederman } 267628a6d671SEric W. Biederman 267728a6d671SEric W. Biederman static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 267828a6d671SEric W. Biederman size_t count, loff_t *ppos) 267928a6d671SEric W. Biederman { 2680496ad9aaSAl Viro struct inode * inode = file_inode(file); 268141089b6dSAlexey Dobriyan struct task_struct *task; 2682bb646cdbSAl Viro void *page; 268341089b6dSAlexey Dobriyan int rv; 268428a6d671SEric W. Biederman 268541089b6dSAlexey Dobriyan rcu_read_lock(); 268641089b6dSAlexey Dobriyan task = pid_task(proc_pid(inode), PIDTYPE_PID); 268741089b6dSAlexey Dobriyan if (!task) { 268841089b6dSAlexey Dobriyan rcu_read_unlock(); 268941089b6dSAlexey Dobriyan return -ESRCH; 269041089b6dSAlexey Dobriyan } 2691b21507e2SStephen Smalley /* A task may only write its own attributes. */ 269241089b6dSAlexey Dobriyan if (current != task) { 269341089b6dSAlexey Dobriyan rcu_read_unlock(); 269441089b6dSAlexey Dobriyan return -EACCES; 269541089b6dSAlexey Dobriyan } 269635a196beSPaul Moore /* Prevent changes to overridden credentials. */ 269735a196beSPaul Moore if (current_cred() != current_real_cred()) { 269835a196beSPaul Moore rcu_read_unlock(); 269935a196beSPaul Moore return -EBUSY; 270035a196beSPaul Moore } 270141089b6dSAlexey Dobriyan rcu_read_unlock(); 2702b21507e2SStephen Smalley 270328a6d671SEric W. Biederman if (count > PAGE_SIZE) 270428a6d671SEric W. Biederman count = PAGE_SIZE; 270528a6d671SEric W. Biederman 270628a6d671SEric W. Biederman /* No partial writes. */ 270728a6d671SEric W. Biederman if (*ppos != 0) 270841089b6dSAlexey Dobriyan return -EINVAL; 270928a6d671SEric W. Biederman 2710bb646cdbSAl Viro page = memdup_user(buf, count); 2711bb646cdbSAl Viro if (IS_ERR(page)) { 271241089b6dSAlexey Dobriyan rv = PTR_ERR(page); 271328a6d671SEric W. Biederman goto out; 2714bb646cdbSAl Viro } 271528a6d671SEric W. Biederman 2716107db7c7SDavid Howells /* Guard against adverse ptrace interaction */ 271741089b6dSAlexey Dobriyan rv = mutex_lock_interruptible(¤t->signal->cred_guard_mutex); 271841089b6dSAlexey Dobriyan if (rv < 0) 2719107db7c7SDavid Howells goto out_free; 2720107db7c7SDavid Howells 27216d9c939dSCasey Schaufler rv = security_setprocattr(PROC_I(inode)->op.lsm, 27226d9c939dSCasey Schaufler file->f_path.dentry->d_name.name, page, 27236d9c939dSCasey Schaufler count); 2724b21507e2SStephen Smalley mutex_unlock(¤t->signal->cred_guard_mutex); 272528a6d671SEric W. Biederman out_free: 2726bb646cdbSAl Viro kfree(page); 272728a6d671SEric W. Biederman out: 272841089b6dSAlexey Dobriyan return rv; 272928a6d671SEric W. Biederman } 273028a6d671SEric W. Biederman 273100977a59SArjan van de Ven static const struct file_operations proc_pid_attr_operations = { 273228a6d671SEric W. Biederman .read = proc_pid_attr_read, 273328a6d671SEric W. Biederman .write = proc_pid_attr_write, 273487df8424SArnd Bergmann .llseek = generic_file_llseek, 273528a6d671SEric W. Biederman }; 273628a6d671SEric W. Biederman 27376d9c939dSCasey Schaufler #define LSM_DIR_OPS(LSM) \ 27386d9c939dSCasey Schaufler static int proc_##LSM##_attr_dir_iterate(struct file *filp, \ 27396d9c939dSCasey Schaufler struct dir_context *ctx) \ 27406d9c939dSCasey Schaufler { \ 27416d9c939dSCasey Schaufler return proc_pident_readdir(filp, ctx, \ 27426d9c939dSCasey Schaufler LSM##_attr_dir_stuff, \ 27436d9c939dSCasey Schaufler ARRAY_SIZE(LSM##_attr_dir_stuff)); \ 27446d9c939dSCasey Schaufler } \ 27456d9c939dSCasey Schaufler \ 27466d9c939dSCasey Schaufler static const struct file_operations proc_##LSM##_attr_dir_ops = { \ 27476d9c939dSCasey Schaufler .read = generic_read_dir, \ 27486d9c939dSCasey Schaufler .iterate = proc_##LSM##_attr_dir_iterate, \ 27496d9c939dSCasey Schaufler .llseek = default_llseek, \ 27506d9c939dSCasey Schaufler }; \ 27516d9c939dSCasey Schaufler \ 27526d9c939dSCasey Schaufler static struct dentry *proc_##LSM##_attr_dir_lookup(struct inode *dir, \ 27536d9c939dSCasey Schaufler struct dentry *dentry, unsigned int flags) \ 27546d9c939dSCasey Schaufler { \ 27556d9c939dSCasey Schaufler return proc_pident_lookup(dir, dentry, \ 27566d9c939dSCasey Schaufler LSM##_attr_dir_stuff, \ 2757d5a572a4SAlexey Dobriyan LSM##_attr_dir_stuff + ARRAY_SIZE(LSM##_attr_dir_stuff)); \ 27586d9c939dSCasey Schaufler } \ 27596d9c939dSCasey Schaufler \ 27606d9c939dSCasey Schaufler static const struct inode_operations proc_##LSM##_attr_dir_inode_ops = { \ 27616d9c939dSCasey Schaufler .lookup = proc_##LSM##_attr_dir_lookup, \ 27626d9c939dSCasey Schaufler .getattr = pid_getattr, \ 27636d9c939dSCasey Schaufler .setattr = proc_setattr, \ 27646d9c939dSCasey Schaufler } 27656d9c939dSCasey Schaufler 27666d9c939dSCasey Schaufler #ifdef CONFIG_SECURITY_SMACK 27676d9c939dSCasey Schaufler static const struct pid_entry smack_attr_dir_stuff[] = { 27686d9c939dSCasey Schaufler ATTR("smack", "current", 0666), 27696d9c939dSCasey Schaufler }; 27706d9c939dSCasey Schaufler LSM_DIR_OPS(smack); 27716d9c939dSCasey Schaufler #endif 27726d9c939dSCasey Schaufler 2773c5141e6dSEric Dumazet static const struct pid_entry attr_dir_stuff[] = { 27746d9c939dSCasey Schaufler ATTR(NULL, "current", 0666), 27756d9c939dSCasey Schaufler ATTR(NULL, "prev", 0444), 27766d9c939dSCasey Schaufler ATTR(NULL, "exec", 0666), 27776d9c939dSCasey Schaufler ATTR(NULL, "fscreate", 0666), 27786d9c939dSCasey Schaufler ATTR(NULL, "keycreate", 0666), 27796d9c939dSCasey Schaufler ATTR(NULL, "sockcreate", 0666), 27806d9c939dSCasey Schaufler #ifdef CONFIG_SECURITY_SMACK 27816d9c939dSCasey Schaufler DIR("smack", 0555, 27826d9c939dSCasey Schaufler proc_smack_attr_dir_inode_ops, proc_smack_attr_dir_ops), 27836d9c939dSCasey Schaufler #endif 278428a6d671SEric W. Biederman }; 278528a6d671SEric W. Biederman 2786f0c3b509SAl Viro static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx) 27871da177e4SLinus Torvalds { 2788f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 278972d9dcfcSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 27901da177e4SLinus Torvalds } 27911da177e4SLinus Torvalds 279200977a59SArjan van de Ven static const struct file_operations proc_attr_dir_operations = { 27931da177e4SLinus Torvalds .read = generic_read_dir, 2794f50752eaSAl Viro .iterate_shared = proc_attr_dir_readdir, 2795f50752eaSAl Viro .llseek = generic_file_llseek, 27961da177e4SLinus Torvalds }; 27971da177e4SLinus Torvalds 279872d9dcfcSEric W. Biederman static struct dentry *proc_attr_dir_lookup(struct inode *dir, 279900cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 28001da177e4SLinus Torvalds { 28017bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 2802d5a572a4SAlexey Dobriyan attr_dir_stuff, 2803d5a572a4SAlexey Dobriyan attr_dir_stuff + ARRAY_SIZE(attr_dir_stuff)); 28041da177e4SLinus Torvalds } 28051da177e4SLinus Torvalds 2806c5ef1c42SArjan van de Ven static const struct inode_operations proc_attr_dir_inode_operations = { 280772d9dcfcSEric W. Biederman .lookup = proc_attr_dir_lookup, 280899f89551SEric W. Biederman .getattr = pid_getattr, 28096d76fa58SLinus Torvalds .setattr = proc_setattr, 28101da177e4SLinus Torvalds }; 28111da177e4SLinus Torvalds 28121da177e4SLinus Torvalds #endif 28131da177e4SLinus Torvalds 2814698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 28153cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, 28163cb4a0bbSKawai, Hidehiro size_t count, loff_t *ppos) 28173cb4a0bbSKawai, Hidehiro { 2818496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 28193cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 28203cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF]; 28213cb4a0bbSKawai, Hidehiro size_t len; 28223cb4a0bbSKawai, Hidehiro int ret; 28233cb4a0bbSKawai, Hidehiro 28243cb4a0bbSKawai, Hidehiro if (!task) 28253cb4a0bbSKawai, Hidehiro return -ESRCH; 28263cb4a0bbSKawai, Hidehiro 28273cb4a0bbSKawai, Hidehiro ret = 0; 28283cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 28293cb4a0bbSKawai, Hidehiro if (mm) { 28303cb4a0bbSKawai, Hidehiro len = snprintf(buffer, sizeof(buffer), "%08lx\n", 28313cb4a0bbSKawai, Hidehiro ((mm->flags & MMF_DUMP_FILTER_MASK) >> 28323cb4a0bbSKawai, Hidehiro MMF_DUMP_FILTER_SHIFT)); 28333cb4a0bbSKawai, Hidehiro mmput(mm); 28343cb4a0bbSKawai, Hidehiro ret = simple_read_from_buffer(buf, count, ppos, buffer, len); 28353cb4a0bbSKawai, Hidehiro } 28363cb4a0bbSKawai, Hidehiro 28373cb4a0bbSKawai, Hidehiro put_task_struct(task); 28383cb4a0bbSKawai, Hidehiro 28393cb4a0bbSKawai, Hidehiro return ret; 28403cb4a0bbSKawai, Hidehiro } 28413cb4a0bbSKawai, Hidehiro 28423cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_write(struct file *file, 28433cb4a0bbSKawai, Hidehiro const char __user *buf, 28443cb4a0bbSKawai, Hidehiro size_t count, 28453cb4a0bbSKawai, Hidehiro loff_t *ppos) 28463cb4a0bbSKawai, Hidehiro { 28473cb4a0bbSKawai, Hidehiro struct task_struct *task; 28483cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 28493cb4a0bbSKawai, Hidehiro unsigned int val; 28503cb4a0bbSKawai, Hidehiro int ret; 28513cb4a0bbSKawai, Hidehiro int i; 28523cb4a0bbSKawai, Hidehiro unsigned long mask; 28533cb4a0bbSKawai, Hidehiro 2854774636e1SAlexey Dobriyan ret = kstrtouint_from_user(buf, count, 0, &val); 2855774636e1SAlexey Dobriyan if (ret < 0) 2856774636e1SAlexey Dobriyan return ret; 28573cb4a0bbSKawai, Hidehiro 28583cb4a0bbSKawai, Hidehiro ret = -ESRCH; 2859496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 28603cb4a0bbSKawai, Hidehiro if (!task) 28613cb4a0bbSKawai, Hidehiro goto out_no_task; 28623cb4a0bbSKawai, Hidehiro 28633cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 28643cb4a0bbSKawai, Hidehiro if (!mm) 28653cb4a0bbSKawai, Hidehiro goto out_no_mm; 286641a0c249SColin Ian King ret = 0; 28673cb4a0bbSKawai, Hidehiro 28683cb4a0bbSKawai, Hidehiro for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) { 28693cb4a0bbSKawai, Hidehiro if (val & mask) 28703cb4a0bbSKawai, Hidehiro set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 28713cb4a0bbSKawai, Hidehiro else 28723cb4a0bbSKawai, Hidehiro clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 28733cb4a0bbSKawai, Hidehiro } 28743cb4a0bbSKawai, Hidehiro 28753cb4a0bbSKawai, Hidehiro mmput(mm); 28763cb4a0bbSKawai, Hidehiro out_no_mm: 28773cb4a0bbSKawai, Hidehiro put_task_struct(task); 28783cb4a0bbSKawai, Hidehiro out_no_task: 2879774636e1SAlexey Dobriyan if (ret < 0) 28803cb4a0bbSKawai, Hidehiro return ret; 2881774636e1SAlexey Dobriyan return count; 28823cb4a0bbSKawai, Hidehiro } 28833cb4a0bbSKawai, Hidehiro 28843cb4a0bbSKawai, Hidehiro static const struct file_operations proc_coredump_filter_operations = { 28853cb4a0bbSKawai, Hidehiro .read = proc_coredump_filter_read, 28863cb4a0bbSKawai, Hidehiro .write = proc_coredump_filter_write, 288787df8424SArnd Bergmann .llseek = generic_file_llseek, 28883cb4a0bbSKawai, Hidehiro }; 28893cb4a0bbSKawai, Hidehiro #endif 28903cb4a0bbSKawai, Hidehiro 2891aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 289219aadc98SAlexey Dobriyan static int do_io_accounting(struct task_struct *task, struct seq_file *m, int whole) 2893aba76fdbSAndrew Morton { 2894940389b8SAndrea Righi struct task_io_accounting acct = task->ioac; 2895297c5d92SAndrea Righi unsigned long flags; 2896293eb1e7SVasiliy Kulikov int result; 2897297c5d92SAndrea Righi 289876518d37SBernd Edlinger result = mutex_lock_killable(&task->signal->exec_update_mutex); 2899293eb1e7SVasiliy Kulikov if (result) 2900293eb1e7SVasiliy Kulikov return result; 2901293eb1e7SVasiliy Kulikov 2902caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) { 2903293eb1e7SVasiliy Kulikov result = -EACCES; 2904293eb1e7SVasiliy Kulikov goto out_unlock; 2905293eb1e7SVasiliy Kulikov } 29061d1221f3SVasiliy Kulikov 29075995477aSAndrea Righi if (whole && lock_task_sighand(task, &flags)) { 2908b2d002dbSAndrea Righi struct task_struct *t = task; 2909297c5d92SAndrea Righi 29105995477aSAndrea Righi task_io_accounting_add(&acct, &task->signal->ioac); 29115995477aSAndrea Righi while_each_thread(task, t) 29125995477aSAndrea Righi task_io_accounting_add(&acct, &t->ioac); 2913297c5d92SAndrea Righi 2914297c5d92SAndrea Righi unlock_task_sighand(task, &flags); 2915297c5d92SAndrea Righi } 291625ce3191SJoe Perches seq_printf(m, 2917aba76fdbSAndrew Morton "rchar: %llu\n" 2918aba76fdbSAndrew Morton "wchar: %llu\n" 2919aba76fdbSAndrew Morton "syscr: %llu\n" 2920aba76fdbSAndrew Morton "syscw: %llu\n" 2921aba76fdbSAndrew Morton "read_bytes: %llu\n" 2922aba76fdbSAndrew Morton "write_bytes: %llu\n" 2923aba76fdbSAndrew Morton "cancelled_write_bytes: %llu\n", 29247c44319dSAlexander Beregalov (unsigned long long)acct.rchar, 29257c44319dSAlexander Beregalov (unsigned long long)acct.wchar, 29267c44319dSAlexander Beregalov (unsigned long long)acct.syscr, 29277c44319dSAlexander Beregalov (unsigned long long)acct.syscw, 29287c44319dSAlexander Beregalov (unsigned long long)acct.read_bytes, 29297c44319dSAlexander Beregalov (unsigned long long)acct.write_bytes, 29307c44319dSAlexander Beregalov (unsigned long long)acct.cancelled_write_bytes); 293125ce3191SJoe Perches result = 0; 293225ce3191SJoe Perches 2933293eb1e7SVasiliy Kulikov out_unlock: 293476518d37SBernd Edlinger mutex_unlock(&task->signal->exec_update_mutex); 2935293eb1e7SVasiliy Kulikov return result; 2936aba76fdbSAndrew Morton } 2937297c5d92SAndrea Righi 293819aadc98SAlexey Dobriyan static int proc_tid_io_accounting(struct seq_file *m, struct pid_namespace *ns, 293919aadc98SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2940297c5d92SAndrea Righi { 294119aadc98SAlexey Dobriyan return do_io_accounting(task, m, 0); 2942297c5d92SAndrea Righi } 2943297c5d92SAndrea Righi 294419aadc98SAlexey Dobriyan static int proc_tgid_io_accounting(struct seq_file *m, struct pid_namespace *ns, 294519aadc98SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2946297c5d92SAndrea Righi { 294719aadc98SAlexey Dobriyan return do_io_accounting(task, m, 1); 2948297c5d92SAndrea Righi } 2949297c5d92SAndrea Righi #endif /* CONFIG_TASK_IO_ACCOUNTING */ 2950aba76fdbSAndrew Morton 295122d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 295222d917d8SEric W. Biederman static int proc_id_map_open(struct inode *inode, struct file *file, 2953ccf94f1bSFabian Frederick const struct seq_operations *seq_ops) 295422d917d8SEric W. Biederman { 295522d917d8SEric W. Biederman struct user_namespace *ns = NULL; 295622d917d8SEric W. Biederman struct task_struct *task; 295722d917d8SEric W. Biederman struct seq_file *seq; 295822d917d8SEric W. Biederman int ret = -EINVAL; 295922d917d8SEric W. Biederman 296022d917d8SEric W. Biederman task = get_proc_task(inode); 296122d917d8SEric W. Biederman if (task) { 296222d917d8SEric W. Biederman rcu_read_lock(); 296322d917d8SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 296422d917d8SEric W. Biederman rcu_read_unlock(); 296522d917d8SEric W. Biederman put_task_struct(task); 296622d917d8SEric W. Biederman } 296722d917d8SEric W. Biederman if (!ns) 296822d917d8SEric W. Biederman goto err; 296922d917d8SEric W. Biederman 297022d917d8SEric W. Biederman ret = seq_open(file, seq_ops); 297122d917d8SEric W. Biederman if (ret) 297222d917d8SEric W. Biederman goto err_put_ns; 297322d917d8SEric W. Biederman 297422d917d8SEric W. Biederman seq = file->private_data; 297522d917d8SEric W. Biederman seq->private = ns; 297622d917d8SEric W. Biederman 297722d917d8SEric W. Biederman return 0; 297822d917d8SEric W. Biederman err_put_ns: 297922d917d8SEric W. Biederman put_user_ns(ns); 298022d917d8SEric W. Biederman err: 298122d917d8SEric W. Biederman return ret; 298222d917d8SEric W. Biederman } 298322d917d8SEric W. Biederman 298422d917d8SEric W. Biederman static int proc_id_map_release(struct inode *inode, struct file *file) 298522d917d8SEric W. Biederman { 298622d917d8SEric W. Biederman struct seq_file *seq = file->private_data; 298722d917d8SEric W. Biederman struct user_namespace *ns = seq->private; 298822d917d8SEric W. Biederman put_user_ns(ns); 298922d917d8SEric W. Biederman return seq_release(inode, file); 299022d917d8SEric W. Biederman } 299122d917d8SEric W. Biederman 299222d917d8SEric W. Biederman static int proc_uid_map_open(struct inode *inode, struct file *file) 299322d917d8SEric W. Biederman { 299422d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_uid_seq_operations); 299522d917d8SEric W. Biederman } 299622d917d8SEric W. Biederman 299722d917d8SEric W. Biederman static int proc_gid_map_open(struct inode *inode, struct file *file) 299822d917d8SEric W. Biederman { 299922d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_gid_seq_operations); 300022d917d8SEric W. Biederman } 300122d917d8SEric W. Biederman 3002f76d207aSEric W. Biederman static int proc_projid_map_open(struct inode *inode, struct file *file) 3003f76d207aSEric W. Biederman { 3004f76d207aSEric W. Biederman return proc_id_map_open(inode, file, &proc_projid_seq_operations); 3005f76d207aSEric W. Biederman } 3006f76d207aSEric W. Biederman 300722d917d8SEric W. Biederman static const struct file_operations proc_uid_map_operations = { 300822d917d8SEric W. Biederman .open = proc_uid_map_open, 300922d917d8SEric W. Biederman .write = proc_uid_map_write, 301022d917d8SEric W. Biederman .read = seq_read, 301122d917d8SEric W. Biederman .llseek = seq_lseek, 301222d917d8SEric W. Biederman .release = proc_id_map_release, 301322d917d8SEric W. Biederman }; 301422d917d8SEric W. Biederman 301522d917d8SEric W. Biederman static const struct file_operations proc_gid_map_operations = { 301622d917d8SEric W. Biederman .open = proc_gid_map_open, 301722d917d8SEric W. Biederman .write = proc_gid_map_write, 301822d917d8SEric W. Biederman .read = seq_read, 301922d917d8SEric W. Biederman .llseek = seq_lseek, 302022d917d8SEric W. Biederman .release = proc_id_map_release, 302122d917d8SEric W. Biederman }; 3022f76d207aSEric W. Biederman 3023f76d207aSEric W. Biederman static const struct file_operations proc_projid_map_operations = { 3024f76d207aSEric W. Biederman .open = proc_projid_map_open, 3025f76d207aSEric W. Biederman .write = proc_projid_map_write, 3026f76d207aSEric W. Biederman .read = seq_read, 3027f76d207aSEric W. Biederman .llseek = seq_lseek, 3028f76d207aSEric W. Biederman .release = proc_id_map_release, 3029f76d207aSEric W. Biederman }; 30309cc46516SEric W. Biederman 30319cc46516SEric W. Biederman static int proc_setgroups_open(struct inode *inode, struct file *file) 30329cc46516SEric W. Biederman { 30339cc46516SEric W. Biederman struct user_namespace *ns = NULL; 30349cc46516SEric W. Biederman struct task_struct *task; 30359cc46516SEric W. Biederman int ret; 30369cc46516SEric W. Biederman 30379cc46516SEric W. Biederman ret = -ESRCH; 30389cc46516SEric W. Biederman task = get_proc_task(inode); 30399cc46516SEric W. Biederman if (task) { 30409cc46516SEric W. Biederman rcu_read_lock(); 30419cc46516SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 30429cc46516SEric W. Biederman rcu_read_unlock(); 30439cc46516SEric W. Biederman put_task_struct(task); 30449cc46516SEric W. Biederman } 30459cc46516SEric W. Biederman if (!ns) 30469cc46516SEric W. Biederman goto err; 30479cc46516SEric W. Biederman 30489cc46516SEric W. Biederman if (file->f_mode & FMODE_WRITE) { 30499cc46516SEric W. Biederman ret = -EACCES; 30509cc46516SEric W. Biederman if (!ns_capable(ns, CAP_SYS_ADMIN)) 30519cc46516SEric W. Biederman goto err_put_ns; 30529cc46516SEric W. Biederman } 30539cc46516SEric W. Biederman 30549cc46516SEric W. Biederman ret = single_open(file, &proc_setgroups_show, ns); 30559cc46516SEric W. Biederman if (ret) 30569cc46516SEric W. Biederman goto err_put_ns; 30579cc46516SEric W. Biederman 30589cc46516SEric W. Biederman return 0; 30599cc46516SEric W. Biederman err_put_ns: 30609cc46516SEric W. Biederman put_user_ns(ns); 30619cc46516SEric W. Biederman err: 30629cc46516SEric W. Biederman return ret; 30639cc46516SEric W. Biederman } 30649cc46516SEric W. Biederman 30659cc46516SEric W. Biederman static int proc_setgroups_release(struct inode *inode, struct file *file) 30669cc46516SEric W. Biederman { 30679cc46516SEric W. Biederman struct seq_file *seq = file->private_data; 30689cc46516SEric W. Biederman struct user_namespace *ns = seq->private; 30699cc46516SEric W. Biederman int ret = single_release(inode, file); 30709cc46516SEric W. Biederman put_user_ns(ns); 30719cc46516SEric W. Biederman return ret; 30729cc46516SEric W. Biederman } 30739cc46516SEric W. Biederman 30749cc46516SEric W. Biederman static const struct file_operations proc_setgroups_operations = { 30759cc46516SEric W. Biederman .open = proc_setgroups_open, 30769cc46516SEric W. Biederman .write = proc_setgroups_write, 30779cc46516SEric W. Biederman .read = seq_read, 30789cc46516SEric W. Biederman .llseek = seq_lseek, 30799cc46516SEric W. Biederman .release = proc_setgroups_release, 30809cc46516SEric W. Biederman }; 308122d917d8SEric W. Biederman #endif /* CONFIG_USER_NS */ 308222d917d8SEric W. Biederman 308347830723SKees Cook static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns, 308447830723SKees Cook struct pid *pid, struct task_struct *task) 308547830723SKees Cook { 3086a9712bc1SAl Viro int err = lock_trace(task); 3087a9712bc1SAl Viro if (!err) { 308847830723SKees Cook seq_printf(m, "%08x\n", task->personality); 3089a9712bc1SAl Viro unlock_trace(task); 3090a9712bc1SAl Viro } 3091a9712bc1SAl Viro return err; 309247830723SKees Cook } 309347830723SKees Cook 30947c23b330SJosh Poimboeuf #ifdef CONFIG_LIVEPATCH 30957c23b330SJosh Poimboeuf static int proc_pid_patch_state(struct seq_file *m, struct pid_namespace *ns, 30967c23b330SJosh Poimboeuf struct pid *pid, struct task_struct *task) 30977c23b330SJosh Poimboeuf { 30987c23b330SJosh Poimboeuf seq_printf(m, "%d\n", task->patch_state); 30997c23b330SJosh Poimboeuf return 0; 31007c23b330SJosh Poimboeuf } 31017c23b330SJosh Poimboeuf #endif /* CONFIG_LIVEPATCH */ 31027c23b330SJosh Poimboeuf 3103c8d12627SAlexander Popov #ifdef CONFIG_STACKLEAK_METRICS 3104c8d12627SAlexander Popov static int proc_stack_depth(struct seq_file *m, struct pid_namespace *ns, 3105c8d12627SAlexander Popov struct pid *pid, struct task_struct *task) 3106c8d12627SAlexander Popov { 3107c8d12627SAlexander Popov unsigned long prev_depth = THREAD_SIZE - 3108c8d12627SAlexander Popov (task->prev_lowest_stack & (THREAD_SIZE - 1)); 3109c8d12627SAlexander Popov unsigned long depth = THREAD_SIZE - 3110c8d12627SAlexander Popov (task->lowest_stack & (THREAD_SIZE - 1)); 3111c8d12627SAlexander Popov 3112c8d12627SAlexander Popov seq_printf(m, "previous stack depth: %lu\nstack depth: %lu\n", 3113c8d12627SAlexander Popov prev_depth, depth); 3114c8d12627SAlexander Popov return 0; 3115c8d12627SAlexander Popov } 3116c8d12627SAlexander Popov #endif /* CONFIG_STACKLEAK_METRICS */ 3117c8d12627SAlexander Popov 3118801199ceSEric W. Biederman /* 311928a6d671SEric W. Biederman * Thread groups 312028a6d671SEric W. Biederman */ 312100977a59SArjan van de Ven static const struct file_operations proc_task_operations; 3122c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations; 312320cdc894SEric W. Biederman 3124c5141e6dSEric Dumazet static const struct pid_entry tgid_base_stuff[] = { 3125631f9c18SAlexey Dobriyan DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations), 3126631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 3127640708a2SPavel Emelyanov DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations), 3128631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 31296b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 3130b2211a36SAndrew Morton #ifdef CONFIG_NET 3131631f9c18SAlexey Dobriyan DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 3132b2211a36SAndrew Morton #endif 3133631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 3134c5317167SAl Viro REG("auxv", S_IRUSR, proc_auxv_operations), 3135631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 313635a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 31371c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 313843ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 3139631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 314043ae34cbSIngo Molnar #endif 31415091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 31425091faa4SMike Galbraith REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations), 31435091faa4SMike Galbraith #endif 314404a8682aSAndrei Vagin #ifdef CONFIG_TIME_NS 314504a8682aSAndrei Vagin REG("timens_offsets", S_IRUGO|S_IWUSR, proc_timens_offsets_operations), 314604a8682aSAndrei Vagin #endif 31474614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 3148ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 314909d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 3150ebcb6734SRoland McGrath #endif 3151c2c0bb44SAlexey Dobriyan REG("cmdline", S_IRUGO, proc_pid_cmdline_ops), 3152631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tgid_stat), 3153631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 3154b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_pid_maps_operations), 315528a6d671SEric W. Biederman #ifdef CONFIG_NUMA 3156b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations), 315728a6d671SEric W. Biederman #endif 3158631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 3159631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 3160631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 3161631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 3162631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 3163631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 3164631f9c18SAlexey Dobriyan REG("mountstats", S_IRUSR, proc_mountstats_operations), 31651e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 3166631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 3167b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_pid_smaps_operations), 3168493b0e9dSDaniel Colascione REG("smaps_rollup", S_IRUGO, proc_pid_smaps_rollup_operations), 316932ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 317028a6d671SEric W. Biederman #endif 317128a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 3172631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 317328a6d671SEric W. Biederman #endif 317428a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 3175edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 317628a6d671SEric W. Biederman #endif 31772ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 317835a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 317928a6d671SEric W. Biederman #endif 31805968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 3181f6e826caSAlexey Dobriyan ONE("schedstat", S_IRUGO, proc_pid_schedstat), 318228a6d671SEric W. Biederman #endif 31839745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3184631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 31859745512cSArjan van de Ven #endif 31868793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 318752de4779SZefan Li ONE("cpuset", S_IRUGO, proc_cpuset_show), 318828a6d671SEric W. Biederman #endif 3189a424316cSPaul Menage #ifdef CONFIG_CGROUPS 3190006f4ac4SZefan Li ONE("cgroup", S_IRUGO, proc_cgroup_show), 3191a424316cSPaul Menage #endif 3192e79f15a4SChen Yu #ifdef CONFIG_PROC_CPU_RESCTRL 3193e79f15a4SChen Yu ONE("cpu_resctrl_groups", S_IRUGO, proc_resctrl_show), 3194e79f15a4SChen Yu #endif 31956ba51e37SAlexey Dobriyan ONE("oom_score", S_IRUGO, proc_oom_score), 3196fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 3197a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 31984b7d248bSRichard Guy Briggs #ifdef CONFIG_AUDIT 3199631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 3200631f9c18SAlexey Dobriyan REG("sessionid", S_IRUGO, proc_sessionid_operations), 320128a6d671SEric W. Biederman #endif 3202f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 3203631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 3204168c42bcSAkinobu Mita REG("fail-nth", 0644, proc_fail_nth_operations), 3205f4f154fdSAkinobu Mita #endif 3206698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 3207631f9c18SAlexey Dobriyan REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations), 32083cb4a0bbSKawai, Hidehiro #endif 3209aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 321019aadc98SAlexey Dobriyan ONE("io", S_IRUSR, proc_tgid_io_accounting), 3211aba76fdbSAndrew Morton #endif 321222d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 321322d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 321422d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 3215f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 32169cc46516SEric W. Biederman REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), 321722d917d8SEric W. Biederman #endif 3218b18b6a9cSNicolas Pitre #if defined(CONFIG_CHECKPOINT_RESTORE) && defined(CONFIG_POSIX_TIMERS) 321948f6a7a5SPavel Emelyanov REG("timers", S_IRUGO, proc_timers_operations), 322048f6a7a5SPavel Emelyanov #endif 32215de23d43SJohn Stultz REG("timerslack_ns", S_IRUGO|S_IWUGO, proc_pid_set_timerslack_ns_operations), 32227c23b330SJosh Poimboeuf #ifdef CONFIG_LIVEPATCH 32237c23b330SJosh Poimboeuf ONE("patch_state", S_IRUSR, proc_pid_patch_state), 32247c23b330SJosh Poimboeuf #endif 3225c8d12627SAlexander Popov #ifdef CONFIG_STACKLEAK_METRICS 3226c8d12627SAlexander Popov ONE("stack_depth", S_IRUGO, proc_stack_depth), 3227c8d12627SAlexander Popov #endif 322868bc30bbSAubrey Li #ifdef CONFIG_PROC_PID_ARCH_STATUS 322968bc30bbSAubrey Li ONE("arch_status", S_IRUGO, proc_pid_arch_status), 323068bc30bbSAubrey Li #endif 323128a6d671SEric W. Biederman }; 323228a6d671SEric W. Biederman 3233f0c3b509SAl Viro static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx) 323428a6d671SEric W. Biederman { 3235f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 323628a6d671SEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 323728a6d671SEric W. Biederman } 323828a6d671SEric W. Biederman 323900977a59SArjan van de Ven static const struct file_operations proc_tgid_base_operations = { 324028a6d671SEric W. Biederman .read = generic_read_dir, 3241f50752eaSAl Viro .iterate_shared = proc_tgid_base_readdir, 3242f50752eaSAl Viro .llseek = generic_file_llseek, 324328a6d671SEric W. Biederman }; 324428a6d671SEric W. Biederman 32453eb39f47SChristian Brauner struct pid *tgid_pidfd_to_pid(const struct file *file) 32463eb39f47SChristian Brauner { 324730d158b1SChristian Brauner if (file->f_op != &proc_tgid_base_operations) 32483eb39f47SChristian Brauner return ERR_PTR(-EBADF); 32493eb39f47SChristian Brauner 32503eb39f47SChristian Brauner return proc_pid(file_inode(file)); 32513eb39f47SChristian Brauner } 32523eb39f47SChristian Brauner 325300cd8dd3SAl Viro static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 325400cd8dd3SAl Viro { 32557bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 3256d5a572a4SAlexey Dobriyan tgid_base_stuff, 3257d5a572a4SAlexey Dobriyan tgid_base_stuff + ARRAY_SIZE(tgid_base_stuff)); 325828a6d671SEric W. Biederman } 325928a6d671SEric W. Biederman 3260c5ef1c42SArjan van de Ven static const struct inode_operations proc_tgid_base_inode_operations = { 326128a6d671SEric W. Biederman .lookup = proc_tgid_base_lookup, 326228a6d671SEric W. Biederman .getattr = pid_getattr, 326328a6d671SEric W. Biederman .setattr = proc_setattr, 32640499680aSVasiliy Kulikov .permission = proc_pid_permission, 326528a6d671SEric W. Biederman }; 326628a6d671SEric W. Biederman 32670895e91dSRandy Dunlap /** 32687bc3e6e5SEric W. Biederman * proc_flush_pid - Remove dcache entries for @pid from the /proc dcache. 32697bc3e6e5SEric W. Biederman * @pid: pid that should be flushed. 32700895e91dSRandy Dunlap * 32717bc3e6e5SEric W. Biederman * This function walks a list of inodes (that belong to any proc 32727bc3e6e5SEric W. Biederman * filesystem) that are attached to the pid and flushes them from 32737bc3e6e5SEric W. Biederman * the dentry cache. 32740895e91dSRandy Dunlap * 32750895e91dSRandy Dunlap * It is safe and reasonable to cache /proc entries for a task until 32760895e91dSRandy Dunlap * that task exits. After that they just clog up the dcache with 32770895e91dSRandy Dunlap * useless entries, possibly causing useful dcache entries to be 32787bc3e6e5SEric W. Biederman * flushed instead. This routine is provided to flush those useless 32797bc3e6e5SEric W. Biederman * dcache entries when a process is reaped. 32800895e91dSRandy Dunlap * 32810895e91dSRandy Dunlap * NOTE: This routine is just an optimization so it does not guarantee 32827bc3e6e5SEric W. Biederman * that no dcache entries will exist after a process is reaped 32837bc3e6e5SEric W. Biederman * it just makes it very unlikely that any will persist. 328460347f67SPavel Emelyanov */ 328560347f67SPavel Emelyanov 32867bc3e6e5SEric W. Biederman void proc_flush_pid(struct pid *pid) 328760347f67SPavel Emelyanov { 328863f818f4SEric W. Biederman proc_invalidate_siblings_dcache(&pid->inodes, &pid->lock); 32897bc3e6e5SEric W. Biederman put_pid(pid); 329060347f67SPavel Emelyanov } 329160347f67SPavel Emelyanov 32920168b9e3SAl Viro static struct dentry *proc_pid_instantiate(struct dentry * dentry, 3293c5141e6dSEric Dumazet struct task_struct *task, const void *ptr) 3294444ceed8SEric W. Biederman { 3295444ceed8SEric W. Biederman struct inode *inode; 3296444ceed8SEric W. Biederman 32970168b9e3SAl Viro inode = proc_pid_make_inode(dentry->d_sb, task, S_IFDIR | S_IRUGO | S_IXUGO); 3298444ceed8SEric W. Biederman if (!inode) 32990168b9e3SAl Viro return ERR_PTR(-ENOENT); 3300444ceed8SEric W. Biederman 3301444ceed8SEric W. Biederman inode->i_op = &proc_tgid_base_inode_operations; 3302444ceed8SEric W. Biederman inode->i_fop = &proc_tgid_base_operations; 3303444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 3304aed54175SVegard Nossum 33051270dd8dSAlexey Dobriyan set_nlink(inode, nlink_tgid); 33061bbc5513SAl Viro pid_update_inode(task, inode); 3307444ceed8SEric W. Biederman 3308fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 33090168b9e3SAl Viro return d_splice_alias(inode, dentry); 3310444ceed8SEric W. Biederman } 3311444ceed8SEric W. Biederman 3312867aaccfSZhikang Zhang struct dentry *proc_pid_lookup(struct dentry *dentry, unsigned int flags) 33131da177e4SLinus Torvalds { 33141da177e4SLinus Torvalds struct task_struct *task; 33151da177e4SLinus Torvalds unsigned tgid; 3316b488893aSPavel Emelyanov struct pid_namespace *ns; 33170168b9e3SAl Viro struct dentry *result = ERR_PTR(-ENOENT); 33181da177e4SLinus Torvalds 3319dbcdb504SAlexey Dobriyan tgid = name_to_int(&dentry->d_name); 33201da177e4SLinus Torvalds if (tgid == ~0U) 33211da177e4SLinus Torvalds goto out; 33221da177e4SLinus Torvalds 3323b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 3324de758734SEric W. Biederman rcu_read_lock(); 3325b488893aSPavel Emelyanov task = find_task_by_pid_ns(tgid, ns); 33261da177e4SLinus Torvalds if (task) 33271da177e4SLinus Torvalds get_task_struct(task); 3328de758734SEric W. Biederman rcu_read_unlock(); 33291da177e4SLinus Torvalds if (!task) 33301da177e4SLinus Torvalds goto out; 33311da177e4SLinus Torvalds 33320168b9e3SAl Viro result = proc_pid_instantiate(dentry, task, NULL); 333348e6484dSEric W. Biederman put_task_struct(task); 33341da177e4SLinus Torvalds out: 33350168b9e3SAl Viro return result; 33361da177e4SLinus Torvalds } 33371da177e4SLinus Torvalds 33381da177e4SLinus Torvalds /* 33390804ef4bSEric W. Biederman * Find the first task with tgid >= tgid 33400bc58a91SEric W. Biederman * 33411da177e4SLinus Torvalds */ 334219fd4bb2SEric W. Biederman struct tgid_iter { 334319fd4bb2SEric W. Biederman unsigned int tgid; 33440804ef4bSEric W. Biederman struct task_struct *task; 334519fd4bb2SEric W. Biederman }; 334619fd4bb2SEric W. Biederman static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter) 334719fd4bb2SEric W. Biederman { 33480804ef4bSEric W. Biederman struct pid *pid; 33491da177e4SLinus Torvalds 335019fd4bb2SEric W. Biederman if (iter.task) 335119fd4bb2SEric W. Biederman put_task_struct(iter.task); 33520804ef4bSEric W. Biederman rcu_read_lock(); 33530804ef4bSEric W. Biederman retry: 335419fd4bb2SEric W. Biederman iter.task = NULL; 335519fd4bb2SEric W. Biederman pid = find_ge_pid(iter.tgid, ns); 33560804ef4bSEric W. Biederman if (pid) { 335719fd4bb2SEric W. Biederman iter.tgid = pid_nr_ns(pid, ns); 335819fd4bb2SEric W. Biederman iter.task = pid_task(pid, PIDTYPE_PID); 33590804ef4bSEric W. Biederman /* What we to know is if the pid we have find is the 33600804ef4bSEric W. Biederman * pid of a thread_group_leader. Testing for task 33610804ef4bSEric W. Biederman * being a thread_group_leader is the obvious thing 33620804ef4bSEric W. Biederman * todo but there is a window when it fails, due to 33630804ef4bSEric W. Biederman * the pid transfer logic in de_thread. 33640804ef4bSEric W. Biederman * 33650804ef4bSEric W. Biederman * So we perform the straight forward test of seeing 33660804ef4bSEric W. Biederman * if the pid we have found is the pid of a thread 33670804ef4bSEric W. Biederman * group leader, and don't worry if the task we have 33680804ef4bSEric W. Biederman * found doesn't happen to be a thread group leader. 33690804ef4bSEric W. Biederman * As we don't care in the case of readdir. 33700bc58a91SEric W. Biederman */ 337119fd4bb2SEric W. Biederman if (!iter.task || !has_group_leader_pid(iter.task)) { 337219fd4bb2SEric W. Biederman iter.tgid += 1; 33730804ef4bSEric W. Biederman goto retry; 337419fd4bb2SEric W. Biederman } 337519fd4bb2SEric W. Biederman get_task_struct(iter.task); 33761da177e4SLinus Torvalds } 3377454cc105SEric W. Biederman rcu_read_unlock(); 337819fd4bb2SEric W. Biederman return iter; 33791da177e4SLinus Torvalds } 33801da177e4SLinus Torvalds 33810097875bSEric W. Biederman #define TGID_OFFSET (FIRST_PROCESS_ENTRY + 2) 33821da177e4SLinus Torvalds 33831da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 3384f0c3b509SAl Viro int proc_pid_readdir(struct file *file, struct dir_context *ctx) 33851da177e4SLinus Torvalds { 338619fd4bb2SEric W. Biederman struct tgid_iter iter; 338776f668beSChristoph Hellwig struct pid_namespace *ns = proc_pid_ns(file_inode(file)); 3388f0c3b509SAl Viro loff_t pos = ctx->pos; 33891da177e4SLinus Torvalds 3390021ada7dSAl Viro if (pos >= PID_MAX_LIMIT + TGID_OFFSET) 3391f0c3b509SAl Viro return 0; 33921da177e4SLinus Torvalds 33930097875bSEric W. Biederman if (pos == TGID_OFFSET - 2) { 33942b0143b5SDavid Howells struct inode *inode = d_inode(ns->proc_self); 3395db963164SAl Viro if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK)) 3396f0c3b509SAl Viro return 0; 33970097875bSEric W. Biederman ctx->pos = pos = pos + 1; 3398021ada7dSAl Viro } 33990097875bSEric W. Biederman if (pos == TGID_OFFSET - 1) { 34002b0143b5SDavid Howells struct inode *inode = d_inode(ns->proc_thread_self); 34010097875bSEric W. Biederman if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK)) 34020097875bSEric W. Biederman return 0; 34030097875bSEric W. Biederman ctx->pos = pos = pos + 1; 34040097875bSEric W. Biederman } 34050097875bSEric W. Biederman iter.tgid = pos - TGID_OFFSET; 340619fd4bb2SEric W. Biederman iter.task = NULL; 340719fd4bb2SEric W. Biederman for (iter = next_tgid(ns, iter); 340819fd4bb2SEric W. Biederman iter.task; 340919fd4bb2SEric W. Biederman iter.tgid += 1, iter = next_tgid(ns, iter)) { 3410e3912ac3SAlexey Dobriyan char name[10 + 1]; 3411a4ef3895SAlexey Dobriyan unsigned int len; 34123ba4bceeSEric Dumazet 34133ba4bceeSEric Dumazet cond_resched(); 3414796f571bSLafcadio Wluiki if (!has_pid_permissions(ns, iter.task, HIDEPID_INVISIBLE)) 3415f0c3b509SAl Viro continue; 34160499680aSVasiliy Kulikov 3417e3912ac3SAlexey Dobriyan len = snprintf(name, sizeof(name), "%u", iter.tgid); 3418f0c3b509SAl Viro ctx->pos = iter.tgid + TGID_OFFSET; 3419f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3420f0c3b509SAl Viro proc_pid_instantiate, iter.task, NULL)) { 342119fd4bb2SEric W. Biederman put_task_struct(iter.task); 3422f0c3b509SAl Viro return 0; 34231da177e4SLinus Torvalds } 34241da177e4SLinus Torvalds } 3425f0c3b509SAl Viro ctx->pos = PID_MAX_LIMIT + TGID_OFFSET; 34261da177e4SLinus Torvalds return 0; 34271da177e4SLinus Torvalds } 34281da177e4SLinus Torvalds 34290bc58a91SEric W. Biederman /* 34301b3044e3SJanis Danisevskis * proc_tid_comm_permission is a special permission function exclusively 34311b3044e3SJanis Danisevskis * used for the node /proc/<pid>/task/<tid>/comm. 34321b3044e3SJanis Danisevskis * It bypasses generic permission checks in the case where a task of the same 34331b3044e3SJanis Danisevskis * task group attempts to access the node. 34341b3044e3SJanis Danisevskis * The rationale behind this is that glibc and bionic access this node for 34351b3044e3SJanis Danisevskis * cross thread naming (pthread_set/getname_np(!self)). However, if 34361b3044e3SJanis Danisevskis * PR_SET_DUMPABLE gets set to 0 this node among others becomes uid=0 gid=0, 34371b3044e3SJanis Danisevskis * which locks out the cross thread naming implementation. 34381b3044e3SJanis Danisevskis * This function makes sure that the node is always accessible for members of 34391b3044e3SJanis Danisevskis * same thread group. 34401b3044e3SJanis Danisevskis */ 34411b3044e3SJanis Danisevskis static int proc_tid_comm_permission(struct inode *inode, int mask) 34421b3044e3SJanis Danisevskis { 34431b3044e3SJanis Danisevskis bool is_same_tgroup; 34441b3044e3SJanis Danisevskis struct task_struct *task; 34451b3044e3SJanis Danisevskis 34461b3044e3SJanis Danisevskis task = get_proc_task(inode); 34471b3044e3SJanis Danisevskis if (!task) 34481b3044e3SJanis Danisevskis return -ESRCH; 34491b3044e3SJanis Danisevskis is_same_tgroup = same_thread_group(current, task); 34501b3044e3SJanis Danisevskis put_task_struct(task); 34511b3044e3SJanis Danisevskis 34521b3044e3SJanis Danisevskis if (likely(is_same_tgroup && !(mask & MAY_EXEC))) { 34531b3044e3SJanis Danisevskis /* This file (/proc/<pid>/task/<tid>/comm) can always be 34541b3044e3SJanis Danisevskis * read or written by the members of the corresponding 34551b3044e3SJanis Danisevskis * thread group. 34561b3044e3SJanis Danisevskis */ 34571b3044e3SJanis Danisevskis return 0; 34581b3044e3SJanis Danisevskis } 34591b3044e3SJanis Danisevskis 34601b3044e3SJanis Danisevskis return generic_permission(inode, mask); 34611b3044e3SJanis Danisevskis } 34621b3044e3SJanis Danisevskis 34631b3044e3SJanis Danisevskis static const struct inode_operations proc_tid_comm_inode_operations = { 34641b3044e3SJanis Danisevskis .permission = proc_tid_comm_permission, 34651b3044e3SJanis Danisevskis }; 34661b3044e3SJanis Danisevskis 34671b3044e3SJanis Danisevskis /* 346828a6d671SEric W. Biederman * Tasks 346928a6d671SEric W. Biederman */ 3470c5141e6dSEric Dumazet static const struct pid_entry tid_base_stuff[] = { 3471631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 34723835541dSJerome Marchand DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 34736b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 34746ba8ed79SEric W. Biederman #ifdef CONFIG_NET 34756ba8ed79SEric W. Biederman DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 34766ba8ed79SEric W. Biederman #endif 3477631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 3478c5317167SAl Viro REG("auxv", S_IRUSR, proc_auxv_operations), 3479631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 348035a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 34811c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 348243ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 3483631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 348443ae34cbSIngo Molnar #endif 34851b3044e3SJanis Danisevskis NOD("comm", S_IFREG|S_IRUGO|S_IWUSR, 34861b3044e3SJanis Danisevskis &proc_tid_comm_inode_operations, 34871b3044e3SJanis Danisevskis &proc_pid_set_comm_operations, {}), 3488ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 348909d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 3490ebcb6734SRoland McGrath #endif 3491c2c0bb44SAlexey Dobriyan REG("cmdline", S_IRUGO, proc_pid_cmdline_ops), 3492631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tid_stat), 3493631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 3494871305bbSVlastimil Babka REG("maps", S_IRUGO, proc_pid_maps_operations), 34952e13ba54SIago López Galeiras #ifdef CONFIG_PROC_CHILDREN 349681841161SCyrill Gorcunov REG("children", S_IRUGO, proc_tid_children_operations), 349781841161SCyrill Gorcunov #endif 349828a6d671SEric W. Biederman #ifdef CONFIG_NUMA 3499871305bbSVlastimil Babka REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations), 350028a6d671SEric W. Biederman #endif 3501631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 3502631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 3503631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 3504631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 3505631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 3506631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 35071e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 3508631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 3509871305bbSVlastimil Babka REG("smaps", S_IRUGO, proc_pid_smaps_operations), 3510493b0e9dSDaniel Colascione REG("smaps_rollup", S_IRUGO, proc_pid_smaps_rollup_operations), 351132ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 351228a6d671SEric W. Biederman #endif 351328a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 3514631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 351528a6d671SEric W. Biederman #endif 351628a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 3517edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 351828a6d671SEric W. Biederman #endif 35192ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 352035a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 352128a6d671SEric W. Biederman #endif 35225968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 3523f6e826caSAlexey Dobriyan ONE("schedstat", S_IRUGO, proc_pid_schedstat), 352428a6d671SEric W. Biederman #endif 35259745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3526631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 35279745512cSArjan van de Ven #endif 35288793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 352952de4779SZefan Li ONE("cpuset", S_IRUGO, proc_cpuset_show), 353028a6d671SEric W. Biederman #endif 3531a424316cSPaul Menage #ifdef CONFIG_CGROUPS 3532006f4ac4SZefan Li ONE("cgroup", S_IRUGO, proc_cgroup_show), 3533a424316cSPaul Menage #endif 3534e79f15a4SChen Yu #ifdef CONFIG_PROC_CPU_RESCTRL 3535e79f15a4SChen Yu ONE("cpu_resctrl_groups", S_IRUGO, proc_resctrl_show), 3536e79f15a4SChen Yu #endif 35376ba51e37SAlexey Dobriyan ONE("oom_score", S_IRUGO, proc_oom_score), 3538fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 3539a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 35404b7d248bSRichard Guy Briggs #ifdef CONFIG_AUDIT 3541631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 354226ec3c64SAl Viro REG("sessionid", S_IRUGO, proc_sessionid_operations), 354328a6d671SEric W. Biederman #endif 3544f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 3545631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 35461203c8e6SAkinobu Mita REG("fail-nth", 0644, proc_fail_nth_operations), 3547f4f154fdSAkinobu Mita #endif 3548297c5d92SAndrea Righi #ifdef CONFIG_TASK_IO_ACCOUNTING 354919aadc98SAlexey Dobriyan ONE("io", S_IRUSR, proc_tid_io_accounting), 3550297c5d92SAndrea Righi #endif 355122d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 355222d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 355322d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 3554f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 35559cc46516SEric W. Biederman REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), 355622d917d8SEric W. Biederman #endif 35577c23b330SJosh Poimboeuf #ifdef CONFIG_LIVEPATCH 35587c23b330SJosh Poimboeuf ONE("patch_state", S_IRUSR, proc_pid_patch_state), 35597c23b330SJosh Poimboeuf #endif 356068bc30bbSAubrey Li #ifdef CONFIG_PROC_PID_ARCH_STATUS 356168bc30bbSAubrey Li ONE("arch_status", S_IRUGO, proc_pid_arch_status), 356268bc30bbSAubrey Li #endif 356328a6d671SEric W. Biederman }; 356428a6d671SEric W. Biederman 3565f0c3b509SAl Viro static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx) 356628a6d671SEric W. Biederman { 3567f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 356828a6d671SEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 356928a6d671SEric W. Biederman } 357028a6d671SEric W. Biederman 357100cd8dd3SAl Viro static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 357200cd8dd3SAl Viro { 35737bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 3574d5a572a4SAlexey Dobriyan tid_base_stuff, 3575d5a572a4SAlexey Dobriyan tid_base_stuff + ARRAY_SIZE(tid_base_stuff)); 357628a6d671SEric W. Biederman } 357728a6d671SEric W. Biederman 357800977a59SArjan van de Ven static const struct file_operations proc_tid_base_operations = { 357928a6d671SEric W. Biederman .read = generic_read_dir, 3580f50752eaSAl Viro .iterate_shared = proc_tid_base_readdir, 3581f50752eaSAl Viro .llseek = generic_file_llseek, 358228a6d671SEric W. Biederman }; 358328a6d671SEric W. Biederman 3584c5ef1c42SArjan van de Ven static const struct inode_operations proc_tid_base_inode_operations = { 358528a6d671SEric W. Biederman .lookup = proc_tid_base_lookup, 358628a6d671SEric W. Biederman .getattr = pid_getattr, 358728a6d671SEric W. Biederman .setattr = proc_setattr, 358828a6d671SEric W. Biederman }; 358928a6d671SEric W. Biederman 35900168b9e3SAl Viro static struct dentry *proc_task_instantiate(struct dentry *dentry, 35910168b9e3SAl Viro struct task_struct *task, const void *ptr) 3592444ceed8SEric W. Biederman { 3593444ceed8SEric W. Biederman struct inode *inode; 35940168b9e3SAl Viro inode = proc_pid_make_inode(dentry->d_sb, task, S_IFDIR | S_IRUGO | S_IXUGO); 3595444ceed8SEric W. Biederman if (!inode) 35960168b9e3SAl Viro return ERR_PTR(-ENOENT); 35971bbc5513SAl Viro 3598444ceed8SEric W. Biederman inode->i_op = &proc_tid_base_inode_operations; 3599444ceed8SEric W. Biederman inode->i_fop = &proc_tid_base_operations; 3600444ceed8SEric W. Biederman inode->i_flags |= S_IMMUTABLE; 3601aed54175SVegard Nossum 36021270dd8dSAlexey Dobriyan set_nlink(inode, nlink_tid); 36031bbc5513SAl Viro pid_update_inode(task, inode); 3604444ceed8SEric W. Biederman 3605fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 36060168b9e3SAl Viro return d_splice_alias(inode, dentry); 3607444ceed8SEric W. Biederman } 3608444ceed8SEric W. Biederman 360900cd8dd3SAl Viro static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 361028a6d671SEric W. Biederman { 361128a6d671SEric W. Biederman struct task_struct *task; 361228a6d671SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 361328a6d671SEric W. Biederman unsigned tid; 3614b488893aSPavel Emelyanov struct pid_namespace *ns; 36150168b9e3SAl Viro struct dentry *result = ERR_PTR(-ENOENT); 361628a6d671SEric W. Biederman 361728a6d671SEric W. Biederman if (!leader) 361828a6d671SEric W. Biederman goto out_no_task; 361928a6d671SEric W. Biederman 3620dbcdb504SAlexey Dobriyan tid = name_to_int(&dentry->d_name); 362128a6d671SEric W. Biederman if (tid == ~0U) 362228a6d671SEric W. Biederman goto out; 362328a6d671SEric W. Biederman 3624b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 362528a6d671SEric W. Biederman rcu_read_lock(); 3626b488893aSPavel Emelyanov task = find_task_by_pid_ns(tid, ns); 362728a6d671SEric W. Biederman if (task) 362828a6d671SEric W. Biederman get_task_struct(task); 362928a6d671SEric W. Biederman rcu_read_unlock(); 363028a6d671SEric W. Biederman if (!task) 363128a6d671SEric W. Biederman goto out; 3632bac0abd6SPavel Emelyanov if (!same_thread_group(leader, task)) 363328a6d671SEric W. Biederman goto out_drop_task; 363428a6d671SEric W. Biederman 36350168b9e3SAl Viro result = proc_task_instantiate(dentry, task, NULL); 363628a6d671SEric W. Biederman out_drop_task: 363728a6d671SEric W. Biederman put_task_struct(task); 363828a6d671SEric W. Biederman out: 363928a6d671SEric W. Biederman put_task_struct(leader); 364028a6d671SEric W. Biederman out_no_task: 36410168b9e3SAl Viro return result; 364228a6d671SEric W. Biederman } 364328a6d671SEric W. Biederman 364428a6d671SEric W. Biederman /* 36450bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 36460bc58a91SEric W. Biederman * 36470bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 36480bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 36490bc58a91SEric W. Biederman * directory we have more work todo. 36500bc58a91SEric W. Biederman * 36510bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 36520bc58a91SEric W. Biederman * 36530bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 36540bc58a91SEric W. Biederman * threads past it. 36550bc58a91SEric W. Biederman */ 36569f6e963fSOleg Nesterov static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos, 36579f6e963fSOleg Nesterov struct pid_namespace *ns) 36580bc58a91SEric W. Biederman { 3659d855a4b7SOleg Nesterov struct task_struct *pos, *task; 36609f6e963fSOleg Nesterov unsigned long nr = f_pos; 36619f6e963fSOleg Nesterov 36629f6e963fSOleg Nesterov if (nr != f_pos) /* 32bit overflow? */ 36639f6e963fSOleg Nesterov return NULL; 36640bc58a91SEric W. Biederman 3665cc288738SEric W. Biederman rcu_read_lock(); 3666d855a4b7SOleg Nesterov task = pid_task(pid, PIDTYPE_PID); 3667d855a4b7SOleg Nesterov if (!task) 3668d855a4b7SOleg Nesterov goto fail; 3669d855a4b7SOleg Nesterov 3670d855a4b7SOleg Nesterov /* Attempt to start with the tid of a thread */ 36719f6e963fSOleg Nesterov if (tid && nr) { 3672b488893aSPavel Emelyanov pos = find_task_by_pid_ns(tid, ns); 3673d855a4b7SOleg Nesterov if (pos && same_thread_group(pos, task)) 3674a872ff0cSOleg Nesterov goto found; 36750bc58a91SEric W. Biederman } 36760bc58a91SEric W. Biederman 36770bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 36789f6e963fSOleg Nesterov if (nr >= get_nr_threads(task)) 3679c986c14aSOleg Nesterov goto fail; 3680a872ff0cSOleg Nesterov 3681a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 3682a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 3683a872ff0cSOleg Nesterov */ 3684d855a4b7SOleg Nesterov pos = task = task->group_leader; 3685c986c14aSOleg Nesterov do { 36869f6e963fSOleg Nesterov if (!nr--) 3687c986c14aSOleg Nesterov goto found; 3688d855a4b7SOleg Nesterov } while_each_thread(task, pos); 3689c986c14aSOleg Nesterov fail: 3690a872ff0cSOleg Nesterov pos = NULL; 3691a872ff0cSOleg Nesterov goto out; 3692a872ff0cSOleg Nesterov found: 3693a872ff0cSOleg Nesterov get_task_struct(pos); 3694a872ff0cSOleg Nesterov out: 3695cc288738SEric W. Biederman rcu_read_unlock(); 36960bc58a91SEric W. Biederman return pos; 36970bc58a91SEric W. Biederman } 36980bc58a91SEric W. Biederman 36990bc58a91SEric W. Biederman /* 37000bc58a91SEric W. Biederman * Find the next thread in the thread list. 37010bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 37020bc58a91SEric W. Biederman * 37030bc58a91SEric W. Biederman * The reference to the input task_struct is released. 37040bc58a91SEric W. Biederman */ 37050bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 37060bc58a91SEric W. Biederman { 3707c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 3708cc288738SEric W. Biederman rcu_read_lock(); 3709c1df7fb8SOleg Nesterov if (pid_alive(start)) { 37100bc58a91SEric W. Biederman pos = next_thread(start); 3711c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 37120bc58a91SEric W. Biederman pos = NULL; 3713c1df7fb8SOleg Nesterov else 3714c1df7fb8SOleg Nesterov get_task_struct(pos); 3715c1df7fb8SOleg Nesterov } 3716cc288738SEric W. Biederman rcu_read_unlock(); 37170bc58a91SEric W. Biederman put_task_struct(start); 37180bc58a91SEric W. Biederman return pos; 37190bc58a91SEric W. Biederman } 37200bc58a91SEric W. Biederman 37211da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 3722f0c3b509SAl Viro static int proc_task_readdir(struct file *file, struct dir_context *ctx) 37231da177e4SLinus Torvalds { 3724d855a4b7SOleg Nesterov struct inode *inode = file_inode(file); 3725d855a4b7SOleg Nesterov struct task_struct *task; 3726b488893aSPavel Emelyanov struct pid_namespace *ns; 3727f0c3b509SAl Viro int tid; 37281da177e4SLinus Torvalds 3729d855a4b7SOleg Nesterov if (proc_inode_is_dead(inode)) 3730f0c3b509SAl Viro return -ENOENT; 37311da177e4SLinus Torvalds 3732f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 3733d855a4b7SOleg Nesterov return 0; 37341da177e4SLinus Torvalds 37350bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 37360bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 37370bc58a91SEric W. Biederman */ 373876f668beSChristoph Hellwig ns = proc_pid_ns(inode); 3739f0c3b509SAl Viro tid = (int)file->f_version; 3740f0c3b509SAl Viro file->f_version = 0; 3741d855a4b7SOleg Nesterov for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns); 37420bc58a91SEric W. Biederman task; 3743f0c3b509SAl Viro task = next_tid(task), ctx->pos++) { 3744e3912ac3SAlexey Dobriyan char name[10 + 1]; 3745a4ef3895SAlexey Dobriyan unsigned int len; 3746b488893aSPavel Emelyanov tid = task_pid_nr_ns(task, ns); 3747e3912ac3SAlexey Dobriyan len = snprintf(name, sizeof(name), "%u", tid); 3748f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3749f0c3b509SAl Viro proc_task_instantiate, task, NULL)) { 37500bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 37510bc58a91SEric W. Biederman * pid for the next readir call */ 3752f0c3b509SAl Viro file->f_version = (u64)tid; 37530bc58a91SEric W. Biederman put_task_struct(task); 37541da177e4SLinus Torvalds break; 37550bc58a91SEric W. Biederman } 37561da177e4SLinus Torvalds } 3757d855a4b7SOleg Nesterov 3758f0c3b509SAl Viro return 0; 37591da177e4SLinus Torvalds } 37606e66b52bSEric W. Biederman 3761a528d35eSDavid Howells static int proc_task_getattr(const struct path *path, struct kstat *stat, 3762a528d35eSDavid Howells u32 request_mask, unsigned int query_flags) 37636e66b52bSEric W. Biederman { 3764a528d35eSDavid Howells struct inode *inode = d_inode(path->dentry); 376599f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 37666e66b52bSEric W. Biederman generic_fillattr(inode, stat); 37676e66b52bSEric W. Biederman 376899f89551SEric W. Biederman if (p) { 376999f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 377099f89551SEric W. Biederman put_task_struct(p); 37716e66b52bSEric W. Biederman } 37726e66b52bSEric W. Biederman 37736e66b52bSEric W. Biederman return 0; 37746e66b52bSEric W. Biederman } 377528a6d671SEric W. Biederman 3776c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations = { 377728a6d671SEric W. Biederman .lookup = proc_task_lookup, 377828a6d671SEric W. Biederman .getattr = proc_task_getattr, 377928a6d671SEric W. Biederman .setattr = proc_setattr, 37800499680aSVasiliy Kulikov .permission = proc_pid_permission, 378128a6d671SEric W. Biederman }; 378228a6d671SEric W. Biederman 378300977a59SArjan van de Ven static const struct file_operations proc_task_operations = { 378428a6d671SEric W. Biederman .read = generic_read_dir, 3785f50752eaSAl Viro .iterate_shared = proc_task_readdir, 3786f50752eaSAl Viro .llseek = generic_file_llseek, 378728a6d671SEric W. Biederman }; 37881270dd8dSAlexey Dobriyan 37891270dd8dSAlexey Dobriyan void __init set_proc_pid_nlink(void) 37901270dd8dSAlexey Dobriyan { 37911270dd8dSAlexey Dobriyan nlink_tid = pid_entry_nlink(tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 37921270dd8dSAlexey Dobriyan nlink_tgid = pid_entry_nlink(tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 37931270dd8dSAlexey Dobriyan } 3794