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> 621da177e4SLinus Torvalds #include <linux/string.h> 631da177e4SLinus Torvalds #include <linux/seq_file.h> 641da177e4SLinus Torvalds #include <linux/namei.h> 656b3286edSKirill Korotaev #include <linux/mnt_namespace.h> 661da177e4SLinus Torvalds #include <linux/mm.h> 67a63d83f4SDavid Rientjes #include <linux/swap.h> 68b835996fSDipankar Sarma #include <linux/rcupdate.h> 691da177e4SLinus Torvalds #include <linux/kallsyms.h> 702ec220e2SKen Chen #include <linux/stacktrace.h> 71d85f50d5SNeil Horman #include <linux/resource.h> 725096add8SKees Cook #include <linux/module.h> 731da177e4SLinus Torvalds #include <linux/mount.h> 741da177e4SLinus Torvalds #include <linux/security.h> 751da177e4SLinus Torvalds #include <linux/ptrace.h> 760d094efeSRoland McGrath #include <linux/tracehook.h> 7787ebdc00SAndrew Morton #include <linux/printk.h> 78a424316cSPaul Menage #include <linux/cgroup.h> 791da177e4SLinus Torvalds #include <linux/cpuset.h> 801da177e4SLinus Torvalds #include <linux/audit.h> 815addc5ddSAl Viro #include <linux/poll.h> 821651e14eSSerge E. Hallyn #include <linux/nsproxy.h> 838ac773b4SAlexey Dobriyan #include <linux/oom.h> 843cb4a0bbSKawai, Hidehiro #include <linux/elf.h> 8560347f67SPavel Emelyanov #include <linux/pid_namespace.h> 8622d917d8SEric W. Biederman #include <linux/user_namespace.h> 875ad4e53bSAl Viro #include <linux/fs_struct.h> 885a0e3ad6STejun Heo #include <linux/slab.h> 894eb5aaa3SIngo Molnar #include <linux/sched/autogroup.h> 906e84f315SIngo Molnar #include <linux/sched/mm.h> 91f7ccbae4SIngo Molnar #include <linux/sched/coredump.h> 92b17b0153SIngo Molnar #include <linux/sched/debug.h> 933905f9adSIngo Molnar #include <linux/sched/stat.h> 94640708a2SPavel Emelyanov #include <linux/flex_array.h> 9548f6a7a5SPavel Emelyanov #include <linux/posix-timers.h> 96f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 97f133eccaSChris Metcalf #include <asm/hardwall.h> 98f133eccaSChris Metcalf #endif 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 1151270dd8dSAlexey Dobriyan static u8 nlink_tid; 1161270dd8dSAlexey Dobriyan static u8 nlink_tgid; 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 } ) 1481da177e4SLinus Torvalds 149aed54175SVegard Nossum /* 150aed54175SVegard Nossum * Count the number of hardlinks for the pid_entry table, excluding the . 151aed54175SVegard Nossum * and .. links. 152aed54175SVegard Nossum */ 1531270dd8dSAlexey Dobriyan static unsigned int __init pid_entry_nlink(const struct pid_entry *entries, 154aed54175SVegard Nossum unsigned int n) 155aed54175SVegard Nossum { 156aed54175SVegard Nossum unsigned int i; 157aed54175SVegard Nossum unsigned int count; 158aed54175SVegard Nossum 1591270dd8dSAlexey Dobriyan count = 2; 160aed54175SVegard Nossum for (i = 0; i < n; ++i) { 161aed54175SVegard Nossum if (S_ISDIR(entries[i].mode)) 162aed54175SVegard Nossum ++count; 163aed54175SVegard Nossum } 164aed54175SVegard Nossum 165aed54175SVegard Nossum return count; 166aed54175SVegard Nossum } 167aed54175SVegard Nossum 168f7ad3c6bSMiklos Szeredi static int get_task_root(struct task_struct *task, struct path *root) 1691da177e4SLinus Torvalds { 1707c2c7d99SHugh Dickins int result = -ENOENT; 1717c2c7d99SHugh Dickins 1720494f6ecSMiklos Szeredi task_lock(task); 173f7ad3c6bSMiklos Szeredi if (task->fs) { 174f7ad3c6bSMiklos Szeredi get_fs_root(task->fs, root); 1757c2c7d99SHugh Dickins result = 0; 1767c2c7d99SHugh Dickins } 1770494f6ecSMiklos Szeredi task_unlock(task); 1787c2c7d99SHugh Dickins return result; 1790494f6ecSMiklos Szeredi } 1800494f6ecSMiklos Szeredi 1817773fbc5SCyrill Gorcunov static int proc_cwd_link(struct dentry *dentry, struct path *path) 1820494f6ecSMiklos Szeredi { 1832b0143b5SDavid Howells struct task_struct *task = get_proc_task(d_inode(dentry)); 1840494f6ecSMiklos Szeredi int result = -ENOENT; 18599f89551SEric W. Biederman 18699f89551SEric W. Biederman if (task) { 187f7ad3c6bSMiklos Szeredi task_lock(task); 188f7ad3c6bSMiklos Szeredi if (task->fs) { 189f7ad3c6bSMiklos Szeredi get_fs_pwd(task->fs, path); 190f7ad3c6bSMiklos Szeredi result = 0; 191f7ad3c6bSMiklos Szeredi } 192f7ad3c6bSMiklos Szeredi task_unlock(task); 19399f89551SEric W. Biederman put_task_struct(task); 19499f89551SEric W. Biederman } 1951da177e4SLinus Torvalds return result; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds 1987773fbc5SCyrill Gorcunov static int proc_root_link(struct dentry *dentry, struct path *path) 1991da177e4SLinus Torvalds { 2002b0143b5SDavid Howells struct task_struct *task = get_proc_task(d_inode(dentry)); 2011da177e4SLinus Torvalds int result = -ENOENT; 20299f89551SEric W. Biederman 20399f89551SEric W. Biederman if (task) { 204f7ad3c6bSMiklos Szeredi result = get_task_root(task, path); 20599f89551SEric W. Biederman put_task_struct(task); 20699f89551SEric W. Biederman } 2071da177e4SLinus Torvalds return result; 2081da177e4SLinus Torvalds } 2091da177e4SLinus Torvalds 210c2c0bb44SAlexey Dobriyan static ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf, 211c2c0bb44SAlexey Dobriyan size_t _count, loff_t *pos) 2121da177e4SLinus Torvalds { 213c2c0bb44SAlexey Dobriyan struct task_struct *tsk; 214c2c0bb44SAlexey Dobriyan struct mm_struct *mm; 215c2c0bb44SAlexey Dobriyan char *page; 216c2c0bb44SAlexey Dobriyan unsigned long count = _count; 217c2c0bb44SAlexey Dobriyan unsigned long arg_start, arg_end, env_start, env_end; 218c2c0bb44SAlexey Dobriyan unsigned long len1, len2, len; 219c2c0bb44SAlexey Dobriyan unsigned long p; 220c2c0bb44SAlexey Dobriyan char c; 221c2c0bb44SAlexey Dobriyan ssize_t rv; 222c2c0bb44SAlexey Dobriyan 223c2c0bb44SAlexey Dobriyan BUG_ON(*pos < 0); 224c2c0bb44SAlexey Dobriyan 225c2c0bb44SAlexey Dobriyan tsk = get_proc_task(file_inode(file)); 226c2c0bb44SAlexey Dobriyan if (!tsk) 227c2c0bb44SAlexey Dobriyan return -ESRCH; 228c2c0bb44SAlexey Dobriyan mm = get_task_mm(tsk); 229c2c0bb44SAlexey Dobriyan put_task_struct(tsk); 230c2c0bb44SAlexey Dobriyan if (!mm) 2312ca66ff7SAlexey Dobriyan return 0; 232c2c0bb44SAlexey Dobriyan /* Check if process spawned far enough to have cmdline. */ 233c2c0bb44SAlexey Dobriyan if (!mm->env_end) { 234c2c0bb44SAlexey Dobriyan rv = 0; 235c2c0bb44SAlexey Dobriyan goto out_mmput; 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds 2380ee931c4SMichal Hocko page = (char *)__get_free_page(GFP_KERNEL); 239c2c0bb44SAlexey Dobriyan if (!page) { 240c2c0bb44SAlexey Dobriyan rv = -ENOMEM; 241c2c0bb44SAlexey Dobriyan goto out_mmput; 242c2c0bb44SAlexey Dobriyan } 243c2c0bb44SAlexey Dobriyan 244c2c0bb44SAlexey Dobriyan down_read(&mm->mmap_sem); 245c2c0bb44SAlexey Dobriyan arg_start = mm->arg_start; 246c2c0bb44SAlexey Dobriyan arg_end = mm->arg_end; 247c2c0bb44SAlexey Dobriyan env_start = mm->env_start; 248c2c0bb44SAlexey Dobriyan env_end = mm->env_end; 249c2c0bb44SAlexey Dobriyan up_read(&mm->mmap_sem); 250c2c0bb44SAlexey Dobriyan 251c2c0bb44SAlexey Dobriyan BUG_ON(arg_start > arg_end); 252c2c0bb44SAlexey Dobriyan BUG_ON(env_start > env_end); 253c2c0bb44SAlexey Dobriyan 254c2c0bb44SAlexey Dobriyan len1 = arg_end - arg_start; 255c2c0bb44SAlexey Dobriyan len2 = env_end - env_start; 256c2c0bb44SAlexey Dobriyan 2573581d458SAlexey Dobriyan /* Empty ARGV. */ 2583581d458SAlexey Dobriyan if (len1 == 0) { 2593581d458SAlexey Dobriyan rv = 0; 2603581d458SAlexey Dobriyan goto out_free_page; 2613581d458SAlexey Dobriyan } 262c2c0bb44SAlexey Dobriyan /* 263c2c0bb44SAlexey Dobriyan * Inherently racy -- command line shares address space 264c2c0bb44SAlexey Dobriyan * with code and data. 265c2c0bb44SAlexey Dobriyan */ 266272ddc8bSLinus Torvalds rv = access_remote_vm(mm, arg_end - 1, &c, 1, 0); 267c2c0bb44SAlexey Dobriyan if (rv <= 0) 268c2c0bb44SAlexey Dobriyan goto out_free_page; 269c2c0bb44SAlexey Dobriyan 270c2c0bb44SAlexey Dobriyan rv = 0; 271c2c0bb44SAlexey Dobriyan 272c2c0bb44SAlexey Dobriyan if (c == '\0') { 273c2c0bb44SAlexey Dobriyan /* Command line (set of strings) occupies whole ARGV. */ 274c2c0bb44SAlexey Dobriyan if (len1 <= *pos) 275c2c0bb44SAlexey Dobriyan goto out_free_page; 276c2c0bb44SAlexey Dobriyan 277c2c0bb44SAlexey Dobriyan p = arg_start + *pos; 278c2c0bb44SAlexey Dobriyan len = len1 - *pos; 279c2c0bb44SAlexey Dobriyan while (count > 0 && len > 0) { 280c2c0bb44SAlexey Dobriyan unsigned int _count; 281c2c0bb44SAlexey Dobriyan int nr_read; 282c2c0bb44SAlexey Dobriyan 283c2c0bb44SAlexey Dobriyan _count = min3(count, len, PAGE_SIZE); 284272ddc8bSLinus Torvalds nr_read = access_remote_vm(mm, p, page, _count, 0); 285c2c0bb44SAlexey Dobriyan if (nr_read < 0) 286c2c0bb44SAlexey Dobriyan rv = nr_read; 287c2c0bb44SAlexey Dobriyan if (nr_read <= 0) 288c2c0bb44SAlexey Dobriyan goto out_free_page; 289c2c0bb44SAlexey Dobriyan 290c2c0bb44SAlexey Dobriyan if (copy_to_user(buf, page, nr_read)) { 291c2c0bb44SAlexey Dobriyan rv = -EFAULT; 292c2c0bb44SAlexey Dobriyan goto out_free_page; 293c2c0bb44SAlexey Dobriyan } 294c2c0bb44SAlexey Dobriyan 295c2c0bb44SAlexey Dobriyan p += nr_read; 296c2c0bb44SAlexey Dobriyan len -= nr_read; 297c2c0bb44SAlexey Dobriyan buf += nr_read; 298c2c0bb44SAlexey Dobriyan count -= nr_read; 299c2c0bb44SAlexey Dobriyan rv += nr_read; 300c2c0bb44SAlexey Dobriyan } 301c2c0bb44SAlexey Dobriyan } else { 302c2c0bb44SAlexey Dobriyan /* 303a0a07b87SAlexey Dobriyan * Command line (1 string) occupies ARGV and 304c2c0bb44SAlexey Dobriyan * extends into ENVP. 305c2c0bb44SAlexey Dobriyan */ 306a0a07b87SAlexey Dobriyan struct { 307a0a07b87SAlexey Dobriyan unsigned long p; 308a0a07b87SAlexey Dobriyan unsigned long len; 309a0a07b87SAlexey Dobriyan } cmdline[2] = { 310a0a07b87SAlexey Dobriyan { .p = arg_start, .len = len1 }, 311a0a07b87SAlexey Dobriyan { .p = env_start, .len = len2 }, 312a0a07b87SAlexey Dobriyan }; 313a0a07b87SAlexey Dobriyan loff_t pos1 = *pos; 314a0a07b87SAlexey Dobriyan unsigned int i; 315c2c0bb44SAlexey Dobriyan 316a0a07b87SAlexey Dobriyan i = 0; 317a0a07b87SAlexey Dobriyan while (i < 2 && pos1 >= cmdline[i].len) { 318a0a07b87SAlexey Dobriyan pos1 -= cmdline[i].len; 319a0a07b87SAlexey Dobriyan i++; 320a0a07b87SAlexey Dobriyan } 321a0a07b87SAlexey Dobriyan while (i < 2) { 322a0a07b87SAlexey Dobriyan p = cmdline[i].p + pos1; 323a0a07b87SAlexey Dobriyan len = cmdline[i].len - pos1; 324c2c0bb44SAlexey Dobriyan while (count > 0 && len > 0) { 325c2c0bb44SAlexey Dobriyan unsigned int _count, l; 326c2c0bb44SAlexey Dobriyan int nr_read; 327c2c0bb44SAlexey Dobriyan bool final; 328c2c0bb44SAlexey Dobriyan 329c2c0bb44SAlexey Dobriyan _count = min3(count, len, PAGE_SIZE); 330272ddc8bSLinus Torvalds nr_read = access_remote_vm(mm, p, page, _count, 0); 331c2c0bb44SAlexey Dobriyan if (nr_read < 0) 332c2c0bb44SAlexey Dobriyan rv = nr_read; 333c2c0bb44SAlexey Dobriyan if (nr_read <= 0) 334c2c0bb44SAlexey Dobriyan goto out_free_page; 335c2c0bb44SAlexey Dobriyan 336c2c0bb44SAlexey Dobriyan /* 337c2c0bb44SAlexey Dobriyan * Command line can be shorter than whole ARGV 338c2c0bb44SAlexey Dobriyan * even if last "marker" byte says it is not. 339c2c0bb44SAlexey Dobriyan */ 340c2c0bb44SAlexey Dobriyan final = false; 341c2c0bb44SAlexey Dobriyan l = strnlen(page, nr_read); 342c2c0bb44SAlexey Dobriyan if (l < nr_read) { 343c2c0bb44SAlexey Dobriyan nr_read = l; 344c2c0bb44SAlexey Dobriyan final = true; 345c2c0bb44SAlexey Dobriyan } 346c2c0bb44SAlexey Dobriyan 347c2c0bb44SAlexey Dobriyan if (copy_to_user(buf, page, nr_read)) { 348c2c0bb44SAlexey Dobriyan rv = -EFAULT; 349c2c0bb44SAlexey Dobriyan goto out_free_page; 350c2c0bb44SAlexey Dobriyan } 351c2c0bb44SAlexey Dobriyan 352c2c0bb44SAlexey Dobriyan p += nr_read; 353c2c0bb44SAlexey Dobriyan len -= nr_read; 354c2c0bb44SAlexey Dobriyan buf += nr_read; 355c2c0bb44SAlexey Dobriyan count -= nr_read; 356c2c0bb44SAlexey Dobriyan rv += nr_read; 357c2c0bb44SAlexey Dobriyan 358c2c0bb44SAlexey Dobriyan if (final) 359c2c0bb44SAlexey Dobriyan goto out_free_page; 360c2c0bb44SAlexey Dobriyan } 361a0a07b87SAlexey Dobriyan 362a0a07b87SAlexey Dobriyan /* Only first chunk can be read partially. */ 363a0a07b87SAlexey Dobriyan pos1 = 0; 364a0a07b87SAlexey Dobriyan i++; 365c2c0bb44SAlexey Dobriyan } 366c2c0bb44SAlexey Dobriyan } 367c2c0bb44SAlexey Dobriyan 368c2c0bb44SAlexey Dobriyan out_free_page: 369c2c0bb44SAlexey Dobriyan free_page((unsigned long)page); 370c2c0bb44SAlexey Dobriyan out_mmput: 371c2c0bb44SAlexey Dobriyan mmput(mm); 372c2c0bb44SAlexey Dobriyan if (rv > 0) 373c2c0bb44SAlexey Dobriyan *pos += rv; 374c2c0bb44SAlexey Dobriyan return rv; 375c2c0bb44SAlexey Dobriyan } 376c2c0bb44SAlexey Dobriyan 377c2c0bb44SAlexey Dobriyan static const struct file_operations proc_pid_cmdline_ops = { 378c2c0bb44SAlexey Dobriyan .read = proc_pid_cmdline_read, 379c2c0bb44SAlexey Dobriyan .llseek = generic_file_llseek, 380c2c0bb44SAlexey Dobriyan }; 381c2c0bb44SAlexey Dobriyan 3821da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 3831da177e4SLinus Torvalds /* 3841da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 3851da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 3861da177e4SLinus Torvalds */ 387edfcd606SAlexey Dobriyan static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns, 388edfcd606SAlexey Dobriyan struct pid *pid, struct task_struct *task) 3891da177e4SLinus Torvalds { 390ffb45122SAlexey Dobriyan unsigned long wchan; 3919281aceaSTejun Heo char symname[KSYM_NAME_LEN]; 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds wchan = get_wchan(task); 3941da177e4SLinus Torvalds 395caaee623SJann Horn if (wchan && ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS) 396caaee623SJann Horn && !lookup_symbol_name(wchan, symname)) 39725ce3191SJoe Perches seq_printf(m, "%s", symname); 398b2f73922SIngo Molnar else 3991e92a61cSRobin Humble seq_putc(m, '0'); 40025ce3191SJoe Perches 40125ce3191SJoe Perches return 0; 4021da177e4SLinus Torvalds } 4031da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 4041da177e4SLinus Torvalds 405a9712bc1SAl Viro static int lock_trace(struct task_struct *task) 406a9712bc1SAl Viro { 407a9712bc1SAl Viro int err = mutex_lock_killable(&task->signal->cred_guard_mutex); 408a9712bc1SAl Viro if (err) 409a9712bc1SAl Viro return err; 410caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) { 411a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 412a9712bc1SAl Viro return -EPERM; 413a9712bc1SAl Viro } 414a9712bc1SAl Viro return 0; 415a9712bc1SAl Viro } 416a9712bc1SAl Viro 417a9712bc1SAl Viro static void unlock_trace(struct task_struct *task) 418a9712bc1SAl Viro { 419a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 420a9712bc1SAl Viro } 421a9712bc1SAl Viro 4222ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 4232ec220e2SKen Chen 4242ec220e2SKen Chen #define MAX_STACK_TRACE_DEPTH 64 4252ec220e2SKen Chen 4262ec220e2SKen Chen static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns, 4272ec220e2SKen Chen struct pid *pid, struct task_struct *task) 4282ec220e2SKen Chen { 4292ec220e2SKen Chen struct stack_trace trace; 4302ec220e2SKen Chen unsigned long *entries; 431a9712bc1SAl Viro int err; 4322ec220e2SKen Chen int i; 4332ec220e2SKen Chen 4342ec220e2SKen Chen entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL); 4352ec220e2SKen Chen if (!entries) 4362ec220e2SKen Chen return -ENOMEM; 4372ec220e2SKen Chen 4382ec220e2SKen Chen trace.nr_entries = 0; 4392ec220e2SKen Chen trace.max_entries = MAX_STACK_TRACE_DEPTH; 4402ec220e2SKen Chen trace.entries = entries; 4412ec220e2SKen Chen trace.skip = 0; 442a9712bc1SAl Viro 443a9712bc1SAl Viro err = lock_trace(task); 444a9712bc1SAl Viro if (!err) { 4452ec220e2SKen Chen save_stack_trace_tsk(task, &trace); 4462ec220e2SKen Chen 4472ec220e2SKen Chen for (i = 0; i < trace.nr_entries; i++) { 4488f5abe84SLinus Torvalds seq_printf(m, "[<0>] %pB\n", (void *)entries[i]); 4492ec220e2SKen Chen } 450a9712bc1SAl Viro unlock_trace(task); 451a9712bc1SAl Viro } 4522ec220e2SKen Chen kfree(entries); 4532ec220e2SKen Chen 454a9712bc1SAl Viro return err; 4552ec220e2SKen Chen } 4562ec220e2SKen Chen #endif 4572ec220e2SKen Chen 4585968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 4591da177e4SLinus Torvalds /* 4601da177e4SLinus Torvalds * Provides /proc/PID/schedstat 4611da177e4SLinus Torvalds */ 462f6e826caSAlexey Dobriyan static int proc_pid_schedstat(struct seq_file *m, struct pid_namespace *ns, 463f6e826caSAlexey Dobriyan struct pid *pid, struct task_struct *task) 4641da177e4SLinus Torvalds { 4655968ceceSNaveen N. Rao if (unlikely(!sched_info_on())) 4665968ceceSNaveen N. Rao seq_printf(m, "0 0 0\n"); 4675968ceceSNaveen N. Rao else 46825ce3191SJoe Perches seq_printf(m, "%llu %llu %lu\n", 469826e08b0SIngo Molnar (unsigned long long)task->se.sum_exec_runtime, 470826e08b0SIngo Molnar (unsigned long long)task->sched_info.run_delay, 4712d72376bSIngo Molnar task->sched_info.pcount); 47225ce3191SJoe Perches 47325ce3191SJoe Perches return 0; 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds #endif 4761da177e4SLinus Torvalds 4779745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 4789745512cSArjan van de Ven static int lstats_show_proc(struct seq_file *m, void *v) 4799745512cSArjan van de Ven { 4809745512cSArjan van de Ven int i; 48113d77c37SHiroshi Shimamoto struct inode *inode = m->private; 48213d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(inode); 4839745512cSArjan van de Ven 48413d77c37SHiroshi Shimamoto if (!task) 48513d77c37SHiroshi Shimamoto return -ESRCH; 48613d77c37SHiroshi Shimamoto seq_puts(m, "Latency Top version : v0.1\n"); 4879745512cSArjan van de Ven for (i = 0; i < 32; i++) { 48834e49d4fSJoe Perches struct latency_record *lr = &task->latency_record[i]; 48934e49d4fSJoe Perches if (lr->backtrace[0]) { 4909745512cSArjan van de Ven int q; 4919745512cSArjan van de Ven seq_printf(m, "%i %li %li", 49234e49d4fSJoe Perches lr->count, lr->time, lr->max); 4939745512cSArjan van de Ven for (q = 0; q < LT_BACKTRACEDEPTH; q++) { 49434e49d4fSJoe Perches unsigned long bt = lr->backtrace[q]; 49534e49d4fSJoe Perches if (!bt) 4969745512cSArjan van de Ven break; 49734e49d4fSJoe Perches if (bt == ULONG_MAX) 4989745512cSArjan van de Ven break; 49934e49d4fSJoe Perches seq_printf(m, " %ps", (void *)bt); 5009745512cSArjan van de Ven } 5019d6de12fSAlexey Dobriyan seq_putc(m, '\n'); 5029745512cSArjan van de Ven } 5039745512cSArjan van de Ven 5049745512cSArjan van de Ven } 50513d77c37SHiroshi Shimamoto put_task_struct(task); 5069745512cSArjan van de Ven return 0; 5079745512cSArjan van de Ven } 5089745512cSArjan van de Ven 5099745512cSArjan van de Ven static int lstats_open(struct inode *inode, struct file *file) 5109745512cSArjan van de Ven { 51113d77c37SHiroshi Shimamoto return single_open(file, lstats_show_proc, inode); 512d6643d12SHiroshi Shimamoto } 513d6643d12SHiroshi Shimamoto 5149745512cSArjan van de Ven static ssize_t lstats_write(struct file *file, const char __user *buf, 5159745512cSArjan van de Ven size_t count, loff_t *offs) 5169745512cSArjan van de Ven { 517496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 5189745512cSArjan van de Ven 51913d77c37SHiroshi Shimamoto if (!task) 52013d77c37SHiroshi Shimamoto return -ESRCH; 5219745512cSArjan van de Ven clear_all_latency_tracing(task); 52213d77c37SHiroshi Shimamoto put_task_struct(task); 5239745512cSArjan van de Ven 5249745512cSArjan van de Ven return count; 5259745512cSArjan van de Ven } 5269745512cSArjan van de Ven 5279745512cSArjan van de Ven static const struct file_operations proc_lstats_operations = { 5289745512cSArjan van de Ven .open = lstats_open, 5299745512cSArjan van de Ven .read = seq_read, 5309745512cSArjan van de Ven .write = lstats_write, 5319745512cSArjan van de Ven .llseek = seq_lseek, 53213d77c37SHiroshi Shimamoto .release = single_release, 5339745512cSArjan van de Ven }; 5349745512cSArjan van de Ven 5359745512cSArjan van de Ven #endif 5369745512cSArjan van de Ven 5376ba51e37SAlexey Dobriyan static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns, 5386ba51e37SAlexey Dobriyan struct pid *pid, struct task_struct *task) 5391da177e4SLinus Torvalds { 540a7f638f9SDavid Rientjes unsigned long totalpages = totalram_pages + total_swap_pages; 541b95c35e7SOleg Nesterov unsigned long points = 0; 5421da177e4SLinus Torvalds 543a7f638f9SDavid Rientjes points = oom_badness(task, NULL, NULL, totalpages) * 544a7f638f9SDavid Rientjes 1000 / totalpages; 54525ce3191SJoe Perches seq_printf(m, "%lu\n", points); 54625ce3191SJoe Perches 54725ce3191SJoe Perches return 0; 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds 550d85f50d5SNeil Horman struct limit_names { 551cedbccabSAlexey Dobriyan const char *name; 552cedbccabSAlexey Dobriyan const char *unit; 553d85f50d5SNeil Horman }; 554d85f50d5SNeil Horman 555d85f50d5SNeil Horman static const struct limit_names lnames[RLIM_NLIMITS] = { 556cff4edb5SKees Cook [RLIMIT_CPU] = {"Max cpu time", "seconds"}, 557d85f50d5SNeil Horman [RLIMIT_FSIZE] = {"Max file size", "bytes"}, 558d85f50d5SNeil Horman [RLIMIT_DATA] = {"Max data size", "bytes"}, 559d85f50d5SNeil Horman [RLIMIT_STACK] = {"Max stack size", "bytes"}, 560d85f50d5SNeil Horman [RLIMIT_CORE] = {"Max core file size", "bytes"}, 561d85f50d5SNeil Horman [RLIMIT_RSS] = {"Max resident set", "bytes"}, 562d85f50d5SNeil Horman [RLIMIT_NPROC] = {"Max processes", "processes"}, 563d85f50d5SNeil Horman [RLIMIT_NOFILE] = {"Max open files", "files"}, 564d85f50d5SNeil Horman [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"}, 565d85f50d5SNeil Horman [RLIMIT_AS] = {"Max address space", "bytes"}, 566d85f50d5SNeil Horman [RLIMIT_LOCKS] = {"Max file locks", "locks"}, 567d85f50d5SNeil Horman [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"}, 568d85f50d5SNeil Horman [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"}, 569d85f50d5SNeil Horman [RLIMIT_NICE] = {"Max nice priority", NULL}, 570d85f50d5SNeil Horman [RLIMIT_RTPRIO] = {"Max realtime priority", NULL}, 5718808117cSEugene Teo [RLIMIT_RTTIME] = {"Max realtime timeout", "us"}, 572d85f50d5SNeil Horman }; 573d85f50d5SNeil Horman 574d85f50d5SNeil Horman /* Display limits for a process */ 5751c963eb1SAlexey Dobriyan static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns, 5761c963eb1SAlexey Dobriyan struct pid *pid, struct task_struct *task) 577d85f50d5SNeil Horman { 578d85f50d5SNeil Horman unsigned int i; 579d85f50d5SNeil Horman unsigned long flags; 580d85f50d5SNeil Horman 581d85f50d5SNeil Horman struct rlimit rlim[RLIM_NLIMITS]; 582d85f50d5SNeil Horman 583a6bebbc8SLai Jiangshan if (!lock_task_sighand(task, &flags)) 584d85f50d5SNeil Horman return 0; 585d85f50d5SNeil Horman memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS); 586d85f50d5SNeil Horman unlock_task_sighand(task, &flags); 587d85f50d5SNeil Horman 588d85f50d5SNeil Horman /* 589d85f50d5SNeil Horman * print the file header 590d85f50d5SNeil Horman */ 5911c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s %-20s %-10s\n", 592d85f50d5SNeil Horman "Limit", "Soft Limit", "Hard Limit", "Units"); 593d85f50d5SNeil Horman 594d85f50d5SNeil Horman for (i = 0; i < RLIM_NLIMITS; i++) { 595d85f50d5SNeil Horman if (rlim[i].rlim_cur == RLIM_INFINITY) 5961c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s ", 597d85f50d5SNeil Horman lnames[i].name, "unlimited"); 598d85f50d5SNeil Horman else 5991c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20lu ", 600d85f50d5SNeil Horman lnames[i].name, rlim[i].rlim_cur); 601d85f50d5SNeil Horman 602d85f50d5SNeil Horman if (rlim[i].rlim_max == RLIM_INFINITY) 6031c963eb1SAlexey Dobriyan seq_printf(m, "%-20s ", "unlimited"); 604d85f50d5SNeil Horman else 6051c963eb1SAlexey Dobriyan seq_printf(m, "%-20lu ", rlim[i].rlim_max); 606d85f50d5SNeil Horman 607d85f50d5SNeil Horman if (lnames[i].unit) 6081c963eb1SAlexey Dobriyan seq_printf(m, "%-10s\n", lnames[i].unit); 609d85f50d5SNeil Horman else 6101c963eb1SAlexey Dobriyan seq_putc(m, '\n'); 611d85f50d5SNeil Horman } 612d85f50d5SNeil Horman 6131c963eb1SAlexey Dobriyan return 0; 614d85f50d5SNeil Horman } 615d85f50d5SNeil Horman 616ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 61709d93bd6SAlexey Dobriyan static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns, 61809d93bd6SAlexey Dobriyan struct pid *pid, struct task_struct *task) 619ebcb6734SRoland McGrath { 620ebcb6734SRoland McGrath long nr; 621ebcb6734SRoland McGrath unsigned long args[6], sp, pc; 62225ce3191SJoe Perches int res; 62325ce3191SJoe Perches 62425ce3191SJoe Perches res = lock_trace(task); 625a9712bc1SAl Viro if (res) 626a9712bc1SAl Viro return res; 627ebcb6734SRoland McGrath 628ebcb6734SRoland McGrath if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) 62909d93bd6SAlexey Dobriyan seq_puts(m, "running\n"); 630a9712bc1SAl Viro else if (nr < 0) 63109d93bd6SAlexey Dobriyan seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc); 632a9712bc1SAl Viro else 63309d93bd6SAlexey Dobriyan seq_printf(m, 634ebcb6734SRoland McGrath "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 635ebcb6734SRoland McGrath nr, 636ebcb6734SRoland McGrath args[0], args[1], args[2], args[3], args[4], args[5], 637ebcb6734SRoland McGrath sp, pc); 638a9712bc1SAl Viro unlock_trace(task); 63925ce3191SJoe Perches 64025ce3191SJoe Perches return 0; 641ebcb6734SRoland McGrath } 642ebcb6734SRoland McGrath #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */ 643ebcb6734SRoland McGrath 6441da177e4SLinus Torvalds /************************************************************************/ 6451da177e4SLinus Torvalds /* Here the fs part begins */ 6461da177e4SLinus Torvalds /************************************************************************/ 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds /* permission checks */ 649778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 6501da177e4SLinus Torvalds { 651778c1144SEric W. Biederman struct task_struct *task; 652778c1144SEric W. Biederman int allowed = 0; 653df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 654df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 655df26c40eSEric W. Biederman * information. 656778c1144SEric W. Biederman */ 657778c1144SEric W. Biederman task = get_proc_task(inode); 658df26c40eSEric W. Biederman if (task) { 659caaee623SJann Horn allowed = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS); 660778c1144SEric W. Biederman put_task_struct(task); 661df26c40eSEric W. Biederman } 662778c1144SEric W. Biederman return allowed; 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds 6656b4e306aSEric W. Biederman int proc_setattr(struct dentry *dentry, struct iattr *attr) 6666d76fa58SLinus Torvalds { 6676d76fa58SLinus Torvalds int error; 6682b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 6696d76fa58SLinus Torvalds 6706d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 6716d76fa58SLinus Torvalds return -EPERM; 6726d76fa58SLinus Torvalds 67331051c85SJan Kara error = setattr_prepare(dentry, attr); 6741025774cSChristoph Hellwig if (error) 6756d76fa58SLinus Torvalds return error; 6761025774cSChristoph Hellwig 6771025774cSChristoph Hellwig setattr_copy(inode, attr); 6781025774cSChristoph Hellwig mark_inode_dirty(inode); 6791025774cSChristoph Hellwig return 0; 6806d76fa58SLinus Torvalds } 6816d76fa58SLinus Torvalds 6820499680aSVasiliy Kulikov /* 6830499680aSVasiliy Kulikov * May current process learn task's sched/cmdline info (for hide_pid_min=1) 6840499680aSVasiliy Kulikov * or euid/egid (for hide_pid_min=2)? 6850499680aSVasiliy Kulikov */ 6860499680aSVasiliy Kulikov static bool has_pid_permissions(struct pid_namespace *pid, 6870499680aSVasiliy Kulikov struct task_struct *task, 6880499680aSVasiliy Kulikov int hide_pid_min) 6890499680aSVasiliy Kulikov { 6900499680aSVasiliy Kulikov if (pid->hide_pid < hide_pid_min) 6910499680aSVasiliy Kulikov return true; 6920499680aSVasiliy Kulikov if (in_group_p(pid->pid_gid)) 6930499680aSVasiliy Kulikov return true; 694caaee623SJann Horn return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS); 6950499680aSVasiliy Kulikov } 6960499680aSVasiliy Kulikov 6970499680aSVasiliy Kulikov 6980499680aSVasiliy Kulikov static int proc_pid_permission(struct inode *inode, int mask) 6990499680aSVasiliy Kulikov { 7000499680aSVasiliy Kulikov struct pid_namespace *pid = inode->i_sb->s_fs_info; 7010499680aSVasiliy Kulikov struct task_struct *task; 7020499680aSVasiliy Kulikov bool has_perms; 7030499680aSVasiliy Kulikov 7040499680aSVasiliy Kulikov task = get_proc_task(inode); 705a2ef990aSXiaotian Feng if (!task) 706a2ef990aSXiaotian Feng return -ESRCH; 707796f571bSLafcadio Wluiki has_perms = has_pid_permissions(pid, task, HIDEPID_NO_ACCESS); 7080499680aSVasiliy Kulikov put_task_struct(task); 7090499680aSVasiliy Kulikov 7100499680aSVasiliy Kulikov if (!has_perms) { 711796f571bSLafcadio Wluiki if (pid->hide_pid == HIDEPID_INVISIBLE) { 7120499680aSVasiliy Kulikov /* 7130499680aSVasiliy Kulikov * Let's make getdents(), stat(), and open() 7140499680aSVasiliy Kulikov * consistent with each other. If a process 7150499680aSVasiliy Kulikov * may not stat() a file, it shouldn't be seen 7160499680aSVasiliy Kulikov * in procfs at all. 7170499680aSVasiliy Kulikov */ 7180499680aSVasiliy Kulikov return -ENOENT; 7190499680aSVasiliy Kulikov } 7200499680aSVasiliy Kulikov 7210499680aSVasiliy Kulikov return -EPERM; 7220499680aSVasiliy Kulikov } 7230499680aSVasiliy Kulikov return generic_permission(inode, mask); 7240499680aSVasiliy Kulikov } 7250499680aSVasiliy Kulikov 7260499680aSVasiliy Kulikov 7270499680aSVasiliy Kulikov 728c5ef1c42SArjan van de Ven static const struct inode_operations proc_def_inode_operations = { 7296d76fa58SLinus Torvalds .setattr = proc_setattr, 7306d76fa58SLinus Torvalds }; 7316d76fa58SLinus Torvalds 732be614086SEric W. Biederman static int proc_single_show(struct seq_file *m, void *v) 733be614086SEric W. Biederman { 734be614086SEric W. Biederman struct inode *inode = m->private; 735be614086SEric W. Biederman struct pid_namespace *ns; 736be614086SEric W. Biederman struct pid *pid; 737be614086SEric W. Biederman struct task_struct *task; 738be614086SEric W. Biederman int ret; 739be614086SEric W. Biederman 740be614086SEric W. Biederman ns = inode->i_sb->s_fs_info; 741be614086SEric W. Biederman pid = proc_pid(inode); 742be614086SEric W. Biederman task = get_pid_task(pid, PIDTYPE_PID); 743be614086SEric W. Biederman if (!task) 744be614086SEric W. Biederman return -ESRCH; 745be614086SEric W. Biederman 746be614086SEric W. Biederman ret = PROC_I(inode)->op.proc_show(m, ns, pid, task); 747be614086SEric W. Biederman 748be614086SEric W. Biederman put_task_struct(task); 749be614086SEric W. Biederman return ret; 750be614086SEric W. Biederman } 751be614086SEric W. Biederman 752be614086SEric W. Biederman static int proc_single_open(struct inode *inode, struct file *filp) 753be614086SEric W. Biederman { 754c6a34058SJovi Zhang return single_open(filp, proc_single_show, inode); 755be614086SEric W. Biederman } 756be614086SEric W. Biederman 757be614086SEric W. Biederman static const struct file_operations proc_single_file_operations = { 758be614086SEric W. Biederman .open = proc_single_open, 759be614086SEric W. Biederman .read = seq_read, 760be614086SEric W. Biederman .llseek = seq_lseek, 761be614086SEric W. Biederman .release = single_release, 762be614086SEric W. Biederman }; 763be614086SEric W. Biederman 7645381e169SOleg Nesterov 7655381e169SOleg Nesterov struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode) 7661da177e4SLinus Torvalds { 7675381e169SOleg Nesterov struct task_struct *task = get_proc_task(inode); 7685381e169SOleg Nesterov struct mm_struct *mm = ERR_PTR(-ESRCH); 769e268337dSLinus Torvalds 7705381e169SOleg Nesterov if (task) { 771caaee623SJann Horn mm = mm_access(task, mode | PTRACE_MODE_FSCREDS); 772e268337dSLinus Torvalds put_task_struct(task); 773e268337dSLinus Torvalds 7745381e169SOleg Nesterov if (!IS_ERR_OR_NULL(mm)) { 7756d08f2c7SOleg Nesterov /* ensure this mm_struct can't be freed */ 776f1f10076SVegard Nossum mmgrab(mm); 7776d08f2c7SOleg Nesterov /* but do not pin its memory */ 7786d08f2c7SOleg Nesterov mmput(mm); 7796d08f2c7SOleg Nesterov } 7805381e169SOleg Nesterov } 7815381e169SOleg Nesterov 7825381e169SOleg Nesterov return mm; 7835381e169SOleg Nesterov } 7845381e169SOleg Nesterov 7855381e169SOleg Nesterov static int __mem_open(struct inode *inode, struct file *file, unsigned int mode) 7865381e169SOleg Nesterov { 7875381e169SOleg Nesterov struct mm_struct *mm = proc_mem_open(inode, mode); 7885381e169SOleg Nesterov 7895381e169SOleg Nesterov if (IS_ERR(mm)) 7905381e169SOleg Nesterov return PTR_ERR(mm); 7916d08f2c7SOleg Nesterov 792e268337dSLinus Torvalds file->private_data = mm; 7931da177e4SLinus Torvalds return 0; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 796b409e578SCong Wang static int mem_open(struct inode *inode, struct file *file) 797b409e578SCong Wang { 798bc452b4bSDjalal Harouni int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH); 799bc452b4bSDjalal Harouni 800bc452b4bSDjalal Harouni /* OK to pass negative loff_t, we can catch out-of-range */ 801bc452b4bSDjalal Harouni file->f_mode |= FMODE_UNSIGNED_OFFSET; 802bc452b4bSDjalal Harouni 803bc452b4bSDjalal Harouni return ret; 804b409e578SCong Wang } 805b409e578SCong Wang 806572d34b9SOleg Nesterov static ssize_t mem_rw(struct file *file, char __user *buf, 807572d34b9SOleg Nesterov size_t count, loff_t *ppos, int write) 8081da177e4SLinus Torvalds { 809e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 810572d34b9SOleg Nesterov unsigned long addr = *ppos; 811572d34b9SOleg Nesterov ssize_t copied; 8121da177e4SLinus Torvalds char *page; 813272ddc8bSLinus Torvalds unsigned int flags; 8141da177e4SLinus Torvalds 815e268337dSLinus Torvalds if (!mm) 816e268337dSLinus Torvalds return 0; 8171da177e4SLinus Torvalds 8180ee931c4SMichal Hocko page = (char *)__get_free_page(GFP_KERNEL); 8191da177e4SLinus Torvalds if (!page) 820e268337dSLinus Torvalds return -ENOMEM; 8211da177e4SLinus Torvalds 822f7ca54f4SFrederik Deweerdt copied = 0; 823388f7934SVegard Nossum if (!mmget_not_zero(mm)) 8246d08f2c7SOleg Nesterov goto free; 8256d08f2c7SOleg Nesterov 826f511c0b1SLinus Torvalds flags = FOLL_FORCE | (write ? FOLL_WRITE : 0); 8276347e8d5SLorenzo Stoakes 8281da177e4SLinus Torvalds while (count > 0) { 829572d34b9SOleg Nesterov int this_len = min_t(int, count, PAGE_SIZE); 8301da177e4SLinus Torvalds 831572d34b9SOleg Nesterov if (write && copy_from_user(page, buf, this_len)) { 8321da177e4SLinus Torvalds copied = -EFAULT; 8331da177e4SLinus Torvalds break; 8341da177e4SLinus Torvalds } 835572d34b9SOleg Nesterov 8366347e8d5SLorenzo Stoakes this_len = access_remote_vm(mm, addr, page, this_len, flags); 837572d34b9SOleg Nesterov if (!this_len) { 8381da177e4SLinus Torvalds if (!copied) 8391da177e4SLinus Torvalds copied = -EIO; 8401da177e4SLinus Torvalds break; 8411da177e4SLinus Torvalds } 842572d34b9SOleg Nesterov 843572d34b9SOleg Nesterov if (!write && copy_to_user(buf, page, this_len)) { 844572d34b9SOleg Nesterov copied = -EFAULT; 845572d34b9SOleg Nesterov break; 8461da177e4SLinus Torvalds } 847572d34b9SOleg Nesterov 848572d34b9SOleg Nesterov buf += this_len; 849572d34b9SOleg Nesterov addr += this_len; 850572d34b9SOleg Nesterov copied += this_len; 851572d34b9SOleg Nesterov count -= this_len; 852572d34b9SOleg Nesterov } 853572d34b9SOleg Nesterov *ppos = addr; 85430cd8903SKOSAKI Motohiro 8556d08f2c7SOleg Nesterov mmput(mm); 8566d08f2c7SOleg Nesterov free: 85730cd8903SKOSAKI Motohiro free_page((unsigned long) page); 8581da177e4SLinus Torvalds return copied; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 861572d34b9SOleg Nesterov static ssize_t mem_read(struct file *file, char __user *buf, 862572d34b9SOleg Nesterov size_t count, loff_t *ppos) 863572d34b9SOleg Nesterov { 864572d34b9SOleg Nesterov return mem_rw(file, buf, count, ppos, 0); 865572d34b9SOleg Nesterov } 866572d34b9SOleg Nesterov 867572d34b9SOleg Nesterov static ssize_t mem_write(struct file *file, const char __user *buf, 868572d34b9SOleg Nesterov size_t count, loff_t *ppos) 869572d34b9SOleg Nesterov { 870572d34b9SOleg Nesterov return mem_rw(file, (char __user*)buf, count, ppos, 1); 871572d34b9SOleg Nesterov } 872572d34b9SOleg Nesterov 87385863e47SMatt Mackall loff_t mem_lseek(struct file *file, loff_t offset, int orig) 8741da177e4SLinus Torvalds { 8751da177e4SLinus Torvalds switch (orig) { 8761da177e4SLinus Torvalds case 0: 8771da177e4SLinus Torvalds file->f_pos = offset; 8781da177e4SLinus Torvalds break; 8791da177e4SLinus Torvalds case 1: 8801da177e4SLinus Torvalds file->f_pos += offset; 8811da177e4SLinus Torvalds break; 8821da177e4SLinus Torvalds default: 8831da177e4SLinus Torvalds return -EINVAL; 8841da177e4SLinus Torvalds } 8851da177e4SLinus Torvalds force_successful_syscall_return(); 8861da177e4SLinus Torvalds return file->f_pos; 8871da177e4SLinus Torvalds } 8881da177e4SLinus Torvalds 889e268337dSLinus Torvalds static int mem_release(struct inode *inode, struct file *file) 890e268337dSLinus Torvalds { 891e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 89271879d3cSOleg Nesterov if (mm) 8936d08f2c7SOleg Nesterov mmdrop(mm); 894e268337dSLinus Torvalds return 0; 895e268337dSLinus Torvalds } 896e268337dSLinus Torvalds 89700977a59SArjan van de Ven static const struct file_operations proc_mem_operations = { 8981da177e4SLinus Torvalds .llseek = mem_lseek, 8991da177e4SLinus Torvalds .read = mem_read, 9001da177e4SLinus Torvalds .write = mem_write, 9011da177e4SLinus Torvalds .open = mem_open, 902e268337dSLinus Torvalds .release = mem_release, 9031da177e4SLinus Torvalds }; 9041da177e4SLinus Torvalds 905b409e578SCong Wang static int environ_open(struct inode *inode, struct file *file) 906b409e578SCong Wang { 907b409e578SCong Wang return __mem_open(inode, file, PTRACE_MODE_READ); 908b409e578SCong Wang } 909b409e578SCong Wang 910315e28c8SJames Pearson static ssize_t environ_read(struct file *file, char __user *buf, 911315e28c8SJames Pearson size_t count, loff_t *ppos) 912315e28c8SJames Pearson { 913315e28c8SJames Pearson char *page; 914315e28c8SJames Pearson unsigned long src = *ppos; 915b409e578SCong Wang int ret = 0; 916b409e578SCong Wang struct mm_struct *mm = file->private_data; 917a3b609efSMateusz Guzik unsigned long env_start, env_end; 918315e28c8SJames Pearson 9198148a73cSMathias Krause /* Ensure the process spawned far enough to have an environment. */ 9208148a73cSMathias Krause if (!mm || !mm->env_end) 921b409e578SCong Wang return 0; 922315e28c8SJames Pearson 9230ee931c4SMichal Hocko page = (char *)__get_free_page(GFP_KERNEL); 924315e28c8SJames Pearson if (!page) 925b409e578SCong Wang return -ENOMEM; 926315e28c8SJames Pearson 927d6f64b89SAl Viro ret = 0; 928388f7934SVegard Nossum if (!mmget_not_zero(mm)) 929b409e578SCong Wang goto free; 930a3b609efSMateusz Guzik 931a3b609efSMateusz Guzik down_read(&mm->mmap_sem); 932a3b609efSMateusz Guzik env_start = mm->env_start; 933a3b609efSMateusz Guzik env_end = mm->env_end; 934a3b609efSMateusz Guzik up_read(&mm->mmap_sem); 935a3b609efSMateusz Guzik 936315e28c8SJames Pearson while (count > 0) { 937e8905ec2SDjalal Harouni size_t this_len, max_len; 938e8905ec2SDjalal Harouni int retval; 939e8905ec2SDjalal Harouni 940a3b609efSMateusz Guzik if (src >= (env_end - env_start)) 941e8905ec2SDjalal Harouni break; 942315e28c8SJames Pearson 943a3b609efSMateusz Guzik this_len = env_end - (env_start + src); 944315e28c8SJames Pearson 945e8905ec2SDjalal Harouni max_len = min_t(size_t, PAGE_SIZE, count); 946e8905ec2SDjalal Harouni this_len = min(max_len, this_len); 947315e28c8SJames Pearson 948272ddc8bSLinus Torvalds retval = access_remote_vm(mm, (env_start + src), page, this_len, 0); 949315e28c8SJames Pearson 950315e28c8SJames Pearson if (retval <= 0) { 951315e28c8SJames Pearson ret = retval; 952315e28c8SJames Pearson break; 953315e28c8SJames Pearson } 954315e28c8SJames Pearson 955315e28c8SJames Pearson if (copy_to_user(buf, page, retval)) { 956315e28c8SJames Pearson ret = -EFAULT; 957315e28c8SJames Pearson break; 958315e28c8SJames Pearson } 959315e28c8SJames Pearson 960315e28c8SJames Pearson ret += retval; 961315e28c8SJames Pearson src += retval; 962315e28c8SJames Pearson buf += retval; 963315e28c8SJames Pearson count -= retval; 964315e28c8SJames Pearson } 965315e28c8SJames Pearson *ppos = src; 966315e28c8SJames Pearson mmput(mm); 967b409e578SCong Wang 968b409e578SCong Wang free: 969315e28c8SJames Pearson free_page((unsigned long) page); 970315e28c8SJames Pearson return ret; 971315e28c8SJames Pearson } 972315e28c8SJames Pearson 973315e28c8SJames Pearson static const struct file_operations proc_environ_operations = { 974b409e578SCong Wang .open = environ_open, 975315e28c8SJames Pearson .read = environ_read, 97687df8424SArnd Bergmann .llseek = generic_file_llseek, 977b409e578SCong Wang .release = mem_release, 978315e28c8SJames Pearson }; 979315e28c8SJames Pearson 980c5317167SAl Viro static int auxv_open(struct inode *inode, struct file *file) 981c5317167SAl Viro { 982c5317167SAl Viro return __mem_open(inode, file, PTRACE_MODE_READ_FSCREDS); 983c5317167SAl Viro } 984c5317167SAl Viro 985c5317167SAl Viro static ssize_t auxv_read(struct file *file, char __user *buf, 986c5317167SAl Viro size_t count, loff_t *ppos) 987c5317167SAl Viro { 988c5317167SAl Viro struct mm_struct *mm = file->private_data; 989c5317167SAl Viro unsigned int nwords = 0; 99006b2849dSLeon Yu 99106b2849dSLeon Yu if (!mm) 99206b2849dSLeon Yu return 0; 993c5317167SAl Viro do { 994c5317167SAl Viro nwords += 2; 995c5317167SAl Viro } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 996c5317167SAl Viro return simple_read_from_buffer(buf, count, ppos, mm->saved_auxv, 997c5317167SAl Viro nwords * sizeof(mm->saved_auxv[0])); 998c5317167SAl Viro } 999c5317167SAl Viro 1000c5317167SAl Viro static const struct file_operations proc_auxv_operations = { 1001c5317167SAl Viro .open = auxv_open, 1002c5317167SAl Viro .read = auxv_read, 1003c5317167SAl Viro .llseek = generic_file_llseek, 1004c5317167SAl Viro .release = mem_release, 1005c5317167SAl Viro }; 1006c5317167SAl Viro 1007fa0cbbf1SDavid Rientjes static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count, 1008fa0cbbf1SDavid Rientjes loff_t *ppos) 1009fa0cbbf1SDavid Rientjes { 1010496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1011fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 1012fa0cbbf1SDavid Rientjes int oom_adj = OOM_ADJUST_MIN; 1013fa0cbbf1SDavid Rientjes size_t len; 1014fa0cbbf1SDavid Rientjes 1015fa0cbbf1SDavid Rientjes if (!task) 1016fa0cbbf1SDavid Rientjes return -ESRCH; 1017fa0cbbf1SDavid Rientjes if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX) 1018fa0cbbf1SDavid Rientjes oom_adj = OOM_ADJUST_MAX; 1019fa0cbbf1SDavid Rientjes else 1020fa0cbbf1SDavid Rientjes oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) / 1021fa0cbbf1SDavid Rientjes OOM_SCORE_ADJ_MAX; 1022fa0cbbf1SDavid Rientjes put_task_struct(task); 1023fa0cbbf1SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj); 1024fa0cbbf1SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1025fa0cbbf1SDavid Rientjes } 1026fa0cbbf1SDavid Rientjes 10271d5f0acbSMichal Hocko static int __set_oom_adj(struct file *file, int oom_adj, bool legacy) 10281d5f0acbSMichal Hocko { 1029f913da59SMichal Hocko static DEFINE_MUTEX(oom_adj_mutex); 103044a70adeSMichal Hocko struct mm_struct *mm = NULL; 10311d5f0acbSMichal Hocko struct task_struct *task; 10321d5f0acbSMichal Hocko int err = 0; 10331d5f0acbSMichal Hocko 10341d5f0acbSMichal Hocko task = get_proc_task(file_inode(file)); 10351d5f0acbSMichal Hocko if (!task) 10361d5f0acbSMichal Hocko return -ESRCH; 10371d5f0acbSMichal Hocko 10381d5f0acbSMichal Hocko mutex_lock(&oom_adj_mutex); 10391d5f0acbSMichal Hocko if (legacy) { 10401d5f0acbSMichal Hocko if (oom_adj < task->signal->oom_score_adj && 10411d5f0acbSMichal Hocko !capable(CAP_SYS_RESOURCE)) { 10421d5f0acbSMichal Hocko err = -EACCES; 10431d5f0acbSMichal Hocko goto err_unlock; 10441d5f0acbSMichal Hocko } 10451d5f0acbSMichal Hocko /* 10461d5f0acbSMichal Hocko * /proc/pid/oom_adj is provided for legacy purposes, ask users to use 10471d5f0acbSMichal Hocko * /proc/pid/oom_score_adj instead. 10481d5f0acbSMichal Hocko */ 10491d5f0acbSMichal Hocko pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n", 10501d5f0acbSMichal Hocko current->comm, task_pid_nr(current), task_pid_nr(task), 10511d5f0acbSMichal Hocko task_pid_nr(task)); 10521d5f0acbSMichal Hocko } else { 10531d5f0acbSMichal Hocko if ((short)oom_adj < task->signal->oom_score_adj_min && 10541d5f0acbSMichal Hocko !capable(CAP_SYS_RESOURCE)) { 10551d5f0acbSMichal Hocko err = -EACCES; 10561d5f0acbSMichal Hocko goto err_unlock; 10571d5f0acbSMichal Hocko } 10581d5f0acbSMichal Hocko } 10591d5f0acbSMichal Hocko 106044a70adeSMichal Hocko /* 106144a70adeSMichal Hocko * Make sure we will check other processes sharing the mm if this is 106244a70adeSMichal Hocko * not vfrok which wants its own oom_score_adj. 106344a70adeSMichal Hocko * pin the mm so it doesn't go away and get reused after task_unlock 106444a70adeSMichal Hocko */ 106544a70adeSMichal Hocko if (!task->vfork_done) { 106644a70adeSMichal Hocko struct task_struct *p = find_lock_task_mm(task); 106744a70adeSMichal Hocko 106844a70adeSMichal Hocko if (p) { 106944a70adeSMichal Hocko if (atomic_read(&p->mm->mm_users) > 1) { 107044a70adeSMichal Hocko mm = p->mm; 1071f1f10076SVegard Nossum mmgrab(mm); 107244a70adeSMichal Hocko } 107344a70adeSMichal Hocko task_unlock(p); 107444a70adeSMichal Hocko } 107544a70adeSMichal Hocko } 107644a70adeSMichal Hocko 10771d5f0acbSMichal Hocko task->signal->oom_score_adj = oom_adj; 10781d5f0acbSMichal Hocko if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE)) 10791d5f0acbSMichal Hocko task->signal->oom_score_adj_min = (short)oom_adj; 10801d5f0acbSMichal Hocko trace_oom_score_adj_update(task); 108144a70adeSMichal Hocko 108244a70adeSMichal Hocko if (mm) { 108344a70adeSMichal Hocko struct task_struct *p; 108444a70adeSMichal Hocko 108544a70adeSMichal Hocko rcu_read_lock(); 108644a70adeSMichal Hocko for_each_process(p) { 108744a70adeSMichal Hocko if (same_thread_group(task, p)) 108844a70adeSMichal Hocko continue; 108944a70adeSMichal Hocko 109044a70adeSMichal Hocko /* do not touch kernel threads or the global init */ 109144a70adeSMichal Hocko if (p->flags & PF_KTHREAD || is_global_init(p)) 109244a70adeSMichal Hocko continue; 109344a70adeSMichal Hocko 109444a70adeSMichal Hocko task_lock(p); 109544a70adeSMichal Hocko if (!p->vfork_done && process_shares_mm(p, mm)) { 109644a70adeSMichal Hocko pr_info("updating oom_score_adj for %d (%s) from %d to %d because it shares mm with %d (%s). Report if this is unexpected.\n", 109744a70adeSMichal Hocko task_pid_nr(p), p->comm, 109844a70adeSMichal Hocko p->signal->oom_score_adj, oom_adj, 109944a70adeSMichal Hocko task_pid_nr(task), task->comm); 110044a70adeSMichal Hocko p->signal->oom_score_adj = oom_adj; 110144a70adeSMichal Hocko if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE)) 110244a70adeSMichal Hocko p->signal->oom_score_adj_min = (short)oom_adj; 110344a70adeSMichal Hocko } 110444a70adeSMichal Hocko task_unlock(p); 110544a70adeSMichal Hocko } 110644a70adeSMichal Hocko rcu_read_unlock(); 110744a70adeSMichal Hocko mmdrop(mm); 110844a70adeSMichal Hocko } 11091d5f0acbSMichal Hocko err_unlock: 11101d5f0acbSMichal Hocko mutex_unlock(&oom_adj_mutex); 11111d5f0acbSMichal Hocko put_task_struct(task); 11121d5f0acbSMichal Hocko return err; 11131d5f0acbSMichal Hocko } 1114f913da59SMichal Hocko 1115b72bdfa7SDavid Rientjes /* 1116b72bdfa7SDavid Rientjes * /proc/pid/oom_adj exists solely for backwards compatibility with previous 1117b72bdfa7SDavid Rientjes * kernels. The effective policy is defined by oom_score_adj, which has a 1118b72bdfa7SDavid Rientjes * different scale: oom_adj grew exponentially and oom_score_adj grows linearly. 1119b72bdfa7SDavid Rientjes * Values written to oom_adj are simply mapped linearly to oom_score_adj. 1120b72bdfa7SDavid Rientjes * Processes that become oom disabled via oom_adj will still be oom disabled 1121b72bdfa7SDavid Rientjes * with this implementation. 1122b72bdfa7SDavid Rientjes * 1123b72bdfa7SDavid Rientjes * oom_adj cannot be removed since existing userspace binaries use it. 1124b72bdfa7SDavid Rientjes */ 1125fa0cbbf1SDavid Rientjes static ssize_t oom_adj_write(struct file *file, const char __user *buf, 1126fa0cbbf1SDavid Rientjes size_t count, loff_t *ppos) 1127fa0cbbf1SDavid Rientjes { 1128fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 1129fa0cbbf1SDavid Rientjes int oom_adj; 1130fa0cbbf1SDavid Rientjes int err; 1131fa0cbbf1SDavid Rientjes 1132fa0cbbf1SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1133fa0cbbf1SDavid Rientjes if (count > sizeof(buffer) - 1) 1134fa0cbbf1SDavid Rientjes count = sizeof(buffer) - 1; 1135fa0cbbf1SDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1136fa0cbbf1SDavid Rientjes err = -EFAULT; 1137fa0cbbf1SDavid Rientjes goto out; 1138fa0cbbf1SDavid Rientjes } 1139fa0cbbf1SDavid Rientjes 1140fa0cbbf1SDavid Rientjes err = kstrtoint(strstrip(buffer), 0, &oom_adj); 1141fa0cbbf1SDavid Rientjes if (err) 1142fa0cbbf1SDavid Rientjes goto out; 1143fa0cbbf1SDavid Rientjes if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) && 1144fa0cbbf1SDavid Rientjes oom_adj != OOM_DISABLE) { 1145fa0cbbf1SDavid Rientjes err = -EINVAL; 1146fa0cbbf1SDavid Rientjes goto out; 1147fa0cbbf1SDavid Rientjes } 1148fa0cbbf1SDavid Rientjes 1149fa0cbbf1SDavid Rientjes /* 1150fa0cbbf1SDavid Rientjes * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum 1151fa0cbbf1SDavid Rientjes * value is always attainable. 1152fa0cbbf1SDavid Rientjes */ 1153fa0cbbf1SDavid Rientjes if (oom_adj == OOM_ADJUST_MAX) 1154fa0cbbf1SDavid Rientjes oom_adj = OOM_SCORE_ADJ_MAX; 1155fa0cbbf1SDavid Rientjes else 1156fa0cbbf1SDavid Rientjes oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE; 1157fa0cbbf1SDavid Rientjes 11581d5f0acbSMichal Hocko err = __set_oom_adj(file, oom_adj, true); 1159fa0cbbf1SDavid Rientjes out: 1160fa0cbbf1SDavid Rientjes return err < 0 ? err : count; 1161fa0cbbf1SDavid Rientjes } 1162fa0cbbf1SDavid Rientjes 1163fa0cbbf1SDavid Rientjes static const struct file_operations proc_oom_adj_operations = { 1164fa0cbbf1SDavid Rientjes .read = oom_adj_read, 1165fa0cbbf1SDavid Rientjes .write = oom_adj_write, 1166fa0cbbf1SDavid Rientjes .llseek = generic_file_llseek, 1167fa0cbbf1SDavid Rientjes }; 1168fa0cbbf1SDavid Rientjes 1169a63d83f4SDavid Rientjes static ssize_t oom_score_adj_read(struct file *file, char __user *buf, 1170a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1171a63d83f4SDavid Rientjes { 1172496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1173a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1174a9c58b90SDavid Rientjes short oom_score_adj = OOM_SCORE_ADJ_MIN; 1175a63d83f4SDavid Rientjes size_t len; 1176a63d83f4SDavid Rientjes 1177a63d83f4SDavid Rientjes if (!task) 1178a63d83f4SDavid Rientjes return -ESRCH; 1179a63d83f4SDavid Rientjes oom_score_adj = task->signal->oom_score_adj; 1180a63d83f4SDavid Rientjes put_task_struct(task); 1181a9c58b90SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj); 1182a63d83f4SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1183a63d83f4SDavid Rientjes } 1184a63d83f4SDavid Rientjes 1185a63d83f4SDavid Rientjes static ssize_t oom_score_adj_write(struct file *file, const char __user *buf, 1186a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1187a63d83f4SDavid Rientjes { 1188a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 11890a8cb8e3SAlexey Dobriyan int oom_score_adj; 1190a63d83f4SDavid Rientjes int err; 1191a63d83f4SDavid Rientjes 1192a63d83f4SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1193a63d83f4SDavid Rientjes if (count > sizeof(buffer) - 1) 1194a63d83f4SDavid Rientjes count = sizeof(buffer) - 1; 1195723548bfSDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1196723548bfSDavid Rientjes err = -EFAULT; 1197723548bfSDavid Rientjes goto out; 1198723548bfSDavid Rientjes } 1199a63d83f4SDavid Rientjes 12000a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &oom_score_adj); 1201a63d83f4SDavid Rientjes if (err) 1202723548bfSDavid Rientjes goto out; 1203a63d83f4SDavid Rientjes if (oom_score_adj < OOM_SCORE_ADJ_MIN || 1204723548bfSDavid Rientjes oom_score_adj > OOM_SCORE_ADJ_MAX) { 1205723548bfSDavid Rientjes err = -EINVAL; 1206723548bfSDavid Rientjes goto out; 1207723548bfSDavid Rientjes } 1208a63d83f4SDavid Rientjes 12091d5f0acbSMichal Hocko err = __set_oom_adj(file, oom_score_adj, false); 1210723548bfSDavid Rientjes out: 1211723548bfSDavid Rientjes return err < 0 ? err : count; 1212a63d83f4SDavid Rientjes } 1213a63d83f4SDavid Rientjes 1214a63d83f4SDavid Rientjes static const struct file_operations proc_oom_score_adj_operations = { 1215a63d83f4SDavid Rientjes .read = oom_score_adj_read, 1216a63d83f4SDavid Rientjes .write = oom_score_adj_write, 12176038f373SArnd Bergmann .llseek = default_llseek, 1218a63d83f4SDavid Rientjes }; 1219a63d83f4SDavid Rientjes 12201da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 1221b4eb4f7fSAlexey Dobriyan #define TMPBUFLEN 11 12221da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 12231da177e4SLinus Torvalds size_t count, loff_t *ppos) 12241da177e4SLinus Torvalds { 1225496ad9aaSAl Viro struct inode * inode = file_inode(file); 122699f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 12271da177e4SLinus Torvalds ssize_t length; 12281da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 12291da177e4SLinus Torvalds 123099f89551SEric W. Biederman if (!task) 123199f89551SEric W. Biederman return -ESRCH; 12321da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 1233e1760bd5SEric W. Biederman from_kuid(file->f_cred->user_ns, 1234e1760bd5SEric W. Biederman audit_get_loginuid(task))); 123599f89551SEric W. Biederman put_task_struct(task); 12361da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 12371da177e4SLinus Torvalds } 12381da177e4SLinus Torvalds 12391da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 12401da177e4SLinus Torvalds size_t count, loff_t *ppos) 12411da177e4SLinus Torvalds { 1242496ad9aaSAl Viro struct inode * inode = file_inode(file); 12431da177e4SLinus Torvalds uid_t loginuid; 1244e1760bd5SEric W. Biederman kuid_t kloginuid; 1245774636e1SAlexey Dobriyan int rv; 12461da177e4SLinus Torvalds 12477dc52157SPaul E. McKenney rcu_read_lock(); 12487dc52157SPaul E. McKenney if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) { 12497dc52157SPaul E. McKenney rcu_read_unlock(); 12501da177e4SLinus Torvalds return -EPERM; 12517dc52157SPaul E. McKenney } 12527dc52157SPaul E. McKenney rcu_read_unlock(); 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds if (*ppos != 0) { 12551da177e4SLinus Torvalds /* No partial writes. */ 12561da177e4SLinus Torvalds return -EINVAL; 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 1259774636e1SAlexey Dobriyan rv = kstrtou32_from_user(buf, count, 10, &loginuid); 1260774636e1SAlexey Dobriyan if (rv < 0) 1261774636e1SAlexey Dobriyan return rv; 126281407c84SEric Paris 126381407c84SEric Paris /* is userspace tring to explicitly UNSET the loginuid? */ 126481407c84SEric Paris if (loginuid == AUDIT_UID_UNSET) { 126581407c84SEric Paris kloginuid = INVALID_UID; 126681407c84SEric Paris } else { 1267e1760bd5SEric W. Biederman kloginuid = make_kuid(file->f_cred->user_ns, loginuid); 1268774636e1SAlexey Dobriyan if (!uid_valid(kloginuid)) 1269774636e1SAlexey Dobriyan return -EINVAL; 127081407c84SEric Paris } 1271e1760bd5SEric W. Biederman 1272774636e1SAlexey Dobriyan rv = audit_set_loginuid(kloginuid); 1273774636e1SAlexey Dobriyan if (rv < 0) 1274774636e1SAlexey Dobriyan return rv; 1275774636e1SAlexey Dobriyan return count; 12761da177e4SLinus Torvalds } 12771da177e4SLinus Torvalds 127800977a59SArjan van de Ven static const struct file_operations proc_loginuid_operations = { 12791da177e4SLinus Torvalds .read = proc_loginuid_read, 12801da177e4SLinus Torvalds .write = proc_loginuid_write, 128187df8424SArnd Bergmann .llseek = generic_file_llseek, 12821da177e4SLinus Torvalds }; 12831e0bd755SEric Paris 12841e0bd755SEric Paris static ssize_t proc_sessionid_read(struct file * file, char __user * buf, 12851e0bd755SEric Paris size_t count, loff_t *ppos) 12861e0bd755SEric Paris { 1287496ad9aaSAl Viro struct inode * inode = file_inode(file); 12881e0bd755SEric Paris struct task_struct *task = get_proc_task(inode); 12891e0bd755SEric Paris ssize_t length; 12901e0bd755SEric Paris char tmpbuf[TMPBUFLEN]; 12911e0bd755SEric Paris 12921e0bd755SEric Paris if (!task) 12931e0bd755SEric Paris return -ESRCH; 12941e0bd755SEric Paris length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 12951e0bd755SEric Paris audit_get_sessionid(task)); 12961e0bd755SEric Paris put_task_struct(task); 12971e0bd755SEric Paris return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 12981e0bd755SEric Paris } 12991e0bd755SEric Paris 13001e0bd755SEric Paris static const struct file_operations proc_sessionid_operations = { 13011e0bd755SEric Paris .read = proc_sessionid_read, 130287df8424SArnd Bergmann .llseek = generic_file_llseek, 13031e0bd755SEric Paris }; 13041da177e4SLinus Torvalds #endif 13051da177e4SLinus Torvalds 1306f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1307f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_read(struct file * file, char __user * buf, 1308f4f154fdSAkinobu Mita size_t count, loff_t *ppos) 1309f4f154fdSAkinobu Mita { 1310496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1311f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF]; 1312f4f154fdSAkinobu Mita size_t len; 1313f4f154fdSAkinobu Mita int make_it_fail; 1314f4f154fdSAkinobu Mita 1315f4f154fdSAkinobu Mita if (!task) 1316f4f154fdSAkinobu Mita return -ESRCH; 1317f4f154fdSAkinobu Mita make_it_fail = task->make_it_fail; 1318f4f154fdSAkinobu Mita put_task_struct(task); 1319f4f154fdSAkinobu Mita 1320f4f154fdSAkinobu Mita len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail); 13210c28f287SAkinobu Mita 13220c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 1323f4f154fdSAkinobu Mita } 1324f4f154fdSAkinobu Mita 1325f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_write(struct file * file, 1326f4f154fdSAkinobu Mita const char __user * buf, size_t count, loff_t *ppos) 1327f4f154fdSAkinobu Mita { 1328f4f154fdSAkinobu Mita struct task_struct *task; 1329774636e1SAlexey Dobriyan char buffer[PROC_NUMBUF]; 1330f4f154fdSAkinobu Mita int make_it_fail; 1331774636e1SAlexey Dobriyan int rv; 1332f4f154fdSAkinobu Mita 1333f4f154fdSAkinobu Mita if (!capable(CAP_SYS_RESOURCE)) 1334f4f154fdSAkinobu Mita return -EPERM; 1335f4f154fdSAkinobu Mita memset(buffer, 0, sizeof(buffer)); 1336f4f154fdSAkinobu Mita if (count > sizeof(buffer) - 1) 1337f4f154fdSAkinobu Mita count = sizeof(buffer) - 1; 1338f4f154fdSAkinobu Mita if (copy_from_user(buffer, buf, count)) 1339f4f154fdSAkinobu Mita return -EFAULT; 1340774636e1SAlexey Dobriyan rv = kstrtoint(strstrip(buffer), 0, &make_it_fail); 1341774636e1SAlexey Dobriyan if (rv < 0) 1342774636e1SAlexey Dobriyan return rv; 134316caed31SDave Jones if (make_it_fail < 0 || make_it_fail > 1) 134416caed31SDave Jones return -EINVAL; 134516caed31SDave Jones 1346496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1347f4f154fdSAkinobu Mita if (!task) 1348f4f154fdSAkinobu Mita return -ESRCH; 1349f4f154fdSAkinobu Mita task->make_it_fail = make_it_fail; 1350f4f154fdSAkinobu Mita put_task_struct(task); 1351cba8aafeSVincent Li 1352cba8aafeSVincent Li return count; 1353f4f154fdSAkinobu Mita } 1354f4f154fdSAkinobu Mita 135500977a59SArjan van de Ven static const struct file_operations proc_fault_inject_operations = { 1356f4f154fdSAkinobu Mita .read = proc_fault_inject_read, 1357f4f154fdSAkinobu Mita .write = proc_fault_inject_write, 135887df8424SArnd Bergmann .llseek = generic_file_llseek, 1359f4f154fdSAkinobu Mita }; 1360e41d5818SDmitry Vyukov 1361e41d5818SDmitry Vyukov static ssize_t proc_fail_nth_write(struct file *file, const char __user *buf, 1362e41d5818SDmitry Vyukov size_t count, loff_t *ppos) 1363e41d5818SDmitry Vyukov { 1364e41d5818SDmitry Vyukov struct task_struct *task; 13659049f2f6SAkinobu Mita int err; 13669049f2f6SAkinobu Mita unsigned int n; 1367e41d5818SDmitry Vyukov 13689049f2f6SAkinobu Mita err = kstrtouint_from_user(buf, count, 0, &n); 1369e41d5818SDmitry Vyukov if (err) 1370e41d5818SDmitry Vyukov return err; 13711203c8e6SAkinobu Mita 13721203c8e6SAkinobu Mita task = get_proc_task(file_inode(file)); 13731203c8e6SAkinobu Mita if (!task) 13741203c8e6SAkinobu Mita return -ESRCH; 13759f7118b2SAlexey Dobriyan task->fail_nth = n; 13761203c8e6SAkinobu Mita put_task_struct(task); 13771203c8e6SAkinobu Mita 1378e41d5818SDmitry Vyukov return count; 1379e41d5818SDmitry Vyukov } 1380e41d5818SDmitry Vyukov 1381e41d5818SDmitry Vyukov static ssize_t proc_fail_nth_read(struct file *file, char __user *buf, 1382e41d5818SDmitry Vyukov size_t count, loff_t *ppos) 1383e41d5818SDmitry Vyukov { 1384e41d5818SDmitry Vyukov struct task_struct *task; 1385bfc74093SAkinobu Mita char numbuf[PROC_NUMBUF]; 1386bfc74093SAkinobu Mita ssize_t len; 1387e41d5818SDmitry Vyukov 1388e41d5818SDmitry Vyukov task = get_proc_task(file_inode(file)); 1389e41d5818SDmitry Vyukov if (!task) 1390e41d5818SDmitry Vyukov return -ESRCH; 13919f7118b2SAlexey Dobriyan len = snprintf(numbuf, sizeof(numbuf), "%u\n", task->fail_nth); 1392bfc74093SAkinobu Mita len = simple_read_from_buffer(buf, count, ppos, numbuf, len); 13931203c8e6SAkinobu Mita put_task_struct(task); 1394bfc74093SAkinobu Mita 1395bfc74093SAkinobu Mita return len; 1396e41d5818SDmitry Vyukov } 1397e41d5818SDmitry Vyukov 1398e41d5818SDmitry Vyukov static const struct file_operations proc_fail_nth_operations = { 1399e41d5818SDmitry Vyukov .read = proc_fail_nth_read, 1400e41d5818SDmitry Vyukov .write = proc_fail_nth_write, 1401e41d5818SDmitry Vyukov }; 1402f4f154fdSAkinobu Mita #endif 1403f4f154fdSAkinobu Mita 14049745512cSArjan van de Ven 140543ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 140643ae34cbSIngo Molnar /* 140743ae34cbSIngo Molnar * Print out various scheduling related per-task fields: 140843ae34cbSIngo Molnar */ 140943ae34cbSIngo Molnar static int sched_show(struct seq_file *m, void *v) 141043ae34cbSIngo Molnar { 141143ae34cbSIngo Molnar struct inode *inode = m->private; 141274dc3384SAleksa Sarai struct pid_namespace *ns = inode->i_sb->s_fs_info; 141343ae34cbSIngo Molnar struct task_struct *p; 141443ae34cbSIngo Molnar 141543ae34cbSIngo Molnar p = get_proc_task(inode); 141643ae34cbSIngo Molnar if (!p) 141743ae34cbSIngo Molnar return -ESRCH; 141874dc3384SAleksa Sarai proc_sched_show_task(p, ns, m); 141943ae34cbSIngo Molnar 142043ae34cbSIngo Molnar put_task_struct(p); 142143ae34cbSIngo Molnar 142243ae34cbSIngo Molnar return 0; 142343ae34cbSIngo Molnar } 142443ae34cbSIngo Molnar 142543ae34cbSIngo Molnar static ssize_t 142643ae34cbSIngo Molnar sched_write(struct file *file, const char __user *buf, 142743ae34cbSIngo Molnar size_t count, loff_t *offset) 142843ae34cbSIngo Molnar { 1429496ad9aaSAl Viro struct inode *inode = file_inode(file); 143043ae34cbSIngo Molnar struct task_struct *p; 143143ae34cbSIngo Molnar 143243ae34cbSIngo Molnar p = get_proc_task(inode); 143343ae34cbSIngo Molnar if (!p) 143443ae34cbSIngo Molnar return -ESRCH; 143543ae34cbSIngo Molnar proc_sched_set_task(p); 143643ae34cbSIngo Molnar 143743ae34cbSIngo Molnar put_task_struct(p); 143843ae34cbSIngo Molnar 143943ae34cbSIngo Molnar return count; 144043ae34cbSIngo Molnar } 144143ae34cbSIngo Molnar 144243ae34cbSIngo Molnar static int sched_open(struct inode *inode, struct file *filp) 144343ae34cbSIngo Molnar { 1444c6a34058SJovi Zhang return single_open(filp, sched_show, inode); 144543ae34cbSIngo Molnar } 144643ae34cbSIngo Molnar 144743ae34cbSIngo Molnar static const struct file_operations proc_pid_sched_operations = { 144843ae34cbSIngo Molnar .open = sched_open, 144943ae34cbSIngo Molnar .read = seq_read, 145043ae34cbSIngo Molnar .write = sched_write, 145143ae34cbSIngo Molnar .llseek = seq_lseek, 14525ea473a1SAlexey Dobriyan .release = single_release, 145343ae34cbSIngo Molnar }; 145443ae34cbSIngo Molnar 145543ae34cbSIngo Molnar #endif 145643ae34cbSIngo Molnar 14575091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 14585091faa4SMike Galbraith /* 14595091faa4SMike Galbraith * Print out autogroup related information: 14605091faa4SMike Galbraith */ 14615091faa4SMike Galbraith static int sched_autogroup_show(struct seq_file *m, void *v) 14625091faa4SMike Galbraith { 14635091faa4SMike Galbraith struct inode *inode = m->private; 14645091faa4SMike Galbraith struct task_struct *p; 14655091faa4SMike Galbraith 14665091faa4SMike Galbraith p = get_proc_task(inode); 14675091faa4SMike Galbraith if (!p) 14685091faa4SMike Galbraith return -ESRCH; 14695091faa4SMike Galbraith proc_sched_autogroup_show_task(p, m); 14705091faa4SMike Galbraith 14715091faa4SMike Galbraith put_task_struct(p); 14725091faa4SMike Galbraith 14735091faa4SMike Galbraith return 0; 14745091faa4SMike Galbraith } 14755091faa4SMike Galbraith 14765091faa4SMike Galbraith static ssize_t 14775091faa4SMike Galbraith sched_autogroup_write(struct file *file, const char __user *buf, 14785091faa4SMike Galbraith size_t count, loff_t *offset) 14795091faa4SMike Galbraith { 1480496ad9aaSAl Viro struct inode *inode = file_inode(file); 14815091faa4SMike Galbraith struct task_struct *p; 14825091faa4SMike Galbraith char buffer[PROC_NUMBUF]; 14830a8cb8e3SAlexey Dobriyan int nice; 14845091faa4SMike Galbraith int err; 14855091faa4SMike Galbraith 14865091faa4SMike Galbraith memset(buffer, 0, sizeof(buffer)); 14875091faa4SMike Galbraith if (count > sizeof(buffer) - 1) 14885091faa4SMike Galbraith count = sizeof(buffer) - 1; 14895091faa4SMike Galbraith if (copy_from_user(buffer, buf, count)) 14905091faa4SMike Galbraith return -EFAULT; 14915091faa4SMike Galbraith 14920a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &nice); 14930a8cb8e3SAlexey Dobriyan if (err < 0) 14940a8cb8e3SAlexey Dobriyan return err; 14955091faa4SMike Galbraith 14965091faa4SMike Galbraith p = get_proc_task(inode); 14975091faa4SMike Galbraith if (!p) 14985091faa4SMike Galbraith return -ESRCH; 14995091faa4SMike Galbraith 15002e5b5b3aSHiroshi Shimamoto err = proc_sched_autogroup_set_nice(p, nice); 15015091faa4SMike Galbraith if (err) 15025091faa4SMike Galbraith count = err; 15035091faa4SMike Galbraith 15045091faa4SMike Galbraith put_task_struct(p); 15055091faa4SMike Galbraith 15065091faa4SMike Galbraith return count; 15075091faa4SMike Galbraith } 15085091faa4SMike Galbraith 15095091faa4SMike Galbraith static int sched_autogroup_open(struct inode *inode, struct file *filp) 15105091faa4SMike Galbraith { 15115091faa4SMike Galbraith int ret; 15125091faa4SMike Galbraith 15135091faa4SMike Galbraith ret = single_open(filp, sched_autogroup_show, NULL); 15145091faa4SMike Galbraith if (!ret) { 15155091faa4SMike Galbraith struct seq_file *m = filp->private_data; 15165091faa4SMike Galbraith 15175091faa4SMike Galbraith m->private = inode; 15185091faa4SMike Galbraith } 15195091faa4SMike Galbraith return ret; 15205091faa4SMike Galbraith } 15215091faa4SMike Galbraith 15225091faa4SMike Galbraith static const struct file_operations proc_pid_sched_autogroup_operations = { 15235091faa4SMike Galbraith .open = sched_autogroup_open, 15245091faa4SMike Galbraith .read = seq_read, 15255091faa4SMike Galbraith .write = sched_autogroup_write, 15265091faa4SMike Galbraith .llseek = seq_lseek, 15275091faa4SMike Galbraith .release = single_release, 15285091faa4SMike Galbraith }; 15295091faa4SMike Galbraith 15305091faa4SMike Galbraith #endif /* CONFIG_SCHED_AUTOGROUP */ 15315091faa4SMike Galbraith 15324614a696Sjohn stultz static ssize_t comm_write(struct file *file, const char __user *buf, 15334614a696Sjohn stultz size_t count, loff_t *offset) 15344614a696Sjohn stultz { 1535496ad9aaSAl Viro struct inode *inode = file_inode(file); 15364614a696Sjohn stultz struct task_struct *p; 15374614a696Sjohn stultz char buffer[TASK_COMM_LEN]; 1538830e0fc9SDavid Rientjes const size_t maxlen = sizeof(buffer) - 1; 15394614a696Sjohn stultz 15404614a696Sjohn stultz memset(buffer, 0, sizeof(buffer)); 1541830e0fc9SDavid Rientjes if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count)) 15424614a696Sjohn stultz return -EFAULT; 15434614a696Sjohn stultz 15444614a696Sjohn stultz p = get_proc_task(inode); 15454614a696Sjohn stultz if (!p) 15464614a696Sjohn stultz return -ESRCH; 15474614a696Sjohn stultz 15484614a696Sjohn stultz if (same_thread_group(current, p)) 15494614a696Sjohn stultz set_task_comm(p, buffer); 15504614a696Sjohn stultz else 15514614a696Sjohn stultz count = -EINVAL; 15524614a696Sjohn stultz 15534614a696Sjohn stultz put_task_struct(p); 15544614a696Sjohn stultz 15554614a696Sjohn stultz return count; 15564614a696Sjohn stultz } 15574614a696Sjohn stultz 15584614a696Sjohn stultz static int comm_show(struct seq_file *m, void *v) 15594614a696Sjohn stultz { 15604614a696Sjohn stultz struct inode *inode = m->private; 15614614a696Sjohn stultz struct task_struct *p; 15624614a696Sjohn stultz 15634614a696Sjohn stultz p = get_proc_task(inode); 15644614a696Sjohn stultz if (!p) 15654614a696Sjohn stultz return -ESRCH; 15664614a696Sjohn stultz 15674614a696Sjohn stultz task_lock(p); 15684614a696Sjohn stultz seq_printf(m, "%s\n", p->comm); 15694614a696Sjohn stultz task_unlock(p); 15704614a696Sjohn stultz 15714614a696Sjohn stultz put_task_struct(p); 15724614a696Sjohn stultz 15734614a696Sjohn stultz return 0; 15744614a696Sjohn stultz } 15754614a696Sjohn stultz 15764614a696Sjohn stultz static int comm_open(struct inode *inode, struct file *filp) 15774614a696Sjohn stultz { 1578c6a34058SJovi Zhang return single_open(filp, comm_show, inode); 15794614a696Sjohn stultz } 15804614a696Sjohn stultz 15814614a696Sjohn stultz static const struct file_operations proc_pid_set_comm_operations = { 15824614a696Sjohn stultz .open = comm_open, 15834614a696Sjohn stultz .read = seq_read, 15844614a696Sjohn stultz .write = comm_write, 15854614a696Sjohn stultz .llseek = seq_lseek, 15864614a696Sjohn stultz .release = single_release, 15874614a696Sjohn stultz }; 15884614a696Sjohn stultz 15897773fbc5SCyrill Gorcunov static int proc_exe_link(struct dentry *dentry, struct path *exe_path) 1590925d1c40SMatt Helsley { 1591925d1c40SMatt Helsley struct task_struct *task; 1592925d1c40SMatt Helsley struct file *exe_file; 1593925d1c40SMatt Helsley 15942b0143b5SDavid Howells task = get_proc_task(d_inode(dentry)); 1595925d1c40SMatt Helsley if (!task) 1596925d1c40SMatt Helsley return -ENOENT; 1597cd81a917SMateusz Guzik exe_file = get_task_exe_file(task); 1598925d1c40SMatt Helsley put_task_struct(task); 1599925d1c40SMatt Helsley if (exe_file) { 1600925d1c40SMatt Helsley *exe_path = exe_file->f_path; 1601925d1c40SMatt Helsley path_get(&exe_file->f_path); 1602925d1c40SMatt Helsley fput(exe_file); 1603925d1c40SMatt Helsley return 0; 1604925d1c40SMatt Helsley } else 1605925d1c40SMatt Helsley return -ENOENT; 1606925d1c40SMatt Helsley } 1607925d1c40SMatt Helsley 16086b255391SAl Viro static const char *proc_pid_get_link(struct dentry *dentry, 1609fceef393SAl Viro struct inode *inode, 1610fceef393SAl Viro struct delayed_call *done) 16111da177e4SLinus Torvalds { 1612408ef013SChristoph Hellwig struct path path; 16131da177e4SLinus Torvalds int error = -EACCES; 16141da177e4SLinus Torvalds 16156b255391SAl Viro if (!dentry) 16166b255391SAl Viro return ERR_PTR(-ECHILD); 16176b255391SAl Viro 1618778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1619778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 16201da177e4SLinus Torvalds goto out; 16211da177e4SLinus Torvalds 1622408ef013SChristoph Hellwig error = PROC_I(inode)->op.proc_get_link(dentry, &path); 1623408ef013SChristoph Hellwig if (error) 1624408ef013SChristoph Hellwig goto out; 1625408ef013SChristoph Hellwig 16266e77137bSAl Viro nd_jump_link(&path); 1627408ef013SChristoph Hellwig return NULL; 16281da177e4SLinus Torvalds out: 1629008b150aSAl Viro return ERR_PTR(error); 16301da177e4SLinus Torvalds } 16311da177e4SLinus Torvalds 16323dcd25f3SJan Blunck static int do_proc_readlink(struct path *path, char __user *buffer, int buflen) 16331da177e4SLinus Torvalds { 16340ee931c4SMichal Hocko char *tmp = (char *)__get_free_page(GFP_KERNEL); 16353dcd25f3SJan Blunck char *pathname; 16361da177e4SLinus Torvalds int len; 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds if (!tmp) 16391da177e4SLinus Torvalds return -ENOMEM; 16401da177e4SLinus Torvalds 16417b2a69baSEric W. Biederman pathname = d_path(path, tmp, PAGE_SIZE); 16423dcd25f3SJan Blunck len = PTR_ERR(pathname); 16433dcd25f3SJan Blunck if (IS_ERR(pathname)) 16441da177e4SLinus Torvalds goto out; 16453dcd25f3SJan Blunck len = tmp + PAGE_SIZE - 1 - pathname; 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds if (len > buflen) 16481da177e4SLinus Torvalds len = buflen; 16493dcd25f3SJan Blunck if (copy_to_user(buffer, pathname, len)) 16501da177e4SLinus Torvalds len = -EFAULT; 16511da177e4SLinus Torvalds out: 16521da177e4SLinus Torvalds free_page((unsigned long)tmp); 16531da177e4SLinus Torvalds return len; 16541da177e4SLinus Torvalds } 16551da177e4SLinus Torvalds 16561da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 16571da177e4SLinus Torvalds { 16581da177e4SLinus Torvalds int error = -EACCES; 16592b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 16603dcd25f3SJan Blunck struct path path; 16611da177e4SLinus Torvalds 1662778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1663778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 16641da177e4SLinus Torvalds goto out; 16651da177e4SLinus Torvalds 16667773fbc5SCyrill Gorcunov error = PROC_I(inode)->op.proc_get_link(dentry, &path); 16671da177e4SLinus Torvalds if (error) 16681da177e4SLinus Torvalds goto out; 16691da177e4SLinus Torvalds 16703dcd25f3SJan Blunck error = do_proc_readlink(&path, buffer, buflen); 16713dcd25f3SJan Blunck path_put(&path); 16721da177e4SLinus Torvalds out: 16731da177e4SLinus Torvalds return error; 16741da177e4SLinus Torvalds } 16751da177e4SLinus Torvalds 1676faf60af1SCyrill Gorcunov const struct inode_operations proc_pid_link_inode_operations = { 16771da177e4SLinus Torvalds .readlink = proc_pid_readlink, 16786b255391SAl Viro .get_link = proc_pid_get_link, 16796d76fa58SLinus Torvalds .setattr = proc_setattr, 16801da177e4SLinus Torvalds }; 16811da177e4SLinus Torvalds 168228a6d671SEric W. Biederman 168328a6d671SEric W. Biederman /* building an inode */ 168428a6d671SEric W. Biederman 1685c6eb50d2SAl Viro void task_dump_owner(struct task_struct *task, umode_t mode, 168668eb94f1SEric W. Biederman kuid_t *ruid, kgid_t *rgid) 168768eb94f1SEric W. Biederman { 168868eb94f1SEric W. Biederman /* Depending on the state of dumpable compute who should own a 168968eb94f1SEric W. Biederman * proc file for a task. 169068eb94f1SEric W. Biederman */ 169168eb94f1SEric W. Biederman const struct cred *cred; 169268eb94f1SEric W. Biederman kuid_t uid; 169368eb94f1SEric W. Biederman kgid_t gid; 169468eb94f1SEric W. Biederman 169568eb94f1SEric W. Biederman /* Default to the tasks effective ownership */ 169668eb94f1SEric W. Biederman rcu_read_lock(); 169768eb94f1SEric W. Biederman cred = __task_cred(task); 169868eb94f1SEric W. Biederman uid = cred->euid; 169968eb94f1SEric W. Biederman gid = cred->egid; 170068eb94f1SEric W. Biederman rcu_read_unlock(); 170168eb94f1SEric W. Biederman 170268eb94f1SEric W. Biederman /* 170368eb94f1SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 170468eb94f1SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 170568eb94f1SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 170668eb94f1SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 170768eb94f1SEric W. Biederman * made this apply to all per process world readable and executable 170868eb94f1SEric W. Biederman * directories. 170968eb94f1SEric W. Biederman */ 171068eb94f1SEric W. Biederman if (mode != (S_IFDIR|S_IRUGO|S_IXUGO)) { 171168eb94f1SEric W. Biederman struct mm_struct *mm; 171268eb94f1SEric W. Biederman task_lock(task); 171368eb94f1SEric W. Biederman mm = task->mm; 171468eb94f1SEric W. Biederman /* Make non-dumpable tasks owned by some root */ 171568eb94f1SEric W. Biederman if (mm) { 171668eb94f1SEric W. Biederman if (get_dumpable(mm) != SUID_DUMP_USER) { 171768eb94f1SEric W. Biederman struct user_namespace *user_ns = mm->user_ns; 171868eb94f1SEric W. Biederman 171968eb94f1SEric W. Biederman uid = make_kuid(user_ns, 0); 172068eb94f1SEric W. Biederman if (!uid_valid(uid)) 172168eb94f1SEric W. Biederman uid = GLOBAL_ROOT_UID; 172268eb94f1SEric W. Biederman 172368eb94f1SEric W. Biederman gid = make_kgid(user_ns, 0); 172468eb94f1SEric W. Biederman if (!gid_valid(gid)) 172568eb94f1SEric W. Biederman gid = GLOBAL_ROOT_GID; 172668eb94f1SEric W. Biederman } 172768eb94f1SEric W. Biederman } else { 172868eb94f1SEric W. Biederman uid = GLOBAL_ROOT_UID; 172968eb94f1SEric W. Biederman gid = GLOBAL_ROOT_GID; 173068eb94f1SEric W. Biederman } 173168eb94f1SEric W. Biederman task_unlock(task); 173268eb94f1SEric W. Biederman } 173368eb94f1SEric W. Biederman *ruid = uid; 173468eb94f1SEric W. Biederman *rgid = gid; 173568eb94f1SEric W. Biederman } 173668eb94f1SEric W. Biederman 1737db978da8SAndreas Gruenbacher struct inode *proc_pid_make_inode(struct super_block * sb, 1738db978da8SAndreas Gruenbacher struct task_struct *task, umode_t mode) 173928a6d671SEric W. Biederman { 174028a6d671SEric W. Biederman struct inode * inode; 174128a6d671SEric W. Biederman struct proc_inode *ei; 174228a6d671SEric W. Biederman 174328a6d671SEric W. Biederman /* We need a new inode */ 174428a6d671SEric W. Biederman 174528a6d671SEric W. Biederman inode = new_inode(sb); 174628a6d671SEric W. Biederman if (!inode) 174728a6d671SEric W. Biederman goto out; 174828a6d671SEric W. Biederman 174928a6d671SEric W. Biederman /* Common stuff */ 175028a6d671SEric W. Biederman ei = PROC_I(inode); 1751db978da8SAndreas Gruenbacher inode->i_mode = mode; 175285fe4025SChristoph Hellwig inode->i_ino = get_next_ino(); 1753078cd827SDeepa Dinamani inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); 175428a6d671SEric W. Biederman inode->i_op = &proc_def_inode_operations; 175528a6d671SEric W. Biederman 175628a6d671SEric W. Biederman /* 175728a6d671SEric W. Biederman * grab the reference to task. 175828a6d671SEric W. Biederman */ 17591a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 176028a6d671SEric W. Biederman if (!ei->pid) 176128a6d671SEric W. Biederman goto out_unlock; 176228a6d671SEric W. Biederman 176368eb94f1SEric W. Biederman task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid); 176428a6d671SEric W. Biederman security_task_to_inode(task, inode); 176528a6d671SEric W. Biederman 176628a6d671SEric W. Biederman out: 176728a6d671SEric W. Biederman return inode; 176828a6d671SEric W. Biederman 176928a6d671SEric W. Biederman out_unlock: 177028a6d671SEric W. Biederman iput(inode); 177128a6d671SEric W. Biederman return NULL; 177228a6d671SEric W. Biederman } 177328a6d671SEric W. Biederman 1774a528d35eSDavid Howells int pid_getattr(const struct path *path, struct kstat *stat, 1775a528d35eSDavid Howells u32 request_mask, unsigned int query_flags) 177628a6d671SEric W. Biederman { 1777a528d35eSDavid Howells struct inode *inode = d_inode(path->dentry); 177828a6d671SEric W. Biederman struct task_struct *task; 1779a528d35eSDavid Howells struct pid_namespace *pid = path->dentry->d_sb->s_fs_info; 1780c69e8d9cSDavid Howells 178128a6d671SEric W. Biederman generic_fillattr(inode, stat); 178228a6d671SEric W. Biederman 178328a6d671SEric W. Biederman rcu_read_lock(); 1784dcb0f222SEric W. Biederman stat->uid = GLOBAL_ROOT_UID; 1785dcb0f222SEric W. Biederman stat->gid = GLOBAL_ROOT_GID; 178628a6d671SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 178728a6d671SEric W. Biederman if (task) { 1788796f571bSLafcadio Wluiki if (!has_pid_permissions(pid, task, HIDEPID_INVISIBLE)) { 17890499680aSVasiliy Kulikov rcu_read_unlock(); 17900499680aSVasiliy Kulikov /* 17910499680aSVasiliy Kulikov * This doesn't prevent learning whether PID exists, 17920499680aSVasiliy Kulikov * it only makes getattr() consistent with readdir(). 17930499680aSVasiliy Kulikov */ 17940499680aSVasiliy Kulikov return -ENOENT; 17950499680aSVasiliy Kulikov } 179668eb94f1SEric W. Biederman task_dump_owner(task, inode->i_mode, &stat->uid, &stat->gid); 179728a6d671SEric W. Biederman } 179828a6d671SEric W. Biederman rcu_read_unlock(); 179928a6d671SEric W. Biederman return 0; 180028a6d671SEric W. Biederman } 180128a6d671SEric W. Biederman 180228a6d671SEric W. Biederman /* dentry stuff */ 180328a6d671SEric W. Biederman 180428a6d671SEric W. Biederman /* 180528a6d671SEric W. Biederman * Exceptional case: normally we are not allowed to unhash a busy 180628a6d671SEric W. Biederman * directory. In this case, however, we can do it - no aliasing problems 180728a6d671SEric W. Biederman * due to the way we treat inodes. 180828a6d671SEric W. Biederman * 180928a6d671SEric W. Biederman * Rewrite the inode's ownerships here because the owning task may have 181028a6d671SEric W. Biederman * performed a setuid(), etc. 181128a6d671SEric W. Biederman * 181228a6d671SEric W. Biederman */ 18130b728e19SAl Viro int pid_revalidate(struct dentry *dentry, unsigned int flags) 181428a6d671SEric W. Biederman { 181534286d66SNick Piggin struct inode *inode; 181634286d66SNick Piggin struct task_struct *task; 1817c69e8d9cSDavid Howells 18180b728e19SAl Viro if (flags & LOOKUP_RCU) 181934286d66SNick Piggin return -ECHILD; 182034286d66SNick Piggin 18212b0143b5SDavid Howells inode = d_inode(dentry); 182234286d66SNick Piggin task = get_proc_task(inode); 182334286d66SNick Piggin 182428a6d671SEric W. Biederman if (task) { 182568eb94f1SEric W. Biederman task_dump_owner(task, inode->i_mode, &inode->i_uid, &inode->i_gid); 182668eb94f1SEric W. Biederman 182728a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 182828a6d671SEric W. Biederman security_task_to_inode(task, inode); 182928a6d671SEric W. Biederman put_task_struct(task); 183028a6d671SEric W. Biederman return 1; 183128a6d671SEric W. Biederman } 183228a6d671SEric W. Biederman return 0; 183328a6d671SEric W. Biederman } 183428a6d671SEric W. Biederman 1835d855a4b7SOleg Nesterov static inline bool proc_inode_is_dead(struct inode *inode) 1836d855a4b7SOleg Nesterov { 1837d855a4b7SOleg Nesterov return !proc_pid(inode)->tasks[PIDTYPE_PID].first; 1838d855a4b7SOleg Nesterov } 1839d855a4b7SOleg Nesterov 18401dd704b6SDavid Howells int pid_delete_dentry(const struct dentry *dentry) 18411dd704b6SDavid Howells { 18421dd704b6SDavid Howells /* Is the task we represent dead? 18431dd704b6SDavid Howells * If so, then don't put the dentry on the lru list, 18441dd704b6SDavid Howells * kill it immediately. 18451dd704b6SDavid Howells */ 18462b0143b5SDavid Howells return proc_inode_is_dead(d_inode(dentry)); 18471dd704b6SDavid Howells } 18481dd704b6SDavid Howells 18496b4e306aSEric W. Biederman const struct dentry_operations pid_dentry_operations = 185028a6d671SEric W. Biederman { 185128a6d671SEric W. Biederman .d_revalidate = pid_revalidate, 185228a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 185328a6d671SEric W. Biederman }; 185428a6d671SEric W. Biederman 185528a6d671SEric W. Biederman /* Lookups */ 185628a6d671SEric W. Biederman 18571c0d04c9SEric W. Biederman /* 18581c0d04c9SEric W. Biederman * Fill a directory entry. 18591c0d04c9SEric W. Biederman * 18601c0d04c9SEric W. Biederman * If possible create the dcache entry and derive our inode number and 18611c0d04c9SEric W. Biederman * file type from dcache entry. 18621c0d04c9SEric W. Biederman * 18631c0d04c9SEric W. Biederman * Since all of the proc inode numbers are dynamically generated, the inode 18641c0d04c9SEric W. Biederman * numbers do not exist until the inode is cache. This means creating the 18651c0d04c9SEric W. Biederman * the dcache entry in readdir is necessary to keep the inode numbers 18661c0d04c9SEric W. Biederman * reported by readdir in sync with the inode numbers reported 18671c0d04c9SEric W. Biederman * by stat. 18681c0d04c9SEric W. Biederman */ 1869f0c3b509SAl Viro bool proc_fill_cache(struct file *file, struct dir_context *ctx, 18706b4e306aSEric W. Biederman const char *name, int len, 1871c5141e6dSEric Dumazet instantiate_t instantiate, struct task_struct *task, const void *ptr) 187261a28784SEric W. Biederman { 1873f0c3b509SAl Viro struct dentry *child, *dir = file->f_path.dentry; 18741df98b8bSAl Viro struct qstr qname = QSTR_INIT(name, len); 187561a28784SEric W. Biederman struct inode *inode; 18761df98b8bSAl Viro unsigned type; 18771df98b8bSAl Viro ino_t ino; 187861a28784SEric W. Biederman 18791df98b8bSAl Viro child = d_hash_and_lookup(dir, &qname); 188061a28784SEric W. Biederman if (!child) { 18813781764bSAl Viro DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 18823781764bSAl Viro child = d_alloc_parallel(dir, &qname, &wq); 18833781764bSAl Viro if (IS_ERR(child)) 188461a28784SEric W. Biederman goto end_instantiate; 18853781764bSAl Viro if (d_in_lookup(child)) { 18863781764bSAl Viro int err = instantiate(d_inode(dir), child, task, ptr); 18873781764bSAl Viro d_lookup_done(child); 18883781764bSAl Viro if (err < 0) { 18891df98b8bSAl Viro dput(child); 18901df98b8bSAl Viro goto end_instantiate; 18911df98b8bSAl Viro } 18921df98b8bSAl Viro } 18933781764bSAl Viro } 18942b0143b5SDavid Howells inode = d_inode(child); 189561a28784SEric W. Biederman ino = inode->i_ino; 189661a28784SEric W. Biederman type = inode->i_mode >> 12; 189761a28784SEric W. Biederman dput(child); 1898f0c3b509SAl Viro return dir_emit(ctx, name, len, ino, type); 18991df98b8bSAl Viro 19001df98b8bSAl Viro end_instantiate: 19011df98b8bSAl Viro return dir_emit(ctx, name, len, 1, DT_UNKNOWN); 190261a28784SEric W. Biederman } 190361a28784SEric W. Biederman 1904640708a2SPavel Emelyanov /* 1905640708a2SPavel Emelyanov * dname_to_vma_addr - maps a dentry name into two unsigned longs 1906640708a2SPavel Emelyanov * which represent vma start and end addresses. 1907640708a2SPavel Emelyanov */ 1908640708a2SPavel Emelyanov static int dname_to_vma_addr(struct dentry *dentry, 1909640708a2SPavel Emelyanov unsigned long *start, unsigned long *end) 1910640708a2SPavel Emelyanov { 1911ac7f1061SAlexey Dobriyan const char *str = dentry->d_name.name; 1912ac7f1061SAlexey Dobriyan unsigned long long sval, eval; 1913ac7f1061SAlexey Dobriyan unsigned int len; 1914ac7f1061SAlexey Dobriyan 1915ac7f1061SAlexey Dobriyan len = _parse_integer(str, 16, &sval); 1916ac7f1061SAlexey Dobriyan if (len & KSTRTOX_OVERFLOW) 1917640708a2SPavel Emelyanov return -EINVAL; 1918ac7f1061SAlexey Dobriyan if (sval != (unsigned long)sval) 1919ac7f1061SAlexey Dobriyan return -EINVAL; 1920ac7f1061SAlexey Dobriyan str += len; 1921ac7f1061SAlexey Dobriyan 1922ac7f1061SAlexey Dobriyan if (*str != '-') 1923ac7f1061SAlexey Dobriyan return -EINVAL; 1924ac7f1061SAlexey Dobriyan str++; 1925ac7f1061SAlexey Dobriyan 1926ac7f1061SAlexey Dobriyan len = _parse_integer(str, 16, &eval); 1927ac7f1061SAlexey Dobriyan if (len & KSTRTOX_OVERFLOW) 1928ac7f1061SAlexey Dobriyan return -EINVAL; 1929ac7f1061SAlexey Dobriyan if (eval != (unsigned long)eval) 1930ac7f1061SAlexey Dobriyan return -EINVAL; 1931ac7f1061SAlexey Dobriyan str += len; 1932ac7f1061SAlexey Dobriyan 1933ac7f1061SAlexey Dobriyan if (*str != '\0') 1934ac7f1061SAlexey Dobriyan return -EINVAL; 1935ac7f1061SAlexey Dobriyan 1936ac7f1061SAlexey Dobriyan *start = sval; 1937ac7f1061SAlexey Dobriyan *end = eval; 1938640708a2SPavel Emelyanov 1939640708a2SPavel Emelyanov return 0; 1940640708a2SPavel Emelyanov } 1941640708a2SPavel Emelyanov 19420b728e19SAl Viro static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags) 1943640708a2SPavel Emelyanov { 1944640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1945640708a2SPavel Emelyanov bool exact_vma_exists = false; 1946640708a2SPavel Emelyanov struct mm_struct *mm = NULL; 1947640708a2SPavel Emelyanov struct task_struct *task; 1948640708a2SPavel Emelyanov struct inode *inode; 1949640708a2SPavel Emelyanov int status = 0; 1950640708a2SPavel Emelyanov 19510b728e19SAl Viro if (flags & LOOKUP_RCU) 1952640708a2SPavel Emelyanov return -ECHILD; 1953640708a2SPavel Emelyanov 19542b0143b5SDavid Howells inode = d_inode(dentry); 1955640708a2SPavel Emelyanov task = get_proc_task(inode); 1956640708a2SPavel Emelyanov if (!task) 1957640708a2SPavel Emelyanov goto out_notask; 1958640708a2SPavel Emelyanov 1959caaee623SJann Horn mm = mm_access(task, PTRACE_MODE_READ_FSCREDS); 19602344bec7SCong Wang if (IS_ERR_OR_NULL(mm)) 1961640708a2SPavel Emelyanov goto out; 1962640708a2SPavel Emelyanov 1963640708a2SPavel Emelyanov if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) { 1964640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1965640708a2SPavel Emelyanov exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end); 1966640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1967640708a2SPavel Emelyanov } 1968640708a2SPavel Emelyanov 1969640708a2SPavel Emelyanov mmput(mm); 1970640708a2SPavel Emelyanov 1971640708a2SPavel Emelyanov if (exact_vma_exists) { 197268eb94f1SEric W. Biederman task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid); 197368eb94f1SEric W. Biederman 1974640708a2SPavel Emelyanov security_task_to_inode(task, inode); 1975640708a2SPavel Emelyanov status = 1; 1976640708a2SPavel Emelyanov } 1977640708a2SPavel Emelyanov 1978640708a2SPavel Emelyanov out: 1979640708a2SPavel Emelyanov put_task_struct(task); 1980640708a2SPavel Emelyanov 1981640708a2SPavel Emelyanov out_notask: 1982640708a2SPavel Emelyanov return status; 1983640708a2SPavel Emelyanov } 1984640708a2SPavel Emelyanov 1985640708a2SPavel Emelyanov static const struct dentry_operations tid_map_files_dentry_operations = { 1986640708a2SPavel Emelyanov .d_revalidate = map_files_d_revalidate, 1987640708a2SPavel Emelyanov .d_delete = pid_delete_dentry, 1988640708a2SPavel Emelyanov }; 1989640708a2SPavel Emelyanov 19906b255391SAl Viro static int map_files_get_link(struct dentry *dentry, struct path *path) 1991640708a2SPavel Emelyanov { 1992640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1993640708a2SPavel Emelyanov struct vm_area_struct *vma; 1994640708a2SPavel Emelyanov struct task_struct *task; 1995640708a2SPavel Emelyanov struct mm_struct *mm; 1996640708a2SPavel Emelyanov int rc; 1997640708a2SPavel Emelyanov 1998640708a2SPavel Emelyanov rc = -ENOENT; 19992b0143b5SDavid Howells task = get_proc_task(d_inode(dentry)); 2000640708a2SPavel Emelyanov if (!task) 2001640708a2SPavel Emelyanov goto out; 2002640708a2SPavel Emelyanov 2003640708a2SPavel Emelyanov mm = get_task_mm(task); 2004640708a2SPavel Emelyanov put_task_struct(task); 2005640708a2SPavel Emelyanov if (!mm) 2006640708a2SPavel Emelyanov goto out; 2007640708a2SPavel Emelyanov 2008640708a2SPavel Emelyanov rc = dname_to_vma_addr(dentry, &vm_start, &vm_end); 2009640708a2SPavel Emelyanov if (rc) 2010640708a2SPavel Emelyanov goto out_mmput; 2011640708a2SPavel Emelyanov 201270335abbSArtem Fetishev rc = -ENOENT; 2013640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 2014640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 2015640708a2SPavel Emelyanov if (vma && vma->vm_file) { 2016640708a2SPavel Emelyanov *path = vma->vm_file->f_path; 2017640708a2SPavel Emelyanov path_get(path); 2018640708a2SPavel Emelyanov rc = 0; 2019640708a2SPavel Emelyanov } 2020640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2021640708a2SPavel Emelyanov 2022640708a2SPavel Emelyanov out_mmput: 2023640708a2SPavel Emelyanov mmput(mm); 2024640708a2SPavel Emelyanov out: 2025640708a2SPavel Emelyanov return rc; 2026640708a2SPavel Emelyanov } 2027640708a2SPavel Emelyanov 2028640708a2SPavel Emelyanov struct map_files_info { 2029*20d28cdeSAlexey Dobriyan unsigned long start; 2030*20d28cdeSAlexey Dobriyan unsigned long end; 20317b540d06SAl Viro fmode_t mode; 2032640708a2SPavel Emelyanov }; 2033640708a2SPavel Emelyanov 2034bdb4d100SCalvin Owens /* 2035bdb4d100SCalvin Owens * Only allow CAP_SYS_ADMIN to follow the links, due to concerns about how the 2036bdb4d100SCalvin Owens * symlinks may be used to bypass permissions on ancestor directories in the 2037bdb4d100SCalvin Owens * path to the file in question. 2038bdb4d100SCalvin Owens */ 2039bdb4d100SCalvin Owens static const char * 20406b255391SAl Viro proc_map_files_get_link(struct dentry *dentry, 2041fceef393SAl Viro struct inode *inode, 2042fceef393SAl Viro struct delayed_call *done) 2043bdb4d100SCalvin Owens { 2044bdb4d100SCalvin Owens if (!capable(CAP_SYS_ADMIN)) 2045bdb4d100SCalvin Owens return ERR_PTR(-EPERM); 2046bdb4d100SCalvin Owens 2047fceef393SAl Viro return proc_pid_get_link(dentry, inode, done); 2048bdb4d100SCalvin Owens } 2049bdb4d100SCalvin Owens 2050bdb4d100SCalvin Owens /* 20516b255391SAl Viro * Identical to proc_pid_link_inode_operations except for get_link() 2052bdb4d100SCalvin Owens */ 2053bdb4d100SCalvin Owens static const struct inode_operations proc_map_files_link_inode_operations = { 2054bdb4d100SCalvin Owens .readlink = proc_pid_readlink, 20556b255391SAl Viro .get_link = proc_map_files_get_link, 2056bdb4d100SCalvin Owens .setattr = proc_setattr, 2057bdb4d100SCalvin Owens }; 2058bdb4d100SCalvin Owens 2059c52a47acSAl Viro static int 2060640708a2SPavel Emelyanov proc_map_files_instantiate(struct inode *dir, struct dentry *dentry, 2061640708a2SPavel Emelyanov struct task_struct *task, const void *ptr) 2062640708a2SPavel Emelyanov { 20637b540d06SAl Viro fmode_t mode = (fmode_t)(unsigned long)ptr; 2064640708a2SPavel Emelyanov struct proc_inode *ei; 2065640708a2SPavel Emelyanov struct inode *inode; 2066640708a2SPavel Emelyanov 2067db978da8SAndreas Gruenbacher inode = proc_pid_make_inode(dir->i_sb, task, S_IFLNK | 2068db978da8SAndreas Gruenbacher ((mode & FMODE_READ ) ? S_IRUSR : 0) | 2069db978da8SAndreas Gruenbacher ((mode & FMODE_WRITE) ? S_IWUSR : 0)); 2070640708a2SPavel Emelyanov if (!inode) 2071c52a47acSAl Viro return -ENOENT; 2072640708a2SPavel Emelyanov 2073640708a2SPavel Emelyanov ei = PROC_I(inode); 20746b255391SAl Viro ei->op.proc_get_link = map_files_get_link; 2075640708a2SPavel Emelyanov 2076bdb4d100SCalvin Owens inode->i_op = &proc_map_files_link_inode_operations; 2077640708a2SPavel Emelyanov inode->i_size = 64; 2078640708a2SPavel Emelyanov 2079640708a2SPavel Emelyanov d_set_d_op(dentry, &tid_map_files_dentry_operations); 2080640708a2SPavel Emelyanov d_add(dentry, inode); 2081640708a2SPavel Emelyanov 2082c52a47acSAl Viro return 0; 2083640708a2SPavel Emelyanov } 2084640708a2SPavel Emelyanov 2085640708a2SPavel Emelyanov static struct dentry *proc_map_files_lookup(struct inode *dir, 208600cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 2087640708a2SPavel Emelyanov { 2088640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 2089640708a2SPavel Emelyanov struct vm_area_struct *vma; 2090640708a2SPavel Emelyanov struct task_struct *task; 2091c52a47acSAl Viro int result; 2092640708a2SPavel Emelyanov struct mm_struct *mm; 2093640708a2SPavel Emelyanov 2094c52a47acSAl Viro result = -ENOENT; 2095640708a2SPavel Emelyanov task = get_proc_task(dir); 2096640708a2SPavel Emelyanov if (!task) 2097640708a2SPavel Emelyanov goto out; 2098640708a2SPavel Emelyanov 2099c52a47acSAl Viro result = -EACCES; 2100caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) 2101640708a2SPavel Emelyanov goto out_put_task; 2102640708a2SPavel Emelyanov 2103c52a47acSAl Viro result = -ENOENT; 2104640708a2SPavel Emelyanov if (dname_to_vma_addr(dentry, &vm_start, &vm_end)) 2105eb94cd96SCyrill Gorcunov goto out_put_task; 2106640708a2SPavel Emelyanov 2107640708a2SPavel Emelyanov mm = get_task_mm(task); 2108640708a2SPavel Emelyanov if (!mm) 2109eb94cd96SCyrill Gorcunov goto out_put_task; 2110640708a2SPavel Emelyanov 2111640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 2112640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 2113640708a2SPavel Emelyanov if (!vma) 2114640708a2SPavel Emelyanov goto out_no_vma; 2115640708a2SPavel Emelyanov 211605f56484SStanislav Kinsbursky if (vma->vm_file) 21177b540d06SAl Viro result = proc_map_files_instantiate(dir, dentry, task, 21187b540d06SAl Viro (void *)(unsigned long)vma->vm_file->f_mode); 2119640708a2SPavel Emelyanov 2120640708a2SPavel Emelyanov out_no_vma: 2121640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2122640708a2SPavel Emelyanov mmput(mm); 2123640708a2SPavel Emelyanov out_put_task: 2124640708a2SPavel Emelyanov put_task_struct(task); 2125640708a2SPavel Emelyanov out: 2126c52a47acSAl Viro return ERR_PTR(result); 2127640708a2SPavel Emelyanov } 2128640708a2SPavel Emelyanov 2129640708a2SPavel Emelyanov static const struct inode_operations proc_map_files_inode_operations = { 2130640708a2SPavel Emelyanov .lookup = proc_map_files_lookup, 2131640708a2SPavel Emelyanov .permission = proc_fd_permission, 2132640708a2SPavel Emelyanov .setattr = proc_setattr, 2133640708a2SPavel Emelyanov }; 2134640708a2SPavel Emelyanov 2135640708a2SPavel Emelyanov static int 2136f0c3b509SAl Viro proc_map_files_readdir(struct file *file, struct dir_context *ctx) 2137640708a2SPavel Emelyanov { 2138640708a2SPavel Emelyanov struct vm_area_struct *vma; 2139640708a2SPavel Emelyanov struct task_struct *task; 2140640708a2SPavel Emelyanov struct mm_struct *mm; 2141f0c3b509SAl Viro unsigned long nr_files, pos, i; 2142f0c3b509SAl Viro struct flex_array *fa = NULL; 2143f0c3b509SAl Viro struct map_files_info info; 2144f0c3b509SAl Viro struct map_files_info *p; 2145640708a2SPavel Emelyanov int ret; 2146640708a2SPavel Emelyanov 2147640708a2SPavel Emelyanov ret = -ENOENT; 2148f0c3b509SAl Viro task = get_proc_task(file_inode(file)); 2149640708a2SPavel Emelyanov if (!task) 2150640708a2SPavel Emelyanov goto out; 2151640708a2SPavel Emelyanov 2152640708a2SPavel Emelyanov ret = -EACCES; 2153caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) 2154640708a2SPavel Emelyanov goto out_put_task; 2155640708a2SPavel Emelyanov 2156640708a2SPavel Emelyanov ret = 0; 2157f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 2158eb94cd96SCyrill Gorcunov goto out_put_task; 2159640708a2SPavel Emelyanov 2160640708a2SPavel Emelyanov mm = get_task_mm(task); 2161640708a2SPavel Emelyanov if (!mm) 2162eb94cd96SCyrill Gorcunov goto out_put_task; 2163640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 2164640708a2SPavel Emelyanov 2165640708a2SPavel Emelyanov nr_files = 0; 2166640708a2SPavel Emelyanov 2167640708a2SPavel Emelyanov /* 2168640708a2SPavel Emelyanov * We need two passes here: 2169640708a2SPavel Emelyanov * 2170640708a2SPavel Emelyanov * 1) Collect vmas of mapped files with mmap_sem taken 2171640708a2SPavel Emelyanov * 2) Release mmap_sem and instantiate entries 2172640708a2SPavel Emelyanov * 2173640708a2SPavel Emelyanov * otherwise we get lockdep complained, since filldir() 2174640708a2SPavel Emelyanov * routine might require mmap_sem taken in might_fault(). 2175640708a2SPavel Emelyanov */ 2176640708a2SPavel Emelyanov 2177640708a2SPavel Emelyanov for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) { 2178f0c3b509SAl Viro if (vma->vm_file && ++pos > ctx->pos) 2179640708a2SPavel Emelyanov nr_files++; 2180640708a2SPavel Emelyanov } 2181640708a2SPavel Emelyanov 2182640708a2SPavel Emelyanov if (nr_files) { 2183640708a2SPavel Emelyanov fa = flex_array_alloc(sizeof(info), nr_files, 2184640708a2SPavel Emelyanov GFP_KERNEL); 2185640708a2SPavel Emelyanov if (!fa || flex_array_prealloc(fa, 0, nr_files, 2186640708a2SPavel Emelyanov GFP_KERNEL)) { 2187640708a2SPavel Emelyanov ret = -ENOMEM; 2188640708a2SPavel Emelyanov if (fa) 2189640708a2SPavel Emelyanov flex_array_free(fa); 2190640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2191640708a2SPavel Emelyanov mmput(mm); 2192eb94cd96SCyrill Gorcunov goto out_put_task; 2193640708a2SPavel Emelyanov } 2194640708a2SPavel Emelyanov for (i = 0, vma = mm->mmap, pos = 2; vma; 2195640708a2SPavel Emelyanov vma = vma->vm_next) { 2196640708a2SPavel Emelyanov if (!vma->vm_file) 2197640708a2SPavel Emelyanov continue; 2198f0c3b509SAl Viro if (++pos <= ctx->pos) 2199640708a2SPavel Emelyanov continue; 2200640708a2SPavel Emelyanov 2201*20d28cdeSAlexey Dobriyan info.start = vma->vm_start; 2202*20d28cdeSAlexey Dobriyan info.end = vma->vm_end; 22037b540d06SAl Viro info.mode = vma->vm_file->f_mode; 2204640708a2SPavel Emelyanov if (flex_array_put(fa, i++, &info, GFP_KERNEL)) 2205640708a2SPavel Emelyanov BUG(); 2206640708a2SPavel Emelyanov } 2207640708a2SPavel Emelyanov } 2208640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2209640708a2SPavel Emelyanov 2210640708a2SPavel Emelyanov for (i = 0; i < nr_files; i++) { 2211*20d28cdeSAlexey Dobriyan char buf[4 * sizeof(long) + 2]; /* max: %lx-%lx\0 */ 2212*20d28cdeSAlexey Dobriyan unsigned int len; 2213*20d28cdeSAlexey Dobriyan 2214640708a2SPavel Emelyanov p = flex_array_get(fa, i); 2215*20d28cdeSAlexey Dobriyan len = snprintf(buf, sizeof(buf), "%lx-%lx", p->start, p->end); 2216f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, 2217*20d28cdeSAlexey Dobriyan buf, len, 2218640708a2SPavel Emelyanov proc_map_files_instantiate, 22197b540d06SAl Viro task, 2220f0c3b509SAl Viro (void *)(unsigned long)p->mode)) 2221640708a2SPavel Emelyanov break; 2222f0c3b509SAl Viro ctx->pos++; 2223640708a2SPavel Emelyanov } 2224640708a2SPavel Emelyanov if (fa) 2225640708a2SPavel Emelyanov flex_array_free(fa); 2226640708a2SPavel Emelyanov mmput(mm); 2227640708a2SPavel Emelyanov 2228640708a2SPavel Emelyanov out_put_task: 2229640708a2SPavel Emelyanov put_task_struct(task); 2230640708a2SPavel Emelyanov out: 2231640708a2SPavel Emelyanov return ret; 2232640708a2SPavel Emelyanov } 2233640708a2SPavel Emelyanov 2234640708a2SPavel Emelyanov static const struct file_operations proc_map_files_operations = { 2235640708a2SPavel Emelyanov .read = generic_read_dir, 2236f50752eaSAl Viro .iterate_shared = proc_map_files_readdir, 2237f50752eaSAl Viro .llseek = generic_file_llseek, 2238640708a2SPavel Emelyanov }; 2239640708a2SPavel Emelyanov 2240b18b6a9cSNicolas Pitre #if defined(CONFIG_CHECKPOINT_RESTORE) && defined(CONFIG_POSIX_TIMERS) 224148f6a7a5SPavel Emelyanov struct timers_private { 224248f6a7a5SPavel Emelyanov struct pid *pid; 224348f6a7a5SPavel Emelyanov struct task_struct *task; 224448f6a7a5SPavel Emelyanov struct sighand_struct *sighand; 224557b8015eSPavel Emelyanov struct pid_namespace *ns; 224648f6a7a5SPavel Emelyanov unsigned long flags; 224748f6a7a5SPavel Emelyanov }; 224848f6a7a5SPavel Emelyanov 224948f6a7a5SPavel Emelyanov static void *timers_start(struct seq_file *m, loff_t *pos) 225048f6a7a5SPavel Emelyanov { 225148f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 225248f6a7a5SPavel Emelyanov 225348f6a7a5SPavel Emelyanov tp->task = get_pid_task(tp->pid, PIDTYPE_PID); 225448f6a7a5SPavel Emelyanov if (!tp->task) 225548f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 225648f6a7a5SPavel Emelyanov 225748f6a7a5SPavel Emelyanov tp->sighand = lock_task_sighand(tp->task, &tp->flags); 225848f6a7a5SPavel Emelyanov if (!tp->sighand) 225948f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 226048f6a7a5SPavel Emelyanov 226148f6a7a5SPavel Emelyanov return seq_list_start(&tp->task->signal->posix_timers, *pos); 226248f6a7a5SPavel Emelyanov } 226348f6a7a5SPavel Emelyanov 226448f6a7a5SPavel Emelyanov static void *timers_next(struct seq_file *m, void *v, loff_t *pos) 226548f6a7a5SPavel Emelyanov { 226648f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 226748f6a7a5SPavel Emelyanov return seq_list_next(v, &tp->task->signal->posix_timers, pos); 226848f6a7a5SPavel Emelyanov } 226948f6a7a5SPavel Emelyanov 227048f6a7a5SPavel Emelyanov static void timers_stop(struct seq_file *m, void *v) 227148f6a7a5SPavel Emelyanov { 227248f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 227348f6a7a5SPavel Emelyanov 227448f6a7a5SPavel Emelyanov if (tp->sighand) { 227548f6a7a5SPavel Emelyanov unlock_task_sighand(tp->task, &tp->flags); 227648f6a7a5SPavel Emelyanov tp->sighand = NULL; 227748f6a7a5SPavel Emelyanov } 227848f6a7a5SPavel Emelyanov 227948f6a7a5SPavel Emelyanov if (tp->task) { 228048f6a7a5SPavel Emelyanov put_task_struct(tp->task); 228148f6a7a5SPavel Emelyanov tp->task = NULL; 228248f6a7a5SPavel Emelyanov } 228348f6a7a5SPavel Emelyanov } 228448f6a7a5SPavel Emelyanov 228548f6a7a5SPavel Emelyanov static int show_timer(struct seq_file *m, void *v) 228648f6a7a5SPavel Emelyanov { 228748f6a7a5SPavel Emelyanov struct k_itimer *timer; 228857b8015eSPavel Emelyanov struct timers_private *tp = m->private; 228957b8015eSPavel Emelyanov int notify; 2290cedbccabSAlexey Dobriyan static const char * const nstr[] = { 229157b8015eSPavel Emelyanov [SIGEV_SIGNAL] = "signal", 229257b8015eSPavel Emelyanov [SIGEV_NONE] = "none", 229357b8015eSPavel Emelyanov [SIGEV_THREAD] = "thread", 229457b8015eSPavel Emelyanov }; 229548f6a7a5SPavel Emelyanov 229648f6a7a5SPavel Emelyanov timer = list_entry((struct list_head *)v, struct k_itimer, list); 229757b8015eSPavel Emelyanov notify = timer->it_sigev_notify; 229857b8015eSPavel Emelyanov 229948f6a7a5SPavel Emelyanov seq_printf(m, "ID: %d\n", timer->it_id); 2300ba3edf1fSLinus Torvalds seq_printf(m, "signal: %d/%px\n", 230125ce3191SJoe Perches timer->sigq->info.si_signo, 230257b8015eSPavel Emelyanov timer->sigq->info.si_value.sival_ptr); 230357b8015eSPavel Emelyanov seq_printf(m, "notify: %s/%s.%d\n", 230457b8015eSPavel Emelyanov nstr[notify & ~SIGEV_THREAD_ID], 230557b8015eSPavel Emelyanov (notify & SIGEV_THREAD_ID) ? "tid" : "pid", 230657b8015eSPavel Emelyanov pid_nr_ns(timer->it_pid, tp->ns)); 230715ef0298SPavel Tikhomirov seq_printf(m, "ClockID: %d\n", timer->it_clock); 230848f6a7a5SPavel Emelyanov 230948f6a7a5SPavel Emelyanov return 0; 231048f6a7a5SPavel Emelyanov } 231148f6a7a5SPavel Emelyanov 231248f6a7a5SPavel Emelyanov static const struct seq_operations proc_timers_seq_ops = { 231348f6a7a5SPavel Emelyanov .start = timers_start, 231448f6a7a5SPavel Emelyanov .next = timers_next, 231548f6a7a5SPavel Emelyanov .stop = timers_stop, 231648f6a7a5SPavel Emelyanov .show = show_timer, 231748f6a7a5SPavel Emelyanov }; 231848f6a7a5SPavel Emelyanov 231948f6a7a5SPavel Emelyanov static int proc_timers_open(struct inode *inode, struct file *file) 232048f6a7a5SPavel Emelyanov { 232148f6a7a5SPavel Emelyanov struct timers_private *tp; 232248f6a7a5SPavel Emelyanov 232348f6a7a5SPavel Emelyanov tp = __seq_open_private(file, &proc_timers_seq_ops, 232448f6a7a5SPavel Emelyanov sizeof(struct timers_private)); 232548f6a7a5SPavel Emelyanov if (!tp) 232648f6a7a5SPavel Emelyanov return -ENOMEM; 232748f6a7a5SPavel Emelyanov 232848f6a7a5SPavel Emelyanov tp->pid = proc_pid(inode); 232957b8015eSPavel Emelyanov tp->ns = inode->i_sb->s_fs_info; 233048f6a7a5SPavel Emelyanov return 0; 233148f6a7a5SPavel Emelyanov } 233248f6a7a5SPavel Emelyanov 233348f6a7a5SPavel Emelyanov static const struct file_operations proc_timers_operations = { 233448f6a7a5SPavel Emelyanov .open = proc_timers_open, 233548f6a7a5SPavel Emelyanov .read = seq_read, 233648f6a7a5SPavel Emelyanov .llseek = seq_lseek, 233748f6a7a5SPavel Emelyanov .release = seq_release_private, 233848f6a7a5SPavel Emelyanov }; 2339b5946beaSEric Engestrom #endif 2340640708a2SPavel Emelyanov 23415de23d43SJohn Stultz static ssize_t timerslack_ns_write(struct file *file, const char __user *buf, 23425de23d43SJohn Stultz size_t count, loff_t *offset) 23435de23d43SJohn Stultz { 23445de23d43SJohn Stultz struct inode *inode = file_inode(file); 23455de23d43SJohn Stultz struct task_struct *p; 23465de23d43SJohn Stultz u64 slack_ns; 23475de23d43SJohn Stultz int err; 23485de23d43SJohn Stultz 23495de23d43SJohn Stultz err = kstrtoull_from_user(buf, count, 10, &slack_ns); 23505de23d43SJohn Stultz if (err < 0) 23515de23d43SJohn Stultz return err; 23525de23d43SJohn Stultz 23535de23d43SJohn Stultz p = get_proc_task(inode); 23545de23d43SJohn Stultz if (!p) 23555de23d43SJohn Stultz return -ESRCH; 23565de23d43SJohn Stultz 23574b2bd5feSJohn Stultz if (p != current) { 23587abbaf94SJohn Stultz if (!capable(CAP_SYS_NICE)) { 23597abbaf94SJohn Stultz count = -EPERM; 23607abbaf94SJohn Stultz goto out; 23617abbaf94SJohn Stultz } 23627abbaf94SJohn Stultz 2363904763e1SJohn Stultz err = security_task_setscheduler(p); 2364904763e1SJohn Stultz if (err) { 2365904763e1SJohn Stultz count = err; 2366904763e1SJohn Stultz goto out; 2367904763e1SJohn Stultz } 23684b2bd5feSJohn Stultz } 2369904763e1SJohn Stultz 23705de23d43SJohn Stultz task_lock(p); 23715de23d43SJohn Stultz if (slack_ns == 0) 23725de23d43SJohn Stultz p->timer_slack_ns = p->default_timer_slack_ns; 23735de23d43SJohn Stultz else 23745de23d43SJohn Stultz p->timer_slack_ns = slack_ns; 23755de23d43SJohn Stultz task_unlock(p); 23765de23d43SJohn Stultz 23777abbaf94SJohn Stultz out: 23785de23d43SJohn Stultz put_task_struct(p); 23795de23d43SJohn Stultz 23805de23d43SJohn Stultz return count; 23815de23d43SJohn Stultz } 23825de23d43SJohn Stultz 23835de23d43SJohn Stultz static int timerslack_ns_show(struct seq_file *m, void *v) 23845de23d43SJohn Stultz { 23855de23d43SJohn Stultz struct inode *inode = m->private; 23865de23d43SJohn Stultz struct task_struct *p; 23875de23d43SJohn Stultz int err = 0; 23885de23d43SJohn Stultz 23895de23d43SJohn Stultz p = get_proc_task(inode); 23905de23d43SJohn Stultz if (!p) 23915de23d43SJohn Stultz return -ESRCH; 23925de23d43SJohn Stultz 23934b2bd5feSJohn Stultz if (p != current) { 23944b2bd5feSJohn Stultz 23957abbaf94SJohn Stultz if (!capable(CAP_SYS_NICE)) { 23967abbaf94SJohn Stultz err = -EPERM; 23977abbaf94SJohn Stultz goto out; 23987abbaf94SJohn Stultz } 2399904763e1SJohn Stultz err = security_task_getscheduler(p); 2400904763e1SJohn Stultz if (err) 2401904763e1SJohn Stultz goto out; 24024b2bd5feSJohn Stultz } 2403904763e1SJohn Stultz 24045de23d43SJohn Stultz task_lock(p); 24055de23d43SJohn Stultz seq_printf(m, "%llu\n", p->timer_slack_ns); 24065de23d43SJohn Stultz task_unlock(p); 24075de23d43SJohn Stultz 24087abbaf94SJohn Stultz out: 24095de23d43SJohn Stultz put_task_struct(p); 24105de23d43SJohn Stultz 24115de23d43SJohn Stultz return err; 24125de23d43SJohn Stultz } 24135de23d43SJohn Stultz 24145de23d43SJohn Stultz static int timerslack_ns_open(struct inode *inode, struct file *filp) 24155de23d43SJohn Stultz { 24165de23d43SJohn Stultz return single_open(filp, timerslack_ns_show, inode); 24175de23d43SJohn Stultz } 24185de23d43SJohn Stultz 24195de23d43SJohn Stultz static const struct file_operations proc_pid_set_timerslack_ns_operations = { 24205de23d43SJohn Stultz .open = timerslack_ns_open, 24215de23d43SJohn Stultz .read = seq_read, 24225de23d43SJohn Stultz .write = timerslack_ns_write, 24235de23d43SJohn Stultz .llseek = seq_lseek, 24245de23d43SJohn Stultz .release = single_release, 24255de23d43SJohn Stultz }; 24265de23d43SJohn Stultz 2427c52a47acSAl Viro static int proc_pident_instantiate(struct inode *dir, 2428c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2429444ceed8SEric W. Biederman { 2430c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2431444ceed8SEric W. Biederman struct inode *inode; 2432444ceed8SEric W. Biederman struct proc_inode *ei; 2433444ceed8SEric W. Biederman 2434db978da8SAndreas Gruenbacher inode = proc_pid_make_inode(dir->i_sb, task, p->mode); 2435444ceed8SEric W. Biederman if (!inode) 2436444ceed8SEric W. Biederman goto out; 2437444ceed8SEric W. Biederman 2438444ceed8SEric W. Biederman ei = PROC_I(inode); 2439444ceed8SEric W. Biederman if (S_ISDIR(inode->i_mode)) 2440bfe86848SMiklos Szeredi set_nlink(inode, 2); /* Use getattr to fix if necessary */ 2441444ceed8SEric W. Biederman if (p->iop) 2442444ceed8SEric W. Biederman inode->i_op = p->iop; 2443444ceed8SEric W. Biederman if (p->fop) 2444444ceed8SEric W. Biederman inode->i_fop = p->fop; 2445444ceed8SEric W. Biederman ei->op = p->op; 2446fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2447444ceed8SEric W. Biederman d_add(dentry, inode); 2448444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 24490b728e19SAl Viro if (pid_revalidate(dentry, 0)) 2450c52a47acSAl Viro return 0; 2451444ceed8SEric W. Biederman out: 2452c52a47acSAl Viro return -ENOENT; 2453444ceed8SEric W. Biederman } 2454444ceed8SEric W. Biederman 24551da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 24561da177e4SLinus Torvalds struct dentry *dentry, 2457c5141e6dSEric Dumazet const struct pid_entry *ents, 24587bcd6b0eSEric W. Biederman unsigned int nents) 24591da177e4SLinus Torvalds { 2460c52a47acSAl Viro int error; 246199f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2462c5141e6dSEric Dumazet const struct pid_entry *p, *last; 24631da177e4SLinus Torvalds 2464c52a47acSAl Viro error = -ENOENT; 24651da177e4SLinus Torvalds 246699f89551SEric W. Biederman if (!task) 246799f89551SEric W. Biederman goto out_no_task; 24681da177e4SLinus Torvalds 246920cdc894SEric W. Biederman /* 247020cdc894SEric W. Biederman * Yes, it does not scale. And it should not. Don't add 247120cdc894SEric W. Biederman * new entries into /proc/<tgid>/ without very good reasons. 247220cdc894SEric W. Biederman */ 2473bac5f5d5SAlexey Dobriyan last = &ents[nents]; 2474bac5f5d5SAlexey Dobriyan for (p = ents; p < last; p++) { 24751da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 24761da177e4SLinus Torvalds continue; 24771da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 24781da177e4SLinus Torvalds break; 24791da177e4SLinus Torvalds } 2480bac5f5d5SAlexey Dobriyan if (p >= last) 24811da177e4SLinus Torvalds goto out; 24821da177e4SLinus Torvalds 2483444ceed8SEric W. Biederman error = proc_pident_instantiate(dir, dentry, task, p); 24841da177e4SLinus Torvalds out: 248599f89551SEric W. Biederman put_task_struct(task); 248699f89551SEric W. Biederman out_no_task: 2487c52a47acSAl Viro return ERR_PTR(error); 24881da177e4SLinus Torvalds } 24891da177e4SLinus Torvalds 2490f0c3b509SAl Viro static int proc_pident_readdir(struct file *file, struct dir_context *ctx, 2491c5141e6dSEric Dumazet const struct pid_entry *ents, unsigned int nents) 249228a6d671SEric W. Biederman { 2493f0c3b509SAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 2494f0c3b509SAl Viro const struct pid_entry *p; 249528a6d671SEric W. Biederman 249628a6d671SEric W. Biederman if (!task) 2497f0c3b509SAl Viro return -ENOENT; 249828a6d671SEric W. Biederman 2499f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 250028a6d671SEric W. Biederman goto out; 25011da177e4SLinus Torvalds 2502f0c3b509SAl Viro if (ctx->pos >= nents + 2) 2503f0c3b509SAl Viro goto out; 2504f0c3b509SAl Viro 2505bac5f5d5SAlexey Dobriyan for (p = ents + (ctx->pos - 2); p < ents + nents; p++) { 2506f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, p->name, p->len, 2507f0c3b509SAl Viro proc_pident_instantiate, task, p)) 2508f0c3b509SAl Viro break; 2509f0c3b509SAl Viro ctx->pos++; 2510f0c3b509SAl Viro } 251128a6d671SEric W. Biederman out: 251261a28784SEric W. Biederman put_task_struct(task); 2513f0c3b509SAl Viro return 0; 25141da177e4SLinus Torvalds } 25151da177e4SLinus Torvalds 25161da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 251728a6d671SEric W. Biederman static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 251828a6d671SEric W. Biederman size_t count, loff_t *ppos) 251928a6d671SEric W. Biederman { 2520496ad9aaSAl Viro struct inode * inode = file_inode(file); 252104ff9708SAl Viro char *p = NULL; 252228a6d671SEric W. Biederman ssize_t length; 252328a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 252428a6d671SEric W. Biederman 252528a6d671SEric W. Biederman if (!task) 252604ff9708SAl Viro return -ESRCH; 252728a6d671SEric W. Biederman 252828a6d671SEric W. Biederman length = security_getprocattr(task, 25292fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 253004ff9708SAl Viro &p); 253128a6d671SEric W. Biederman put_task_struct(task); 253204ff9708SAl Viro if (length > 0) 253304ff9708SAl Viro length = simple_read_from_buffer(buf, count, ppos, p, length); 253404ff9708SAl Viro kfree(p); 253528a6d671SEric W. Biederman return length; 253628a6d671SEric W. Biederman } 253728a6d671SEric W. Biederman 253828a6d671SEric W. Biederman static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 253928a6d671SEric W. Biederman size_t count, loff_t *ppos) 254028a6d671SEric W. Biederman { 2541496ad9aaSAl Viro struct inode * inode = file_inode(file); 2542bb646cdbSAl Viro void *page; 254328a6d671SEric W. Biederman ssize_t length; 254428a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 254528a6d671SEric W. Biederman 254628a6d671SEric W. Biederman length = -ESRCH; 254728a6d671SEric W. Biederman if (!task) 254828a6d671SEric W. Biederman goto out_no_task; 2549b21507e2SStephen Smalley 2550b21507e2SStephen Smalley /* A task may only write its own attributes. */ 2551b21507e2SStephen Smalley length = -EACCES; 2552b21507e2SStephen Smalley if (current != task) 2553b21507e2SStephen Smalley goto out; 2554b21507e2SStephen Smalley 255528a6d671SEric W. Biederman if (count > PAGE_SIZE) 255628a6d671SEric W. Biederman count = PAGE_SIZE; 255728a6d671SEric W. Biederman 255828a6d671SEric W. Biederman /* No partial writes. */ 255928a6d671SEric W. Biederman length = -EINVAL; 256028a6d671SEric W. Biederman if (*ppos != 0) 256128a6d671SEric W. Biederman goto out; 256228a6d671SEric W. Biederman 2563bb646cdbSAl Viro page = memdup_user(buf, count); 2564bb646cdbSAl Viro if (IS_ERR(page)) { 2565bb646cdbSAl Viro length = PTR_ERR(page); 256628a6d671SEric W. Biederman goto out; 2567bb646cdbSAl Viro } 256828a6d671SEric W. Biederman 2569107db7c7SDavid Howells /* Guard against adverse ptrace interaction */ 2570b21507e2SStephen Smalley length = mutex_lock_interruptible(¤t->signal->cred_guard_mutex); 2571107db7c7SDavid Howells if (length < 0) 2572107db7c7SDavid Howells goto out_free; 2573107db7c7SDavid Howells 2574b21507e2SStephen Smalley length = security_setprocattr(file->f_path.dentry->d_name.name, 2575bb646cdbSAl Viro page, count); 2576b21507e2SStephen Smalley mutex_unlock(¤t->signal->cred_guard_mutex); 257728a6d671SEric W. Biederman out_free: 2578bb646cdbSAl Viro kfree(page); 257928a6d671SEric W. Biederman out: 258028a6d671SEric W. Biederman put_task_struct(task); 258128a6d671SEric W. Biederman out_no_task: 258228a6d671SEric W. Biederman return length; 258328a6d671SEric W. Biederman } 258428a6d671SEric W. Biederman 258500977a59SArjan van de Ven static const struct file_operations proc_pid_attr_operations = { 258628a6d671SEric W. Biederman .read = proc_pid_attr_read, 258728a6d671SEric W. Biederman .write = proc_pid_attr_write, 258887df8424SArnd Bergmann .llseek = generic_file_llseek, 258928a6d671SEric W. Biederman }; 259028a6d671SEric W. Biederman 2591c5141e6dSEric Dumazet static const struct pid_entry attr_dir_stuff[] = { 2592631f9c18SAlexey Dobriyan REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2593631f9c18SAlexey Dobriyan REG("prev", S_IRUGO, proc_pid_attr_operations), 2594631f9c18SAlexey Dobriyan REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2595631f9c18SAlexey Dobriyan REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2596631f9c18SAlexey Dobriyan REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2597631f9c18SAlexey Dobriyan REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 259828a6d671SEric W. Biederman }; 259928a6d671SEric W. Biederman 2600f0c3b509SAl Viro static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx) 26011da177e4SLinus Torvalds { 2602f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 260372d9dcfcSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 26041da177e4SLinus Torvalds } 26051da177e4SLinus Torvalds 260600977a59SArjan van de Ven static const struct file_operations proc_attr_dir_operations = { 26071da177e4SLinus Torvalds .read = generic_read_dir, 2608f50752eaSAl Viro .iterate_shared = proc_attr_dir_readdir, 2609f50752eaSAl Viro .llseek = generic_file_llseek, 26101da177e4SLinus Torvalds }; 26111da177e4SLinus Torvalds 261272d9dcfcSEric W. Biederman static struct dentry *proc_attr_dir_lookup(struct inode *dir, 261300cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 26141da177e4SLinus Torvalds { 26157bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 26167bcd6b0eSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 26171da177e4SLinus Torvalds } 26181da177e4SLinus Torvalds 2619c5ef1c42SArjan van de Ven static const struct inode_operations proc_attr_dir_inode_operations = { 262072d9dcfcSEric W. Biederman .lookup = proc_attr_dir_lookup, 262199f89551SEric W. Biederman .getattr = pid_getattr, 26226d76fa58SLinus Torvalds .setattr = proc_setattr, 26231da177e4SLinus Torvalds }; 26241da177e4SLinus Torvalds 26251da177e4SLinus Torvalds #endif 26261da177e4SLinus Torvalds 2627698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 26283cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, 26293cb4a0bbSKawai, Hidehiro size_t count, loff_t *ppos) 26303cb4a0bbSKawai, Hidehiro { 2631496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 26323cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 26333cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF]; 26343cb4a0bbSKawai, Hidehiro size_t len; 26353cb4a0bbSKawai, Hidehiro int ret; 26363cb4a0bbSKawai, Hidehiro 26373cb4a0bbSKawai, Hidehiro if (!task) 26383cb4a0bbSKawai, Hidehiro return -ESRCH; 26393cb4a0bbSKawai, Hidehiro 26403cb4a0bbSKawai, Hidehiro ret = 0; 26413cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 26423cb4a0bbSKawai, Hidehiro if (mm) { 26433cb4a0bbSKawai, Hidehiro len = snprintf(buffer, sizeof(buffer), "%08lx\n", 26443cb4a0bbSKawai, Hidehiro ((mm->flags & MMF_DUMP_FILTER_MASK) >> 26453cb4a0bbSKawai, Hidehiro MMF_DUMP_FILTER_SHIFT)); 26463cb4a0bbSKawai, Hidehiro mmput(mm); 26473cb4a0bbSKawai, Hidehiro ret = simple_read_from_buffer(buf, count, ppos, buffer, len); 26483cb4a0bbSKawai, Hidehiro } 26493cb4a0bbSKawai, Hidehiro 26503cb4a0bbSKawai, Hidehiro put_task_struct(task); 26513cb4a0bbSKawai, Hidehiro 26523cb4a0bbSKawai, Hidehiro return ret; 26533cb4a0bbSKawai, Hidehiro } 26543cb4a0bbSKawai, Hidehiro 26553cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_write(struct file *file, 26563cb4a0bbSKawai, Hidehiro const char __user *buf, 26573cb4a0bbSKawai, Hidehiro size_t count, 26583cb4a0bbSKawai, Hidehiro loff_t *ppos) 26593cb4a0bbSKawai, Hidehiro { 26603cb4a0bbSKawai, Hidehiro struct task_struct *task; 26613cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 26623cb4a0bbSKawai, Hidehiro unsigned int val; 26633cb4a0bbSKawai, Hidehiro int ret; 26643cb4a0bbSKawai, Hidehiro int i; 26653cb4a0bbSKawai, Hidehiro unsigned long mask; 26663cb4a0bbSKawai, Hidehiro 2667774636e1SAlexey Dobriyan ret = kstrtouint_from_user(buf, count, 0, &val); 2668774636e1SAlexey Dobriyan if (ret < 0) 2669774636e1SAlexey Dobriyan return ret; 26703cb4a0bbSKawai, Hidehiro 26713cb4a0bbSKawai, Hidehiro ret = -ESRCH; 2672496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 26733cb4a0bbSKawai, Hidehiro if (!task) 26743cb4a0bbSKawai, Hidehiro goto out_no_task; 26753cb4a0bbSKawai, Hidehiro 26763cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 26773cb4a0bbSKawai, Hidehiro if (!mm) 26783cb4a0bbSKawai, Hidehiro goto out_no_mm; 267941a0c249SColin Ian King ret = 0; 26803cb4a0bbSKawai, Hidehiro 26813cb4a0bbSKawai, Hidehiro for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) { 26823cb4a0bbSKawai, Hidehiro if (val & mask) 26833cb4a0bbSKawai, Hidehiro set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 26843cb4a0bbSKawai, Hidehiro else 26853cb4a0bbSKawai, Hidehiro clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 26863cb4a0bbSKawai, Hidehiro } 26873cb4a0bbSKawai, Hidehiro 26883cb4a0bbSKawai, Hidehiro mmput(mm); 26893cb4a0bbSKawai, Hidehiro out_no_mm: 26903cb4a0bbSKawai, Hidehiro put_task_struct(task); 26913cb4a0bbSKawai, Hidehiro out_no_task: 2692774636e1SAlexey Dobriyan if (ret < 0) 26933cb4a0bbSKawai, Hidehiro return ret; 2694774636e1SAlexey Dobriyan return count; 26953cb4a0bbSKawai, Hidehiro } 26963cb4a0bbSKawai, Hidehiro 26973cb4a0bbSKawai, Hidehiro static const struct file_operations proc_coredump_filter_operations = { 26983cb4a0bbSKawai, Hidehiro .read = proc_coredump_filter_read, 26993cb4a0bbSKawai, Hidehiro .write = proc_coredump_filter_write, 270087df8424SArnd Bergmann .llseek = generic_file_llseek, 27013cb4a0bbSKawai, Hidehiro }; 27023cb4a0bbSKawai, Hidehiro #endif 27033cb4a0bbSKawai, Hidehiro 2704aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 270519aadc98SAlexey Dobriyan static int do_io_accounting(struct task_struct *task, struct seq_file *m, int whole) 2706aba76fdbSAndrew Morton { 2707940389b8SAndrea Righi struct task_io_accounting acct = task->ioac; 2708297c5d92SAndrea Righi unsigned long flags; 2709293eb1e7SVasiliy Kulikov int result; 2710297c5d92SAndrea Righi 2711293eb1e7SVasiliy Kulikov result = mutex_lock_killable(&task->signal->cred_guard_mutex); 2712293eb1e7SVasiliy Kulikov if (result) 2713293eb1e7SVasiliy Kulikov return result; 2714293eb1e7SVasiliy Kulikov 2715caaee623SJann Horn if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) { 2716293eb1e7SVasiliy Kulikov result = -EACCES; 2717293eb1e7SVasiliy Kulikov goto out_unlock; 2718293eb1e7SVasiliy Kulikov } 27191d1221f3SVasiliy Kulikov 27205995477aSAndrea Righi if (whole && lock_task_sighand(task, &flags)) { 2721b2d002dbSAndrea Righi struct task_struct *t = task; 2722297c5d92SAndrea Righi 27235995477aSAndrea Righi task_io_accounting_add(&acct, &task->signal->ioac); 27245995477aSAndrea Righi while_each_thread(task, t) 27255995477aSAndrea Righi task_io_accounting_add(&acct, &t->ioac); 2726297c5d92SAndrea Righi 2727297c5d92SAndrea Righi unlock_task_sighand(task, &flags); 2728297c5d92SAndrea Righi } 272925ce3191SJoe Perches seq_printf(m, 2730aba76fdbSAndrew Morton "rchar: %llu\n" 2731aba76fdbSAndrew Morton "wchar: %llu\n" 2732aba76fdbSAndrew Morton "syscr: %llu\n" 2733aba76fdbSAndrew Morton "syscw: %llu\n" 2734aba76fdbSAndrew Morton "read_bytes: %llu\n" 2735aba76fdbSAndrew Morton "write_bytes: %llu\n" 2736aba76fdbSAndrew Morton "cancelled_write_bytes: %llu\n", 27377c44319dSAlexander Beregalov (unsigned long long)acct.rchar, 27387c44319dSAlexander Beregalov (unsigned long long)acct.wchar, 27397c44319dSAlexander Beregalov (unsigned long long)acct.syscr, 27407c44319dSAlexander Beregalov (unsigned long long)acct.syscw, 27417c44319dSAlexander Beregalov (unsigned long long)acct.read_bytes, 27427c44319dSAlexander Beregalov (unsigned long long)acct.write_bytes, 27437c44319dSAlexander Beregalov (unsigned long long)acct.cancelled_write_bytes); 274425ce3191SJoe Perches result = 0; 274525ce3191SJoe Perches 2746293eb1e7SVasiliy Kulikov out_unlock: 2747293eb1e7SVasiliy Kulikov mutex_unlock(&task->signal->cred_guard_mutex); 2748293eb1e7SVasiliy Kulikov return result; 2749aba76fdbSAndrew Morton } 2750297c5d92SAndrea Righi 275119aadc98SAlexey Dobriyan static int proc_tid_io_accounting(struct seq_file *m, struct pid_namespace *ns, 275219aadc98SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2753297c5d92SAndrea Righi { 275419aadc98SAlexey Dobriyan return do_io_accounting(task, m, 0); 2755297c5d92SAndrea Righi } 2756297c5d92SAndrea Righi 275719aadc98SAlexey Dobriyan static int proc_tgid_io_accounting(struct seq_file *m, struct pid_namespace *ns, 275819aadc98SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2759297c5d92SAndrea Righi { 276019aadc98SAlexey Dobriyan return do_io_accounting(task, m, 1); 2761297c5d92SAndrea Righi } 2762297c5d92SAndrea Righi #endif /* CONFIG_TASK_IO_ACCOUNTING */ 2763aba76fdbSAndrew Morton 276422d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 276522d917d8SEric W. Biederman static int proc_id_map_open(struct inode *inode, struct file *file, 2766ccf94f1bSFabian Frederick const struct seq_operations *seq_ops) 276722d917d8SEric W. Biederman { 276822d917d8SEric W. Biederman struct user_namespace *ns = NULL; 276922d917d8SEric W. Biederman struct task_struct *task; 277022d917d8SEric W. Biederman struct seq_file *seq; 277122d917d8SEric W. Biederman int ret = -EINVAL; 277222d917d8SEric W. Biederman 277322d917d8SEric W. Biederman task = get_proc_task(inode); 277422d917d8SEric W. Biederman if (task) { 277522d917d8SEric W. Biederman rcu_read_lock(); 277622d917d8SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 277722d917d8SEric W. Biederman rcu_read_unlock(); 277822d917d8SEric W. Biederman put_task_struct(task); 277922d917d8SEric W. Biederman } 278022d917d8SEric W. Biederman if (!ns) 278122d917d8SEric W. Biederman goto err; 278222d917d8SEric W. Biederman 278322d917d8SEric W. Biederman ret = seq_open(file, seq_ops); 278422d917d8SEric W. Biederman if (ret) 278522d917d8SEric W. Biederman goto err_put_ns; 278622d917d8SEric W. Biederman 278722d917d8SEric W. Biederman seq = file->private_data; 278822d917d8SEric W. Biederman seq->private = ns; 278922d917d8SEric W. Biederman 279022d917d8SEric W. Biederman return 0; 279122d917d8SEric W. Biederman err_put_ns: 279222d917d8SEric W. Biederman put_user_ns(ns); 279322d917d8SEric W. Biederman err: 279422d917d8SEric W. Biederman return ret; 279522d917d8SEric W. Biederman } 279622d917d8SEric W. Biederman 279722d917d8SEric W. Biederman static int proc_id_map_release(struct inode *inode, struct file *file) 279822d917d8SEric W. Biederman { 279922d917d8SEric W. Biederman struct seq_file *seq = file->private_data; 280022d917d8SEric W. Biederman struct user_namespace *ns = seq->private; 280122d917d8SEric W. Biederman put_user_ns(ns); 280222d917d8SEric W. Biederman return seq_release(inode, file); 280322d917d8SEric W. Biederman } 280422d917d8SEric W. Biederman 280522d917d8SEric W. Biederman static int proc_uid_map_open(struct inode *inode, struct file *file) 280622d917d8SEric W. Biederman { 280722d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_uid_seq_operations); 280822d917d8SEric W. Biederman } 280922d917d8SEric W. Biederman 281022d917d8SEric W. Biederman static int proc_gid_map_open(struct inode *inode, struct file *file) 281122d917d8SEric W. Biederman { 281222d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_gid_seq_operations); 281322d917d8SEric W. Biederman } 281422d917d8SEric W. Biederman 2815f76d207aSEric W. Biederman static int proc_projid_map_open(struct inode *inode, struct file *file) 2816f76d207aSEric W. Biederman { 2817f76d207aSEric W. Biederman return proc_id_map_open(inode, file, &proc_projid_seq_operations); 2818f76d207aSEric W. Biederman } 2819f76d207aSEric W. Biederman 282022d917d8SEric W. Biederman static const struct file_operations proc_uid_map_operations = { 282122d917d8SEric W. Biederman .open = proc_uid_map_open, 282222d917d8SEric W. Biederman .write = proc_uid_map_write, 282322d917d8SEric W. Biederman .read = seq_read, 282422d917d8SEric W. Biederman .llseek = seq_lseek, 282522d917d8SEric W. Biederman .release = proc_id_map_release, 282622d917d8SEric W. Biederman }; 282722d917d8SEric W. Biederman 282822d917d8SEric W. Biederman static const struct file_operations proc_gid_map_operations = { 282922d917d8SEric W. Biederman .open = proc_gid_map_open, 283022d917d8SEric W. Biederman .write = proc_gid_map_write, 283122d917d8SEric W. Biederman .read = seq_read, 283222d917d8SEric W. Biederman .llseek = seq_lseek, 283322d917d8SEric W. Biederman .release = proc_id_map_release, 283422d917d8SEric W. Biederman }; 2835f76d207aSEric W. Biederman 2836f76d207aSEric W. Biederman static const struct file_operations proc_projid_map_operations = { 2837f76d207aSEric W. Biederman .open = proc_projid_map_open, 2838f76d207aSEric W. Biederman .write = proc_projid_map_write, 2839f76d207aSEric W. Biederman .read = seq_read, 2840f76d207aSEric W. Biederman .llseek = seq_lseek, 2841f76d207aSEric W. Biederman .release = proc_id_map_release, 2842f76d207aSEric W. Biederman }; 28439cc46516SEric W. Biederman 28449cc46516SEric W. Biederman static int proc_setgroups_open(struct inode *inode, struct file *file) 28459cc46516SEric W. Biederman { 28469cc46516SEric W. Biederman struct user_namespace *ns = NULL; 28479cc46516SEric W. Biederman struct task_struct *task; 28489cc46516SEric W. Biederman int ret; 28499cc46516SEric W. Biederman 28509cc46516SEric W. Biederman ret = -ESRCH; 28519cc46516SEric W. Biederman task = get_proc_task(inode); 28529cc46516SEric W. Biederman if (task) { 28539cc46516SEric W. Biederman rcu_read_lock(); 28549cc46516SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 28559cc46516SEric W. Biederman rcu_read_unlock(); 28569cc46516SEric W. Biederman put_task_struct(task); 28579cc46516SEric W. Biederman } 28589cc46516SEric W. Biederman if (!ns) 28599cc46516SEric W. Biederman goto err; 28609cc46516SEric W. Biederman 28619cc46516SEric W. Biederman if (file->f_mode & FMODE_WRITE) { 28629cc46516SEric W. Biederman ret = -EACCES; 28639cc46516SEric W. Biederman if (!ns_capable(ns, CAP_SYS_ADMIN)) 28649cc46516SEric W. Biederman goto err_put_ns; 28659cc46516SEric W. Biederman } 28669cc46516SEric W. Biederman 28679cc46516SEric W. Biederman ret = single_open(file, &proc_setgroups_show, ns); 28689cc46516SEric W. Biederman if (ret) 28699cc46516SEric W. Biederman goto err_put_ns; 28709cc46516SEric W. Biederman 28719cc46516SEric W. Biederman return 0; 28729cc46516SEric W. Biederman err_put_ns: 28739cc46516SEric W. Biederman put_user_ns(ns); 28749cc46516SEric W. Biederman err: 28759cc46516SEric W. Biederman return ret; 28769cc46516SEric W. Biederman } 28779cc46516SEric W. Biederman 28789cc46516SEric W. Biederman static int proc_setgroups_release(struct inode *inode, struct file *file) 28799cc46516SEric W. Biederman { 28809cc46516SEric W. Biederman struct seq_file *seq = file->private_data; 28819cc46516SEric W. Biederman struct user_namespace *ns = seq->private; 28829cc46516SEric W. Biederman int ret = single_release(inode, file); 28839cc46516SEric W. Biederman put_user_ns(ns); 28849cc46516SEric W. Biederman return ret; 28859cc46516SEric W. Biederman } 28869cc46516SEric W. Biederman 28879cc46516SEric W. Biederman static const struct file_operations proc_setgroups_operations = { 28889cc46516SEric W. Biederman .open = proc_setgroups_open, 28899cc46516SEric W. Biederman .write = proc_setgroups_write, 28909cc46516SEric W. Biederman .read = seq_read, 28919cc46516SEric W. Biederman .llseek = seq_lseek, 28929cc46516SEric W. Biederman .release = proc_setgroups_release, 28939cc46516SEric W. Biederman }; 289422d917d8SEric W. Biederman #endif /* CONFIG_USER_NS */ 289522d917d8SEric W. Biederman 289647830723SKees Cook static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns, 289747830723SKees Cook struct pid *pid, struct task_struct *task) 289847830723SKees Cook { 2899a9712bc1SAl Viro int err = lock_trace(task); 2900a9712bc1SAl Viro if (!err) { 290147830723SKees Cook seq_printf(m, "%08x\n", task->personality); 2902a9712bc1SAl Viro unlock_trace(task); 2903a9712bc1SAl Viro } 2904a9712bc1SAl Viro return err; 290547830723SKees Cook } 290647830723SKees Cook 29077c23b330SJosh Poimboeuf #ifdef CONFIG_LIVEPATCH 29087c23b330SJosh Poimboeuf static int proc_pid_patch_state(struct seq_file *m, struct pid_namespace *ns, 29097c23b330SJosh Poimboeuf struct pid *pid, struct task_struct *task) 29107c23b330SJosh Poimboeuf { 29117c23b330SJosh Poimboeuf seq_printf(m, "%d\n", task->patch_state); 29127c23b330SJosh Poimboeuf return 0; 29137c23b330SJosh Poimboeuf } 29147c23b330SJosh Poimboeuf #endif /* CONFIG_LIVEPATCH */ 29157c23b330SJosh Poimboeuf 2916801199ceSEric W. Biederman /* 291728a6d671SEric W. Biederman * Thread groups 291828a6d671SEric W. Biederman */ 291900977a59SArjan van de Ven static const struct file_operations proc_task_operations; 2920c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations; 292120cdc894SEric W. Biederman 2922c5141e6dSEric Dumazet static const struct pid_entry tgid_base_stuff[] = { 2923631f9c18SAlexey Dobriyan DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations), 2924631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 2925640708a2SPavel Emelyanov DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations), 2926631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 29276b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 2928b2211a36SAndrew Morton #ifdef CONFIG_NET 2929631f9c18SAlexey Dobriyan DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 2930b2211a36SAndrew Morton #endif 2931631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2932c5317167SAl Viro REG("auxv", S_IRUSR, proc_auxv_operations), 2933631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 293435a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 29351c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 293643ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2937631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 293843ae34cbSIngo Molnar #endif 29395091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 29405091faa4SMike Galbraith REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations), 29415091faa4SMike Galbraith #endif 29424614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 2943ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 294409d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 2945ebcb6734SRoland McGrath #endif 2946c2c0bb44SAlexey Dobriyan REG("cmdline", S_IRUGO, proc_pid_cmdline_ops), 2947631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tgid_stat), 2948631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2949b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_pid_maps_operations), 295028a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2951b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations), 295228a6d671SEric W. Biederman #endif 2953631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2954631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2955631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2956631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2957631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2958631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 2959631f9c18SAlexey Dobriyan REG("mountstats", S_IRUSR, proc_mountstats_operations), 29601e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2961631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2962b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_pid_smaps_operations), 2963493b0e9dSDaniel Colascione REG("smaps_rollup", S_IRUGO, proc_pid_smaps_rollup_operations), 296432ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 296528a6d671SEric W. Biederman #endif 296628a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2967631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 296828a6d671SEric W. Biederman #endif 296928a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2970edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 297128a6d671SEric W. Biederman #endif 29722ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 297335a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 297428a6d671SEric W. Biederman #endif 29755968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 2976f6e826caSAlexey Dobriyan ONE("schedstat", S_IRUGO, proc_pid_schedstat), 297728a6d671SEric W. Biederman #endif 29789745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2979631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 29809745512cSArjan van de Ven #endif 29818793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 298252de4779SZefan Li ONE("cpuset", S_IRUGO, proc_cpuset_show), 298328a6d671SEric W. Biederman #endif 2984a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2985006f4ac4SZefan Li ONE("cgroup", S_IRUGO, proc_cgroup_show), 2986a424316cSPaul Menage #endif 29876ba51e37SAlexey Dobriyan ONE("oom_score", S_IRUGO, proc_oom_score), 2988fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 2989a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 299028a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2991631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 2992631f9c18SAlexey Dobriyan REG("sessionid", S_IRUGO, proc_sessionid_operations), 299328a6d671SEric W. Biederman #endif 2994f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2995631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2996168c42bcSAkinobu Mita REG("fail-nth", 0644, proc_fail_nth_operations), 2997f4f154fdSAkinobu Mita #endif 2998698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 2999631f9c18SAlexey Dobriyan REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations), 30003cb4a0bbSKawai, Hidehiro #endif 3001aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 300219aadc98SAlexey Dobriyan ONE("io", S_IRUSR, proc_tgid_io_accounting), 3003aba76fdbSAndrew Morton #endif 3004f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 3005d962c144SAlexey Dobriyan ONE("hardwall", S_IRUGO, proc_pid_hardwall), 3006f133eccaSChris Metcalf #endif 300722d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 300822d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 300922d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 3010f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 30119cc46516SEric W. Biederman REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), 301222d917d8SEric W. Biederman #endif 3013b18b6a9cSNicolas Pitre #if defined(CONFIG_CHECKPOINT_RESTORE) && defined(CONFIG_POSIX_TIMERS) 301448f6a7a5SPavel Emelyanov REG("timers", S_IRUGO, proc_timers_operations), 301548f6a7a5SPavel Emelyanov #endif 30165de23d43SJohn Stultz REG("timerslack_ns", S_IRUGO|S_IWUGO, proc_pid_set_timerslack_ns_operations), 30177c23b330SJosh Poimboeuf #ifdef CONFIG_LIVEPATCH 30187c23b330SJosh Poimboeuf ONE("patch_state", S_IRUSR, proc_pid_patch_state), 30197c23b330SJosh Poimboeuf #endif 302028a6d671SEric W. Biederman }; 302128a6d671SEric W. Biederman 3022f0c3b509SAl Viro static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx) 302328a6d671SEric W. Biederman { 3024f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 302528a6d671SEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 302628a6d671SEric W. Biederman } 302728a6d671SEric W. Biederman 302800977a59SArjan van de Ven static const struct file_operations proc_tgid_base_operations = { 302928a6d671SEric W. Biederman .read = generic_read_dir, 3030f50752eaSAl Viro .iterate_shared = proc_tgid_base_readdir, 3031f50752eaSAl Viro .llseek = generic_file_llseek, 303228a6d671SEric W. Biederman }; 303328a6d671SEric W. Biederman 303400cd8dd3SAl Viro static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 303500cd8dd3SAl Viro { 30367bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 30377bcd6b0eSEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 303828a6d671SEric W. Biederman } 303928a6d671SEric W. Biederman 3040c5ef1c42SArjan van de Ven static const struct inode_operations proc_tgid_base_inode_operations = { 304128a6d671SEric W. Biederman .lookup = proc_tgid_base_lookup, 304228a6d671SEric W. Biederman .getattr = pid_getattr, 304328a6d671SEric W. Biederman .setattr = proc_setattr, 30440499680aSVasiliy Kulikov .permission = proc_pid_permission, 304528a6d671SEric W. Biederman }; 304628a6d671SEric W. Biederman 304760347f67SPavel Emelyanov static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid) 30481da177e4SLinus Torvalds { 304948e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 3050e3912ac3SAlexey Dobriyan char buf[10 + 1]; 305148e6484dSEric W. Biederman struct qstr name; 30521da177e4SLinus Torvalds 305348e6484dSEric W. Biederman name.name = buf; 3054e3912ac3SAlexey Dobriyan name.len = snprintf(buf, sizeof(buf), "%u", pid); 30554f522a24SAl Viro /* no ->d_hash() rejects on procfs */ 305660347f67SPavel Emelyanov dentry = d_hash_and_lookup(mnt->mnt_root, &name); 305748e6484dSEric W. Biederman if (dentry) { 3058bbd51924SEric W. Biederman d_invalidate(dentry); 305948e6484dSEric W. Biederman dput(dentry); 30601da177e4SLinus Torvalds } 30611da177e4SLinus Torvalds 3062c35a7f18SOleg Nesterov if (pid == tgid) 3063c35a7f18SOleg Nesterov return; 3064c35a7f18SOleg Nesterov 306548e6484dSEric W. Biederman name.name = buf; 3066e3912ac3SAlexey Dobriyan name.len = snprintf(buf, sizeof(buf), "%u", tgid); 306760347f67SPavel Emelyanov leader = d_hash_and_lookup(mnt->mnt_root, &name); 306848e6484dSEric W. Biederman if (!leader) 306948e6484dSEric W. Biederman goto out; 307048e6484dSEric W. Biederman 307148e6484dSEric W. Biederman name.name = "task"; 307248e6484dSEric W. Biederman name.len = strlen(name.name); 307348e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 307448e6484dSEric W. Biederman if (!dir) 307548e6484dSEric W. Biederman goto out_put_leader; 307648e6484dSEric W. Biederman 307748e6484dSEric W. Biederman name.name = buf; 3078e3912ac3SAlexey Dobriyan name.len = snprintf(buf, sizeof(buf), "%u", pid); 307948e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 308048e6484dSEric W. Biederman if (dentry) { 3081bbd51924SEric W. Biederman d_invalidate(dentry); 308248e6484dSEric W. Biederman dput(dentry); 30831da177e4SLinus Torvalds } 308448e6484dSEric W. Biederman 308548e6484dSEric W. Biederman dput(dir); 308648e6484dSEric W. Biederman out_put_leader: 308748e6484dSEric W. Biederman dput(leader); 308848e6484dSEric W. Biederman out: 308948e6484dSEric W. Biederman return; 30901da177e4SLinus Torvalds } 30911da177e4SLinus Torvalds 30920895e91dSRandy Dunlap /** 30930895e91dSRandy Dunlap * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 30940895e91dSRandy Dunlap * @task: task that should be flushed. 30950895e91dSRandy Dunlap * 30960895e91dSRandy Dunlap * When flushing dentries from proc, one needs to flush them from global 309760347f67SPavel Emelyanov * proc (proc_mnt) and from all the namespaces' procs this task was seen 30980895e91dSRandy Dunlap * in. This call is supposed to do all of this job. 30990895e91dSRandy Dunlap * 31000895e91dSRandy Dunlap * Looks in the dcache for 31010895e91dSRandy Dunlap * /proc/@pid 31020895e91dSRandy Dunlap * /proc/@tgid/task/@pid 31030895e91dSRandy Dunlap * if either directory is present flushes it and all of it'ts children 31040895e91dSRandy Dunlap * from the dcache. 31050895e91dSRandy Dunlap * 31060895e91dSRandy Dunlap * It is safe and reasonable to cache /proc entries for a task until 31070895e91dSRandy Dunlap * that task exits. After that they just clog up the dcache with 31080895e91dSRandy Dunlap * useless entries, possibly causing useful dcache entries to be 31090895e91dSRandy Dunlap * flushed instead. This routine is proved to flush those useless 31100895e91dSRandy Dunlap * dcache entries at process exit time. 31110895e91dSRandy Dunlap * 31120895e91dSRandy Dunlap * NOTE: This routine is just an optimization so it does not guarantee 31130895e91dSRandy Dunlap * that no dcache entries will exist at process exit time it 31140895e91dSRandy Dunlap * just makes it very unlikely that any will persist. 311560347f67SPavel Emelyanov */ 311660347f67SPavel Emelyanov 311760347f67SPavel Emelyanov void proc_flush_task(struct task_struct *task) 311860347f67SPavel Emelyanov { 31199fcc2d15SEric W. Biederman int i; 31209b4d1cbeSOleg Nesterov struct pid *pid, *tgid; 3121130f77ecSPavel Emelyanov struct upid *upid; 3122130f77ecSPavel Emelyanov 3123130f77ecSPavel Emelyanov pid = task_pid(task); 3124130f77ecSPavel Emelyanov tgid = task_tgid(task); 31259fcc2d15SEric W. Biederman 31269fcc2d15SEric W. Biederman for (i = 0; i <= pid->level; i++) { 3127130f77ecSPavel Emelyanov upid = &pid->numbers[i]; 3128130f77ecSPavel Emelyanov proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr, 31299b4d1cbeSOleg Nesterov tgid->numbers[i].nr); 3130130f77ecSPavel Emelyanov } 313160347f67SPavel Emelyanov } 313260347f67SPavel Emelyanov 3133c52a47acSAl Viro static int proc_pid_instantiate(struct inode *dir, 31349711ef99SAdrian Bunk struct dentry * dentry, 3135c5141e6dSEric Dumazet struct task_struct *task, const void *ptr) 3136444ceed8SEric W. Biederman { 3137444ceed8SEric W. Biederman struct inode *inode; 3138444ceed8SEric W. Biederman 3139db978da8SAndreas Gruenbacher inode = proc_pid_make_inode(dir->i_sb, task, S_IFDIR | S_IRUGO | S_IXUGO); 3140444ceed8SEric W. Biederman if (!inode) 3141444ceed8SEric W. Biederman goto out; 3142444ceed8SEric W. Biederman 3143444ceed8SEric W. Biederman inode->i_op = &proc_tgid_base_inode_operations; 3144444ceed8SEric W. Biederman inode->i_fop = &proc_tgid_base_operations; 3145444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 3146aed54175SVegard Nossum 31471270dd8dSAlexey Dobriyan set_nlink(inode, nlink_tgid); 3148444ceed8SEric W. Biederman 3149fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 3150444ceed8SEric W. Biederman 3151444ceed8SEric W. Biederman d_add(dentry, inode); 3152444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 31530b728e19SAl Viro if (pid_revalidate(dentry, 0)) 3154c52a47acSAl Viro return 0; 3155444ceed8SEric W. Biederman out: 3156c52a47acSAl Viro return -ENOENT; 3157444ceed8SEric W. Biederman } 3158444ceed8SEric W. Biederman 315900cd8dd3SAl Viro struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 31601da177e4SLinus Torvalds { 3161335eb531SAlexey Dobriyan int result = -ENOENT; 31621da177e4SLinus Torvalds struct task_struct *task; 31631da177e4SLinus Torvalds unsigned tgid; 3164b488893aSPavel Emelyanov struct pid_namespace *ns; 31651da177e4SLinus Torvalds 3166dbcdb504SAlexey Dobriyan tgid = name_to_int(&dentry->d_name); 31671da177e4SLinus Torvalds if (tgid == ~0U) 31681da177e4SLinus Torvalds goto out; 31691da177e4SLinus Torvalds 3170b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 3171de758734SEric W. Biederman rcu_read_lock(); 3172b488893aSPavel Emelyanov task = find_task_by_pid_ns(tgid, ns); 31731da177e4SLinus Torvalds if (task) 31741da177e4SLinus Torvalds get_task_struct(task); 3175de758734SEric W. Biederman rcu_read_unlock(); 31761da177e4SLinus Torvalds if (!task) 31771da177e4SLinus Torvalds goto out; 31781da177e4SLinus Torvalds 3179444ceed8SEric W. Biederman result = proc_pid_instantiate(dir, dentry, task, NULL); 318048e6484dSEric W. Biederman put_task_struct(task); 31811da177e4SLinus Torvalds out: 3182c52a47acSAl Viro return ERR_PTR(result); 31831da177e4SLinus Torvalds } 31841da177e4SLinus Torvalds 31851da177e4SLinus Torvalds /* 31860804ef4bSEric W. Biederman * Find the first task with tgid >= tgid 31870bc58a91SEric W. Biederman * 31881da177e4SLinus Torvalds */ 318919fd4bb2SEric W. Biederman struct tgid_iter { 319019fd4bb2SEric W. Biederman unsigned int tgid; 31910804ef4bSEric W. Biederman struct task_struct *task; 319219fd4bb2SEric W. Biederman }; 319319fd4bb2SEric W. Biederman static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter) 319419fd4bb2SEric W. Biederman { 31950804ef4bSEric W. Biederman struct pid *pid; 31961da177e4SLinus Torvalds 319719fd4bb2SEric W. Biederman if (iter.task) 319819fd4bb2SEric W. Biederman put_task_struct(iter.task); 31990804ef4bSEric W. Biederman rcu_read_lock(); 32000804ef4bSEric W. Biederman retry: 320119fd4bb2SEric W. Biederman iter.task = NULL; 320219fd4bb2SEric W. Biederman pid = find_ge_pid(iter.tgid, ns); 32030804ef4bSEric W. Biederman if (pid) { 320419fd4bb2SEric W. Biederman iter.tgid = pid_nr_ns(pid, ns); 320519fd4bb2SEric W. Biederman iter.task = pid_task(pid, PIDTYPE_PID); 32060804ef4bSEric W. Biederman /* What we to know is if the pid we have find is the 32070804ef4bSEric W. Biederman * pid of a thread_group_leader. Testing for task 32080804ef4bSEric W. Biederman * being a thread_group_leader is the obvious thing 32090804ef4bSEric W. Biederman * todo but there is a window when it fails, due to 32100804ef4bSEric W. Biederman * the pid transfer logic in de_thread. 32110804ef4bSEric W. Biederman * 32120804ef4bSEric W. Biederman * So we perform the straight forward test of seeing 32130804ef4bSEric W. Biederman * if the pid we have found is the pid of a thread 32140804ef4bSEric W. Biederman * group leader, and don't worry if the task we have 32150804ef4bSEric W. Biederman * found doesn't happen to be a thread group leader. 32160804ef4bSEric W. Biederman * As we don't care in the case of readdir. 32170bc58a91SEric W. Biederman */ 321819fd4bb2SEric W. Biederman if (!iter.task || !has_group_leader_pid(iter.task)) { 321919fd4bb2SEric W. Biederman iter.tgid += 1; 32200804ef4bSEric W. Biederman goto retry; 322119fd4bb2SEric W. Biederman } 322219fd4bb2SEric W. Biederman get_task_struct(iter.task); 32231da177e4SLinus Torvalds } 3224454cc105SEric W. Biederman rcu_read_unlock(); 322519fd4bb2SEric W. Biederman return iter; 32261da177e4SLinus Torvalds } 32271da177e4SLinus Torvalds 32280097875bSEric W. Biederman #define TGID_OFFSET (FIRST_PROCESS_ENTRY + 2) 32291da177e4SLinus Torvalds 32301da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 3231f0c3b509SAl Viro int proc_pid_readdir(struct file *file, struct dir_context *ctx) 32321da177e4SLinus Torvalds { 323319fd4bb2SEric W. Biederman struct tgid_iter iter; 32343aa3377fSAl Viro struct pid_namespace *ns = file_inode(file)->i_sb->s_fs_info; 3235f0c3b509SAl Viro loff_t pos = ctx->pos; 32361da177e4SLinus Torvalds 3237021ada7dSAl Viro if (pos >= PID_MAX_LIMIT + TGID_OFFSET) 3238f0c3b509SAl Viro return 0; 32391da177e4SLinus Torvalds 32400097875bSEric W. Biederman if (pos == TGID_OFFSET - 2) { 32412b0143b5SDavid Howells struct inode *inode = d_inode(ns->proc_self); 3242db963164SAl Viro if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK)) 3243f0c3b509SAl Viro return 0; 32440097875bSEric W. Biederman ctx->pos = pos = pos + 1; 3245021ada7dSAl Viro } 32460097875bSEric W. Biederman if (pos == TGID_OFFSET - 1) { 32472b0143b5SDavid Howells struct inode *inode = d_inode(ns->proc_thread_self); 32480097875bSEric W. Biederman if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK)) 32490097875bSEric W. Biederman return 0; 32500097875bSEric W. Biederman ctx->pos = pos = pos + 1; 32510097875bSEric W. Biederman } 32520097875bSEric W. Biederman iter.tgid = pos - TGID_OFFSET; 325319fd4bb2SEric W. Biederman iter.task = NULL; 325419fd4bb2SEric W. Biederman for (iter = next_tgid(ns, iter); 325519fd4bb2SEric W. Biederman iter.task; 325619fd4bb2SEric W. Biederman iter.tgid += 1, iter = next_tgid(ns, iter)) { 3257e3912ac3SAlexey Dobriyan char name[10 + 1]; 3258f0c3b509SAl Viro int len; 32593ba4bceeSEric Dumazet 32603ba4bceeSEric Dumazet cond_resched(); 3261796f571bSLafcadio Wluiki if (!has_pid_permissions(ns, iter.task, HIDEPID_INVISIBLE)) 3262f0c3b509SAl Viro continue; 32630499680aSVasiliy Kulikov 3264e3912ac3SAlexey Dobriyan len = snprintf(name, sizeof(name), "%u", iter.tgid); 3265f0c3b509SAl Viro ctx->pos = iter.tgid + TGID_OFFSET; 3266f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3267f0c3b509SAl Viro proc_pid_instantiate, iter.task, NULL)) { 326819fd4bb2SEric W. Biederman put_task_struct(iter.task); 3269f0c3b509SAl Viro return 0; 32701da177e4SLinus Torvalds } 32711da177e4SLinus Torvalds } 3272f0c3b509SAl Viro ctx->pos = PID_MAX_LIMIT + TGID_OFFSET; 32731da177e4SLinus Torvalds return 0; 32741da177e4SLinus Torvalds } 32751da177e4SLinus Torvalds 32760bc58a91SEric W. Biederman /* 32771b3044e3SJanis Danisevskis * proc_tid_comm_permission is a special permission function exclusively 32781b3044e3SJanis Danisevskis * used for the node /proc/<pid>/task/<tid>/comm. 32791b3044e3SJanis Danisevskis * It bypasses generic permission checks in the case where a task of the same 32801b3044e3SJanis Danisevskis * task group attempts to access the node. 32811b3044e3SJanis Danisevskis * The rationale behind this is that glibc and bionic access this node for 32821b3044e3SJanis Danisevskis * cross thread naming (pthread_set/getname_np(!self)). However, if 32831b3044e3SJanis Danisevskis * PR_SET_DUMPABLE gets set to 0 this node among others becomes uid=0 gid=0, 32841b3044e3SJanis Danisevskis * which locks out the cross thread naming implementation. 32851b3044e3SJanis Danisevskis * This function makes sure that the node is always accessible for members of 32861b3044e3SJanis Danisevskis * same thread group. 32871b3044e3SJanis Danisevskis */ 32881b3044e3SJanis Danisevskis static int proc_tid_comm_permission(struct inode *inode, int mask) 32891b3044e3SJanis Danisevskis { 32901b3044e3SJanis Danisevskis bool is_same_tgroup; 32911b3044e3SJanis Danisevskis struct task_struct *task; 32921b3044e3SJanis Danisevskis 32931b3044e3SJanis Danisevskis task = get_proc_task(inode); 32941b3044e3SJanis Danisevskis if (!task) 32951b3044e3SJanis Danisevskis return -ESRCH; 32961b3044e3SJanis Danisevskis is_same_tgroup = same_thread_group(current, task); 32971b3044e3SJanis Danisevskis put_task_struct(task); 32981b3044e3SJanis Danisevskis 32991b3044e3SJanis Danisevskis if (likely(is_same_tgroup && !(mask & MAY_EXEC))) { 33001b3044e3SJanis Danisevskis /* This file (/proc/<pid>/task/<tid>/comm) can always be 33011b3044e3SJanis Danisevskis * read or written by the members of the corresponding 33021b3044e3SJanis Danisevskis * thread group. 33031b3044e3SJanis Danisevskis */ 33041b3044e3SJanis Danisevskis return 0; 33051b3044e3SJanis Danisevskis } 33061b3044e3SJanis Danisevskis 33071b3044e3SJanis Danisevskis return generic_permission(inode, mask); 33081b3044e3SJanis Danisevskis } 33091b3044e3SJanis Danisevskis 33101b3044e3SJanis Danisevskis static const struct inode_operations proc_tid_comm_inode_operations = { 33111b3044e3SJanis Danisevskis .permission = proc_tid_comm_permission, 33121b3044e3SJanis Danisevskis }; 33131b3044e3SJanis Danisevskis 33141b3044e3SJanis Danisevskis /* 331528a6d671SEric W. Biederman * Tasks 331628a6d671SEric W. Biederman */ 3317c5141e6dSEric Dumazet static const struct pid_entry tid_base_stuff[] = { 3318631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 33193835541dSJerome Marchand DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 33206b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 33216ba8ed79SEric W. Biederman #ifdef CONFIG_NET 33226ba8ed79SEric W. Biederman DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 33236ba8ed79SEric W. Biederman #endif 3324631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 3325c5317167SAl Viro REG("auxv", S_IRUSR, proc_auxv_operations), 3326631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 332735a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 33281c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 332943ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 3330631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 333143ae34cbSIngo Molnar #endif 33321b3044e3SJanis Danisevskis NOD("comm", S_IFREG|S_IRUGO|S_IWUSR, 33331b3044e3SJanis Danisevskis &proc_tid_comm_inode_operations, 33341b3044e3SJanis Danisevskis &proc_pid_set_comm_operations, {}), 3335ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 333609d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 3337ebcb6734SRoland McGrath #endif 3338c2c0bb44SAlexey Dobriyan REG("cmdline", S_IRUGO, proc_pid_cmdline_ops), 3339631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tid_stat), 3340631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 3341b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_tid_maps_operations), 33422e13ba54SIago López Galeiras #ifdef CONFIG_PROC_CHILDREN 334381841161SCyrill Gorcunov REG("children", S_IRUGO, proc_tid_children_operations), 334481841161SCyrill Gorcunov #endif 334528a6d671SEric W. Biederman #ifdef CONFIG_NUMA 3346b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations), 334728a6d671SEric W. Biederman #endif 3348631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 3349631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 3350631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 3351631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 3352631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 3353631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 33541e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 3355631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 3356b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_tid_smaps_operations), 3357493b0e9dSDaniel Colascione REG("smaps_rollup", S_IRUGO, proc_pid_smaps_rollup_operations), 335832ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 335928a6d671SEric W. Biederman #endif 336028a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 3361631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 336228a6d671SEric W. Biederman #endif 336328a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 3364edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 336528a6d671SEric W. Biederman #endif 33662ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 336735a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 336828a6d671SEric W. Biederman #endif 33695968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 3370f6e826caSAlexey Dobriyan ONE("schedstat", S_IRUGO, proc_pid_schedstat), 337128a6d671SEric W. Biederman #endif 33729745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3373631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 33749745512cSArjan van de Ven #endif 33758793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 337652de4779SZefan Li ONE("cpuset", S_IRUGO, proc_cpuset_show), 337728a6d671SEric W. Biederman #endif 3378a424316cSPaul Menage #ifdef CONFIG_CGROUPS 3379006f4ac4SZefan Li ONE("cgroup", S_IRUGO, proc_cgroup_show), 3380a424316cSPaul Menage #endif 33816ba51e37SAlexey Dobriyan ONE("oom_score", S_IRUGO, proc_oom_score), 3382fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 3383a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 338428a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 3385631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 338626ec3c64SAl Viro REG("sessionid", S_IRUGO, proc_sessionid_operations), 338728a6d671SEric W. Biederman #endif 3388f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 3389631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 33901203c8e6SAkinobu Mita REG("fail-nth", 0644, proc_fail_nth_operations), 3391f4f154fdSAkinobu Mita #endif 3392297c5d92SAndrea Righi #ifdef CONFIG_TASK_IO_ACCOUNTING 339319aadc98SAlexey Dobriyan ONE("io", S_IRUSR, proc_tid_io_accounting), 3394297c5d92SAndrea Righi #endif 3395f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 3396d962c144SAlexey Dobriyan ONE("hardwall", S_IRUGO, proc_pid_hardwall), 3397f133eccaSChris Metcalf #endif 339822d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 339922d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 340022d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 3401f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 34029cc46516SEric W. Biederman REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), 340322d917d8SEric W. Biederman #endif 34047c23b330SJosh Poimboeuf #ifdef CONFIG_LIVEPATCH 34057c23b330SJosh Poimboeuf ONE("patch_state", S_IRUSR, proc_pid_patch_state), 34067c23b330SJosh Poimboeuf #endif 340728a6d671SEric W. Biederman }; 340828a6d671SEric W. Biederman 3409f0c3b509SAl Viro static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx) 341028a6d671SEric W. Biederman { 3411f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 341228a6d671SEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 341328a6d671SEric W. Biederman } 341428a6d671SEric W. Biederman 341500cd8dd3SAl Viro static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 341600cd8dd3SAl Viro { 34177bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 34187bcd6b0eSEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 341928a6d671SEric W. Biederman } 342028a6d671SEric W. Biederman 342100977a59SArjan van de Ven static const struct file_operations proc_tid_base_operations = { 342228a6d671SEric W. Biederman .read = generic_read_dir, 3423f50752eaSAl Viro .iterate_shared = proc_tid_base_readdir, 3424f50752eaSAl Viro .llseek = generic_file_llseek, 342528a6d671SEric W. Biederman }; 342628a6d671SEric W. Biederman 3427c5ef1c42SArjan van de Ven static const struct inode_operations proc_tid_base_inode_operations = { 342828a6d671SEric W. Biederman .lookup = proc_tid_base_lookup, 342928a6d671SEric W. Biederman .getattr = pid_getattr, 343028a6d671SEric W. Biederman .setattr = proc_setattr, 343128a6d671SEric W. Biederman }; 343228a6d671SEric W. Biederman 3433c52a47acSAl Viro static int proc_task_instantiate(struct inode *dir, 3434c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 3435444ceed8SEric W. Biederman { 3436444ceed8SEric W. Biederman struct inode *inode; 3437db978da8SAndreas Gruenbacher inode = proc_pid_make_inode(dir->i_sb, task, S_IFDIR | S_IRUGO | S_IXUGO); 3438444ceed8SEric W. Biederman 3439444ceed8SEric W. Biederman if (!inode) 3440444ceed8SEric W. Biederman goto out; 3441444ceed8SEric W. Biederman inode->i_op = &proc_tid_base_inode_operations; 3442444ceed8SEric W. Biederman inode->i_fop = &proc_tid_base_operations; 3443444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 3444aed54175SVegard Nossum 34451270dd8dSAlexey Dobriyan set_nlink(inode, nlink_tid); 3446444ceed8SEric W. Biederman 3447fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 3448444ceed8SEric W. Biederman 3449444ceed8SEric W. Biederman d_add(dentry, inode); 3450444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 34510b728e19SAl Viro if (pid_revalidate(dentry, 0)) 3452c52a47acSAl Viro return 0; 3453444ceed8SEric W. Biederman out: 3454c52a47acSAl Viro return -ENOENT; 3455444ceed8SEric W. Biederman } 3456444ceed8SEric W. Biederman 345700cd8dd3SAl Viro static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 345828a6d671SEric W. Biederman { 3459c52a47acSAl Viro int result = -ENOENT; 346028a6d671SEric W. Biederman struct task_struct *task; 346128a6d671SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 346228a6d671SEric W. Biederman unsigned tid; 3463b488893aSPavel Emelyanov struct pid_namespace *ns; 346428a6d671SEric W. Biederman 346528a6d671SEric W. Biederman if (!leader) 346628a6d671SEric W. Biederman goto out_no_task; 346728a6d671SEric W. Biederman 3468dbcdb504SAlexey Dobriyan tid = name_to_int(&dentry->d_name); 346928a6d671SEric W. Biederman if (tid == ~0U) 347028a6d671SEric W. Biederman goto out; 347128a6d671SEric W. Biederman 3472b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 347328a6d671SEric W. Biederman rcu_read_lock(); 3474b488893aSPavel Emelyanov task = find_task_by_pid_ns(tid, ns); 347528a6d671SEric W. Biederman if (task) 347628a6d671SEric W. Biederman get_task_struct(task); 347728a6d671SEric W. Biederman rcu_read_unlock(); 347828a6d671SEric W. Biederman if (!task) 347928a6d671SEric W. Biederman goto out; 3480bac0abd6SPavel Emelyanov if (!same_thread_group(leader, task)) 348128a6d671SEric W. Biederman goto out_drop_task; 348228a6d671SEric W. Biederman 3483444ceed8SEric W. Biederman result = proc_task_instantiate(dir, dentry, task, NULL); 348428a6d671SEric W. Biederman out_drop_task: 348528a6d671SEric W. Biederman put_task_struct(task); 348628a6d671SEric W. Biederman out: 348728a6d671SEric W. Biederman put_task_struct(leader); 348828a6d671SEric W. Biederman out_no_task: 3489c52a47acSAl Viro return ERR_PTR(result); 349028a6d671SEric W. Biederman } 349128a6d671SEric W. Biederman 349228a6d671SEric W. Biederman /* 34930bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 34940bc58a91SEric W. Biederman * 34950bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 34960bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 34970bc58a91SEric W. Biederman * directory we have more work todo. 34980bc58a91SEric W. Biederman * 34990bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 35000bc58a91SEric W. Biederman * 35010bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 35020bc58a91SEric W. Biederman * threads past it. 35030bc58a91SEric W. Biederman */ 35049f6e963fSOleg Nesterov static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos, 35059f6e963fSOleg Nesterov struct pid_namespace *ns) 35060bc58a91SEric W. Biederman { 3507d855a4b7SOleg Nesterov struct task_struct *pos, *task; 35089f6e963fSOleg Nesterov unsigned long nr = f_pos; 35099f6e963fSOleg Nesterov 35109f6e963fSOleg Nesterov if (nr != f_pos) /* 32bit overflow? */ 35119f6e963fSOleg Nesterov return NULL; 35120bc58a91SEric W. Biederman 3513cc288738SEric W. Biederman rcu_read_lock(); 3514d855a4b7SOleg Nesterov task = pid_task(pid, PIDTYPE_PID); 3515d855a4b7SOleg Nesterov if (!task) 3516d855a4b7SOleg Nesterov goto fail; 3517d855a4b7SOleg Nesterov 3518d855a4b7SOleg Nesterov /* Attempt to start with the tid of a thread */ 35199f6e963fSOleg Nesterov if (tid && nr) { 3520b488893aSPavel Emelyanov pos = find_task_by_pid_ns(tid, ns); 3521d855a4b7SOleg Nesterov if (pos && same_thread_group(pos, task)) 3522a872ff0cSOleg Nesterov goto found; 35230bc58a91SEric W. Biederman } 35240bc58a91SEric W. Biederman 35250bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 35269f6e963fSOleg Nesterov if (nr >= get_nr_threads(task)) 3527c986c14aSOleg Nesterov goto fail; 3528a872ff0cSOleg Nesterov 3529a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 3530a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 3531a872ff0cSOleg Nesterov */ 3532d855a4b7SOleg Nesterov pos = task = task->group_leader; 3533c986c14aSOleg Nesterov do { 35349f6e963fSOleg Nesterov if (!nr--) 3535c986c14aSOleg Nesterov goto found; 3536d855a4b7SOleg Nesterov } while_each_thread(task, pos); 3537c986c14aSOleg Nesterov fail: 3538a872ff0cSOleg Nesterov pos = NULL; 3539a872ff0cSOleg Nesterov goto out; 3540a872ff0cSOleg Nesterov found: 3541a872ff0cSOleg Nesterov get_task_struct(pos); 3542a872ff0cSOleg Nesterov out: 3543cc288738SEric W. Biederman rcu_read_unlock(); 35440bc58a91SEric W. Biederman return pos; 35450bc58a91SEric W. Biederman } 35460bc58a91SEric W. Biederman 35470bc58a91SEric W. Biederman /* 35480bc58a91SEric W. Biederman * Find the next thread in the thread list. 35490bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 35500bc58a91SEric W. Biederman * 35510bc58a91SEric W. Biederman * The reference to the input task_struct is released. 35520bc58a91SEric W. Biederman */ 35530bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 35540bc58a91SEric W. Biederman { 3555c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 3556cc288738SEric W. Biederman rcu_read_lock(); 3557c1df7fb8SOleg Nesterov if (pid_alive(start)) { 35580bc58a91SEric W. Biederman pos = next_thread(start); 3559c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 35600bc58a91SEric W. Biederman pos = NULL; 3561c1df7fb8SOleg Nesterov else 3562c1df7fb8SOleg Nesterov get_task_struct(pos); 3563c1df7fb8SOleg Nesterov } 3564cc288738SEric W. Biederman rcu_read_unlock(); 35650bc58a91SEric W. Biederman put_task_struct(start); 35660bc58a91SEric W. Biederman return pos; 35670bc58a91SEric W. Biederman } 35680bc58a91SEric W. Biederman 35691da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 3570f0c3b509SAl Viro static int proc_task_readdir(struct file *file, struct dir_context *ctx) 35711da177e4SLinus Torvalds { 3572d855a4b7SOleg Nesterov struct inode *inode = file_inode(file); 3573d855a4b7SOleg Nesterov struct task_struct *task; 3574b488893aSPavel Emelyanov struct pid_namespace *ns; 3575f0c3b509SAl Viro int tid; 35761da177e4SLinus Torvalds 3577d855a4b7SOleg Nesterov if (proc_inode_is_dead(inode)) 3578f0c3b509SAl Viro return -ENOENT; 35791da177e4SLinus Torvalds 3580f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 3581d855a4b7SOleg Nesterov return 0; 35821da177e4SLinus Torvalds 35830bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 35840bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 35850bc58a91SEric W. Biederman */ 35863aa3377fSAl Viro ns = inode->i_sb->s_fs_info; 3587f0c3b509SAl Viro tid = (int)file->f_version; 3588f0c3b509SAl Viro file->f_version = 0; 3589d855a4b7SOleg Nesterov for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns); 35900bc58a91SEric W. Biederman task; 3591f0c3b509SAl Viro task = next_tid(task), ctx->pos++) { 3592e3912ac3SAlexey Dobriyan char name[10 + 1]; 3593f0c3b509SAl Viro int len; 3594b488893aSPavel Emelyanov tid = task_pid_nr_ns(task, ns); 3595e3912ac3SAlexey Dobriyan len = snprintf(name, sizeof(name), "%u", tid); 3596f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3597f0c3b509SAl Viro proc_task_instantiate, task, NULL)) { 35980bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 35990bc58a91SEric W. Biederman * pid for the next readir call */ 3600f0c3b509SAl Viro file->f_version = (u64)tid; 36010bc58a91SEric W. Biederman put_task_struct(task); 36021da177e4SLinus Torvalds break; 36030bc58a91SEric W. Biederman } 36041da177e4SLinus Torvalds } 3605d855a4b7SOleg Nesterov 3606f0c3b509SAl Viro return 0; 36071da177e4SLinus Torvalds } 36086e66b52bSEric W. Biederman 3609a528d35eSDavid Howells static int proc_task_getattr(const struct path *path, struct kstat *stat, 3610a528d35eSDavid Howells u32 request_mask, unsigned int query_flags) 36116e66b52bSEric W. Biederman { 3612a528d35eSDavid Howells struct inode *inode = d_inode(path->dentry); 361399f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 36146e66b52bSEric W. Biederman generic_fillattr(inode, stat); 36156e66b52bSEric W. Biederman 361699f89551SEric W. Biederman if (p) { 361799f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 361899f89551SEric W. Biederman put_task_struct(p); 36196e66b52bSEric W. Biederman } 36206e66b52bSEric W. Biederman 36216e66b52bSEric W. Biederman return 0; 36226e66b52bSEric W. Biederman } 362328a6d671SEric W. Biederman 3624c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations = { 362528a6d671SEric W. Biederman .lookup = proc_task_lookup, 362628a6d671SEric W. Biederman .getattr = proc_task_getattr, 362728a6d671SEric W. Biederman .setattr = proc_setattr, 36280499680aSVasiliy Kulikov .permission = proc_pid_permission, 362928a6d671SEric W. Biederman }; 363028a6d671SEric W. Biederman 363100977a59SArjan van de Ven static const struct file_operations proc_task_operations = { 363228a6d671SEric W. Biederman .read = generic_read_dir, 3633f50752eaSAl Viro .iterate_shared = proc_task_readdir, 3634f50752eaSAl Viro .llseek = generic_file_llseek, 363528a6d671SEric W. Biederman }; 36361270dd8dSAlexey Dobriyan 36371270dd8dSAlexey Dobriyan void __init set_proc_pid_nlink(void) 36381270dd8dSAlexey Dobriyan { 36391270dd8dSAlexey Dobriyan nlink_tid = pid_entry_nlink(tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 36401270dd8dSAlexey Dobriyan nlink_tgid = pid_entry_nlink(tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 36411270dd8dSAlexey Dobriyan } 3642