11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/proc/base.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * proc base directory handling functions 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * 1999, Al Viro. Rewritten. Now it covers the whole per-process part. 91da177e4SLinus Torvalds * Instead of using magical inumbers to determine the kind of object 101da177e4SLinus Torvalds * we allocate and fill in-core inodes upon lookup. They don't even 111da177e4SLinus Torvalds * go into icache. We cache the reference to task_struct upon lookup too. 121da177e4SLinus Torvalds * Eventually it should become a filesystem in its own. We don't use the 131da177e4SLinus Torvalds * rest of procfs anymore. 14e070ad49SMauricio Lin * 15e070ad49SMauricio Lin * 16e070ad49SMauricio Lin * Changelog: 17e070ad49SMauricio Lin * 17-Jan-2005 18e070ad49SMauricio Lin * Allan Bezerra 19e070ad49SMauricio Lin * Bruna Moreira <bruna.moreira@indt.org.br> 20e070ad49SMauricio Lin * Edjard Mota <edjard.mota@indt.org.br> 21e070ad49SMauricio Lin * Ilias Biris <ilias.biris@indt.org.br> 22e070ad49SMauricio Lin * Mauricio Lin <mauricio.lin@indt.org.br> 23e070ad49SMauricio Lin * 24e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 25e070ad49SMauricio Lin * 26e070ad49SMauricio Lin * A new process specific entry (smaps) included in /proc. It shows the 27e070ad49SMauricio Lin * size of rss for each memory area. The maps entry lacks information 28e070ad49SMauricio Lin * about physical memory size (rss) for each mapped file, i.e., 29e070ad49SMauricio Lin * rss information for executables and library files. 30e070ad49SMauricio Lin * This additional information is useful for any tools that need to know 31e070ad49SMauricio Lin * about physical memory consumption for a process specific library. 32e070ad49SMauricio Lin * 33e070ad49SMauricio Lin * Changelog: 34e070ad49SMauricio Lin * 21-Feb-2005 35e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 36e070ad49SMauricio Lin * Pud inclusion in the page table walking. 37e070ad49SMauricio Lin * 38e070ad49SMauricio Lin * ChangeLog: 39e070ad49SMauricio Lin * 10-Mar-2005 40e070ad49SMauricio Lin * 10LE Instituto Nokia de Tecnologia - INdT: 41e070ad49SMauricio Lin * A better way to walks through the page table as suggested by Hugh Dickins. 42e070ad49SMauricio Lin * 43e070ad49SMauricio Lin * Simo Piiroinen <simo.piiroinen@nokia.com>: 44e070ad49SMauricio Lin * Smaps information related to shared, private, clean and dirty pages. 45e070ad49SMauricio Lin * 46e070ad49SMauricio Lin * Paul Mundt <paul.mundt@nokia.com>: 47e070ad49SMauricio Lin * Overall revision about smaps. 481da177e4SLinus Torvalds */ 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include <asm/uaccess.h> 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #include <linux/errno.h> 531da177e4SLinus Torvalds #include <linux/time.h> 541da177e4SLinus Torvalds #include <linux/proc_fs.h> 551da177e4SLinus Torvalds #include <linux/stat.h> 565995477aSAndrea Righi #include <linux/task_io_accounting_ops.h> 571da177e4SLinus Torvalds #include <linux/init.h> 5816f7e0feSRandy Dunlap #include <linux/capability.h> 591da177e4SLinus Torvalds #include <linux/file.h> 609f3acc31SAl Viro #include <linux/fdtable.h> 611da177e4SLinus Torvalds #include <linux/string.h> 621da177e4SLinus Torvalds #include <linux/seq_file.h> 631da177e4SLinus Torvalds #include <linux/namei.h> 646b3286edSKirill Korotaev #include <linux/mnt_namespace.h> 651da177e4SLinus Torvalds #include <linux/mm.h> 66a63d83f4SDavid Rientjes #include <linux/swap.h> 67b835996fSDipankar Sarma #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/kallsyms.h> 692ec220e2SKen Chen #include <linux/stacktrace.h> 70d85f50d5SNeil Horman #include <linux/resource.h> 715096add8SKees Cook #include <linux/module.h> 721da177e4SLinus Torvalds #include <linux/mount.h> 731da177e4SLinus Torvalds #include <linux/security.h> 741da177e4SLinus Torvalds #include <linux/ptrace.h> 750d094efeSRoland McGrath #include <linux/tracehook.h> 7687ebdc00SAndrew Morton #include <linux/printk.h> 77a424316cSPaul Menage #include <linux/cgroup.h> 781da177e4SLinus Torvalds #include <linux/cpuset.h> 791da177e4SLinus Torvalds #include <linux/audit.h> 805addc5ddSAl Viro #include <linux/poll.h> 811651e14eSSerge E. Hallyn #include <linux/nsproxy.h> 828ac773b4SAlexey Dobriyan #include <linux/oom.h> 833cb4a0bbSKawai, Hidehiro #include <linux/elf.h> 8460347f67SPavel Emelyanov #include <linux/pid_namespace.h> 8522d917d8SEric W. Biederman #include <linux/user_namespace.h> 865ad4e53bSAl Viro #include <linux/fs_struct.h> 875a0e3ad6STejun Heo #include <linux/slab.h> 88640708a2SPavel Emelyanov #include <linux/flex_array.h> 8948f6a7a5SPavel Emelyanov #include <linux/posix-timers.h> 90f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 91f133eccaSChris Metcalf #include <asm/hardwall.h> 92f133eccaSChris Metcalf #endif 9343d2b113SKAMEZAWA Hiroyuki #include <trace/events/oom.h> 941da177e4SLinus Torvalds #include "internal.h" 95faf60af1SCyrill Gorcunov #include "fd.h" 961da177e4SLinus Torvalds 970f2fe20fSEric W. Biederman /* NOTE: 980f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 990f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 1000f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 1010f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 1020f2fe20fSEric W. Biederman * 1030f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 1040f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 1050f2fe20fSEric W. Biederman */ 1060f2fe20fSEric W. Biederman 1071da177e4SLinus Torvalds struct pid_entry { 108cedbccabSAlexey Dobriyan const char *name; 109c5141e6dSEric Dumazet int len; 110d161a13fSAl Viro umode_t mode; 111c5ef1c42SArjan van de Ven const struct inode_operations *iop; 11200977a59SArjan van de Ven const struct file_operations *fop; 11320cdc894SEric W. Biederman union proc_op op; 1141da177e4SLinus Torvalds }; 1151da177e4SLinus Torvalds 11661a28784SEric W. Biederman #define NOD(NAME, MODE, IOP, FOP, OP) { \ 11720cdc894SEric W. Biederman .name = (NAME), \ 118c5141e6dSEric Dumazet .len = sizeof(NAME) - 1, \ 11920cdc894SEric W. Biederman .mode = MODE, \ 12020cdc894SEric W. Biederman .iop = IOP, \ 12120cdc894SEric W. Biederman .fop = FOP, \ 12220cdc894SEric W. Biederman .op = OP, \ 12320cdc894SEric W. Biederman } 12420cdc894SEric W. Biederman 125631f9c18SAlexey Dobriyan #define DIR(NAME, MODE, iops, fops) \ 126631f9c18SAlexey Dobriyan NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} ) 127631f9c18SAlexey Dobriyan #define LNK(NAME, get_link) \ 12861a28784SEric W. Biederman NOD(NAME, (S_IFLNK|S_IRWXUGO), \ 12920cdc894SEric W. Biederman &proc_pid_link_inode_operations, NULL, \ 130631f9c18SAlexey Dobriyan { .proc_get_link = get_link } ) 131631f9c18SAlexey Dobriyan #define REG(NAME, MODE, fops) \ 132631f9c18SAlexey Dobriyan NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {}) 133631f9c18SAlexey Dobriyan #define ONE(NAME, MODE, show) \ 134be614086SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 135be614086SEric W. Biederman NULL, &proc_single_file_operations, \ 136631f9c18SAlexey Dobriyan { .proc_show = show } ) 1371da177e4SLinus Torvalds 138aed54175SVegard Nossum /* 139aed54175SVegard Nossum * Count the number of hardlinks for the pid_entry table, excluding the . 140aed54175SVegard Nossum * and .. links. 141aed54175SVegard Nossum */ 142aed54175SVegard Nossum static unsigned int pid_entry_count_dirs(const struct pid_entry *entries, 143aed54175SVegard Nossum unsigned int n) 144aed54175SVegard Nossum { 145aed54175SVegard Nossum unsigned int i; 146aed54175SVegard Nossum unsigned int count; 147aed54175SVegard Nossum 148aed54175SVegard Nossum count = 0; 149aed54175SVegard Nossum for (i = 0; i < n; ++i) { 150aed54175SVegard Nossum if (S_ISDIR(entries[i].mode)) 151aed54175SVegard Nossum ++count; 152aed54175SVegard Nossum } 153aed54175SVegard Nossum 154aed54175SVegard Nossum return count; 155aed54175SVegard Nossum } 156aed54175SVegard Nossum 157f7ad3c6bSMiklos Szeredi static int get_task_root(struct task_struct *task, struct path *root) 1581da177e4SLinus Torvalds { 1597c2c7d99SHugh Dickins int result = -ENOENT; 1607c2c7d99SHugh Dickins 1610494f6ecSMiklos Szeredi task_lock(task); 162f7ad3c6bSMiklos Szeredi if (task->fs) { 163f7ad3c6bSMiklos Szeredi get_fs_root(task->fs, root); 1647c2c7d99SHugh Dickins result = 0; 1657c2c7d99SHugh Dickins } 1660494f6ecSMiklos Szeredi task_unlock(task); 1677c2c7d99SHugh Dickins return result; 1680494f6ecSMiklos Szeredi } 1690494f6ecSMiklos Szeredi 1707773fbc5SCyrill Gorcunov static int proc_cwd_link(struct dentry *dentry, struct path *path) 1710494f6ecSMiklos Szeredi { 1722b0143b5SDavid Howells struct task_struct *task = get_proc_task(d_inode(dentry)); 1730494f6ecSMiklos Szeredi int result = -ENOENT; 17499f89551SEric W. Biederman 17599f89551SEric W. Biederman if (task) { 176f7ad3c6bSMiklos Szeredi task_lock(task); 177f7ad3c6bSMiklos Szeredi if (task->fs) { 178f7ad3c6bSMiklos Szeredi get_fs_pwd(task->fs, path); 179f7ad3c6bSMiklos Szeredi result = 0; 180f7ad3c6bSMiklos Szeredi } 181f7ad3c6bSMiklos Szeredi task_unlock(task); 18299f89551SEric W. Biederman put_task_struct(task); 18399f89551SEric W. Biederman } 1841da177e4SLinus Torvalds return result; 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1877773fbc5SCyrill Gorcunov static int proc_root_link(struct dentry *dentry, struct path *path) 1881da177e4SLinus Torvalds { 1892b0143b5SDavid Howells struct task_struct *task = get_proc_task(d_inode(dentry)); 1901da177e4SLinus Torvalds int result = -ENOENT; 19199f89551SEric W. Biederman 19299f89551SEric W. Biederman if (task) { 193f7ad3c6bSMiklos Szeredi result = get_task_root(task, path); 19499f89551SEric W. Biederman put_task_struct(task); 19599f89551SEric W. Biederman } 1961da177e4SLinus Torvalds return result; 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 199c2c0bb44SAlexey Dobriyan static ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf, 200c2c0bb44SAlexey Dobriyan size_t _count, loff_t *pos) 2011da177e4SLinus Torvalds { 202c2c0bb44SAlexey Dobriyan struct task_struct *tsk; 203c2c0bb44SAlexey Dobriyan struct mm_struct *mm; 204c2c0bb44SAlexey Dobriyan char *page; 205c2c0bb44SAlexey Dobriyan unsigned long count = _count; 206c2c0bb44SAlexey Dobriyan unsigned long arg_start, arg_end, env_start, env_end; 207c2c0bb44SAlexey Dobriyan unsigned long len1, len2, len; 208c2c0bb44SAlexey Dobriyan unsigned long p; 209c2c0bb44SAlexey Dobriyan char c; 210c2c0bb44SAlexey Dobriyan ssize_t rv; 211c2c0bb44SAlexey Dobriyan 212c2c0bb44SAlexey Dobriyan BUG_ON(*pos < 0); 213c2c0bb44SAlexey Dobriyan 214c2c0bb44SAlexey Dobriyan tsk = get_proc_task(file_inode(file)); 215c2c0bb44SAlexey Dobriyan if (!tsk) 216c2c0bb44SAlexey Dobriyan return -ESRCH; 217c2c0bb44SAlexey Dobriyan mm = get_task_mm(tsk); 218c2c0bb44SAlexey Dobriyan put_task_struct(tsk); 219c2c0bb44SAlexey Dobriyan if (!mm) 2202ca66ff7SAlexey Dobriyan return 0; 221c2c0bb44SAlexey Dobriyan /* Check if process spawned far enough to have cmdline. */ 222c2c0bb44SAlexey Dobriyan if (!mm->env_end) { 223c2c0bb44SAlexey Dobriyan rv = 0; 224c2c0bb44SAlexey Dobriyan goto out_mmput; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds 227c2c0bb44SAlexey Dobriyan page = (char *)__get_free_page(GFP_TEMPORARY); 228c2c0bb44SAlexey Dobriyan if (!page) { 229c2c0bb44SAlexey Dobriyan rv = -ENOMEM; 230c2c0bb44SAlexey Dobriyan goto out_mmput; 231c2c0bb44SAlexey Dobriyan } 232c2c0bb44SAlexey Dobriyan 233c2c0bb44SAlexey Dobriyan down_read(&mm->mmap_sem); 234c2c0bb44SAlexey Dobriyan arg_start = mm->arg_start; 235c2c0bb44SAlexey Dobriyan arg_end = mm->arg_end; 236c2c0bb44SAlexey Dobriyan env_start = mm->env_start; 237c2c0bb44SAlexey Dobriyan env_end = mm->env_end; 238c2c0bb44SAlexey Dobriyan up_read(&mm->mmap_sem); 239c2c0bb44SAlexey Dobriyan 240c2c0bb44SAlexey Dobriyan BUG_ON(arg_start > arg_end); 241c2c0bb44SAlexey Dobriyan BUG_ON(env_start > env_end); 242c2c0bb44SAlexey Dobriyan 243c2c0bb44SAlexey Dobriyan len1 = arg_end - arg_start; 244c2c0bb44SAlexey Dobriyan len2 = env_end - env_start; 245c2c0bb44SAlexey Dobriyan 2463581d458SAlexey Dobriyan /* Empty ARGV. */ 2473581d458SAlexey Dobriyan if (len1 == 0) { 2483581d458SAlexey Dobriyan rv = 0; 2493581d458SAlexey Dobriyan goto out_free_page; 2503581d458SAlexey Dobriyan } 251c2c0bb44SAlexey Dobriyan /* 252c2c0bb44SAlexey Dobriyan * Inherently racy -- command line shares address space 253c2c0bb44SAlexey Dobriyan * with code and data. 254c2c0bb44SAlexey Dobriyan */ 255c2c0bb44SAlexey Dobriyan rv = access_remote_vm(mm, arg_end - 1, &c, 1, 0); 256c2c0bb44SAlexey Dobriyan if (rv <= 0) 257c2c0bb44SAlexey Dobriyan goto out_free_page; 258c2c0bb44SAlexey Dobriyan 259c2c0bb44SAlexey Dobriyan rv = 0; 260c2c0bb44SAlexey Dobriyan 261c2c0bb44SAlexey Dobriyan if (c == '\0') { 262c2c0bb44SAlexey Dobriyan /* Command line (set of strings) occupies whole ARGV. */ 263c2c0bb44SAlexey Dobriyan if (len1 <= *pos) 264c2c0bb44SAlexey Dobriyan goto out_free_page; 265c2c0bb44SAlexey Dobriyan 266c2c0bb44SAlexey Dobriyan p = arg_start + *pos; 267c2c0bb44SAlexey Dobriyan len = len1 - *pos; 268c2c0bb44SAlexey Dobriyan while (count > 0 && len > 0) { 269c2c0bb44SAlexey Dobriyan unsigned int _count; 270c2c0bb44SAlexey Dobriyan int nr_read; 271c2c0bb44SAlexey Dobriyan 272c2c0bb44SAlexey Dobriyan _count = min3(count, len, PAGE_SIZE); 273c2c0bb44SAlexey Dobriyan nr_read = access_remote_vm(mm, p, page, _count, 0); 274c2c0bb44SAlexey Dobriyan if (nr_read < 0) 275c2c0bb44SAlexey Dobriyan rv = nr_read; 276c2c0bb44SAlexey Dobriyan if (nr_read <= 0) 277c2c0bb44SAlexey Dobriyan goto out_free_page; 278c2c0bb44SAlexey Dobriyan 279c2c0bb44SAlexey Dobriyan if (copy_to_user(buf, page, nr_read)) { 280c2c0bb44SAlexey Dobriyan rv = -EFAULT; 281c2c0bb44SAlexey Dobriyan goto out_free_page; 282c2c0bb44SAlexey Dobriyan } 283c2c0bb44SAlexey Dobriyan 284c2c0bb44SAlexey Dobriyan p += nr_read; 285c2c0bb44SAlexey Dobriyan len -= nr_read; 286c2c0bb44SAlexey Dobriyan buf += nr_read; 287c2c0bb44SAlexey Dobriyan count -= nr_read; 288c2c0bb44SAlexey Dobriyan rv += nr_read; 289c2c0bb44SAlexey Dobriyan } 290c2c0bb44SAlexey Dobriyan } else { 291c2c0bb44SAlexey Dobriyan /* 292c2c0bb44SAlexey Dobriyan * Command line (1 string) occupies ARGV and maybe 293c2c0bb44SAlexey Dobriyan * extends into ENVP. 294c2c0bb44SAlexey Dobriyan */ 295c2c0bb44SAlexey Dobriyan if (len1 + len2 <= *pos) 296c2c0bb44SAlexey Dobriyan goto skip_argv_envp; 297c2c0bb44SAlexey Dobriyan if (len1 <= *pos) 298c2c0bb44SAlexey Dobriyan goto skip_argv; 299c2c0bb44SAlexey Dobriyan 300c2c0bb44SAlexey Dobriyan p = arg_start + *pos; 301c2c0bb44SAlexey Dobriyan len = len1 - *pos; 302c2c0bb44SAlexey Dobriyan while (count > 0 && len > 0) { 303c2c0bb44SAlexey Dobriyan unsigned int _count, l; 304c2c0bb44SAlexey Dobriyan int nr_read; 305c2c0bb44SAlexey Dobriyan bool final; 306c2c0bb44SAlexey Dobriyan 307c2c0bb44SAlexey Dobriyan _count = min3(count, len, PAGE_SIZE); 308c2c0bb44SAlexey Dobriyan nr_read = access_remote_vm(mm, p, page, _count, 0); 309c2c0bb44SAlexey Dobriyan if (nr_read < 0) 310c2c0bb44SAlexey Dobriyan rv = nr_read; 311c2c0bb44SAlexey Dobriyan if (nr_read <= 0) 312c2c0bb44SAlexey Dobriyan goto out_free_page; 313c2c0bb44SAlexey Dobriyan 314c2c0bb44SAlexey Dobriyan /* 315c2c0bb44SAlexey Dobriyan * Command line can be shorter than whole ARGV 316c2c0bb44SAlexey Dobriyan * even if last "marker" byte says it is not. 317c2c0bb44SAlexey Dobriyan */ 318c2c0bb44SAlexey Dobriyan final = false; 319c2c0bb44SAlexey Dobriyan l = strnlen(page, nr_read); 320c2c0bb44SAlexey Dobriyan if (l < nr_read) { 321c2c0bb44SAlexey Dobriyan nr_read = l; 322c2c0bb44SAlexey Dobriyan final = true; 323c2c0bb44SAlexey Dobriyan } 324c2c0bb44SAlexey Dobriyan 325c2c0bb44SAlexey Dobriyan if (copy_to_user(buf, page, nr_read)) { 326c2c0bb44SAlexey Dobriyan rv = -EFAULT; 327c2c0bb44SAlexey Dobriyan goto out_free_page; 328c2c0bb44SAlexey Dobriyan } 329c2c0bb44SAlexey Dobriyan 330c2c0bb44SAlexey Dobriyan p += nr_read; 331c2c0bb44SAlexey Dobriyan len -= nr_read; 332c2c0bb44SAlexey Dobriyan buf += nr_read; 333c2c0bb44SAlexey Dobriyan count -= nr_read; 334c2c0bb44SAlexey Dobriyan rv += nr_read; 335c2c0bb44SAlexey Dobriyan 336c2c0bb44SAlexey Dobriyan if (final) 337c2c0bb44SAlexey Dobriyan goto out_free_page; 338c2c0bb44SAlexey Dobriyan } 339c2c0bb44SAlexey Dobriyan skip_argv: 340c2c0bb44SAlexey Dobriyan /* 341c2c0bb44SAlexey Dobriyan * Command line (1 string) occupies ARGV and 342c2c0bb44SAlexey Dobriyan * extends into ENVP. 343c2c0bb44SAlexey Dobriyan */ 344c2c0bb44SAlexey Dobriyan if (len1 <= *pos) { 345c2c0bb44SAlexey Dobriyan p = env_start + *pos - len1; 346c2c0bb44SAlexey Dobriyan len = len1 + len2 - *pos; 347c2c0bb44SAlexey Dobriyan } else { 348c2c0bb44SAlexey Dobriyan p = env_start; 349c2c0bb44SAlexey Dobriyan len = len2; 350c2c0bb44SAlexey Dobriyan } 351c2c0bb44SAlexey Dobriyan while (count > 0 && len > 0) { 352c2c0bb44SAlexey Dobriyan unsigned int _count, l; 353c2c0bb44SAlexey Dobriyan int nr_read; 354c2c0bb44SAlexey Dobriyan bool final; 355c2c0bb44SAlexey Dobriyan 356c2c0bb44SAlexey Dobriyan _count = min3(count, len, PAGE_SIZE); 357c2c0bb44SAlexey Dobriyan nr_read = access_remote_vm(mm, p, page, _count, 0); 358c2c0bb44SAlexey Dobriyan if (nr_read < 0) 359c2c0bb44SAlexey Dobriyan rv = nr_read; 360c2c0bb44SAlexey Dobriyan if (nr_read <= 0) 361c2c0bb44SAlexey Dobriyan goto out_free_page; 362c2c0bb44SAlexey Dobriyan 363c2c0bb44SAlexey Dobriyan /* Find EOS. */ 364c2c0bb44SAlexey Dobriyan final = false; 365c2c0bb44SAlexey Dobriyan l = strnlen(page, nr_read); 366c2c0bb44SAlexey Dobriyan if (l < nr_read) { 367c2c0bb44SAlexey Dobriyan nr_read = l; 368c2c0bb44SAlexey Dobriyan final = true; 369c2c0bb44SAlexey Dobriyan } 370c2c0bb44SAlexey Dobriyan 371c2c0bb44SAlexey Dobriyan if (copy_to_user(buf, page, nr_read)) { 372c2c0bb44SAlexey Dobriyan rv = -EFAULT; 373c2c0bb44SAlexey Dobriyan goto out_free_page; 374c2c0bb44SAlexey Dobriyan } 375c2c0bb44SAlexey Dobriyan 376c2c0bb44SAlexey Dobriyan p += nr_read; 377c2c0bb44SAlexey Dobriyan len -= nr_read; 378c2c0bb44SAlexey Dobriyan buf += nr_read; 379c2c0bb44SAlexey Dobriyan count -= nr_read; 380c2c0bb44SAlexey Dobriyan rv += nr_read; 381c2c0bb44SAlexey Dobriyan 382c2c0bb44SAlexey Dobriyan if (final) 383c2c0bb44SAlexey Dobriyan goto out_free_page; 384c2c0bb44SAlexey Dobriyan } 385c2c0bb44SAlexey Dobriyan skip_argv_envp: 386c2c0bb44SAlexey Dobriyan ; 387c2c0bb44SAlexey Dobriyan } 388c2c0bb44SAlexey Dobriyan 389c2c0bb44SAlexey Dobriyan out_free_page: 390c2c0bb44SAlexey Dobriyan free_page((unsigned long)page); 391c2c0bb44SAlexey Dobriyan out_mmput: 392c2c0bb44SAlexey Dobriyan mmput(mm); 393c2c0bb44SAlexey Dobriyan if (rv > 0) 394c2c0bb44SAlexey Dobriyan *pos += rv; 395c2c0bb44SAlexey Dobriyan return rv; 396c2c0bb44SAlexey Dobriyan } 397c2c0bb44SAlexey Dobriyan 398c2c0bb44SAlexey Dobriyan static const struct file_operations proc_pid_cmdline_ops = { 399c2c0bb44SAlexey Dobriyan .read = proc_pid_cmdline_read, 400c2c0bb44SAlexey Dobriyan .llseek = generic_file_llseek, 401c2c0bb44SAlexey Dobriyan }; 402c2c0bb44SAlexey Dobriyan 403f9ea536eSAlexey Dobriyan static int proc_pid_auxv(struct seq_file *m, struct pid_namespace *ns, 404f9ea536eSAlexey Dobriyan struct pid *pid, struct task_struct *task) 4051da177e4SLinus Torvalds { 406e7dcd999SCong Wang struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ); 4072fadaef4SAl Viro if (mm && !IS_ERR(mm)) { 4081da177e4SLinus Torvalds unsigned int nwords = 0; 409dfe6b7d9SHannes Eder do { 4101da177e4SLinus Torvalds nwords += 2; 411dfe6b7d9SHannes Eder } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 412f9ea536eSAlexey Dobriyan seq_write(m, mm->saved_auxv, nwords * sizeof(mm->saved_auxv[0])); 4131da177e4SLinus Torvalds mmput(mm); 414f9ea536eSAlexey Dobriyan return 0; 415f9ea536eSAlexey Dobriyan } else 416f9ea536eSAlexey Dobriyan return PTR_ERR(mm); 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 4211da177e4SLinus Torvalds /* 4221da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 4231da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 4241da177e4SLinus Torvalds */ 425edfcd606SAlexey Dobriyan static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns, 426edfcd606SAlexey Dobriyan struct pid *pid, struct task_struct *task) 4271da177e4SLinus Torvalds { 428ffb45122SAlexey Dobriyan unsigned long wchan; 4299281aceaSTejun Heo char symname[KSYM_NAME_LEN]; 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds wchan = get_wchan(task); 4321da177e4SLinus Torvalds 43325ce3191SJoe Perches if (lookup_symbol_name(wchan, symname) < 0) { 434f83ce3e6SJake Edge if (!ptrace_may_access(task, PTRACE_MODE_READ)) 435f83ce3e6SJake Edge return 0; 43625ce3191SJoe Perches seq_printf(m, "%lu", wchan); 43725ce3191SJoe Perches } else { 43825ce3191SJoe Perches seq_printf(m, "%s", symname); 43925ce3191SJoe Perches } 44025ce3191SJoe Perches 44125ce3191SJoe Perches return 0; 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 4441da177e4SLinus Torvalds 445a9712bc1SAl Viro static int lock_trace(struct task_struct *task) 446a9712bc1SAl Viro { 447a9712bc1SAl Viro int err = mutex_lock_killable(&task->signal->cred_guard_mutex); 448a9712bc1SAl Viro if (err) 449a9712bc1SAl Viro return err; 450a9712bc1SAl Viro if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) { 451a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 452a9712bc1SAl Viro return -EPERM; 453a9712bc1SAl Viro } 454a9712bc1SAl Viro return 0; 455a9712bc1SAl Viro } 456a9712bc1SAl Viro 457a9712bc1SAl Viro static void unlock_trace(struct task_struct *task) 458a9712bc1SAl Viro { 459a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 460a9712bc1SAl Viro } 461a9712bc1SAl Viro 4622ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 4632ec220e2SKen Chen 4642ec220e2SKen Chen #define MAX_STACK_TRACE_DEPTH 64 4652ec220e2SKen Chen 4662ec220e2SKen Chen static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns, 4672ec220e2SKen Chen struct pid *pid, struct task_struct *task) 4682ec220e2SKen Chen { 4692ec220e2SKen Chen struct stack_trace trace; 4702ec220e2SKen Chen unsigned long *entries; 471a9712bc1SAl Viro int err; 4722ec220e2SKen Chen int i; 4732ec220e2SKen Chen 4742ec220e2SKen Chen entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL); 4752ec220e2SKen Chen if (!entries) 4762ec220e2SKen Chen return -ENOMEM; 4772ec220e2SKen Chen 4782ec220e2SKen Chen trace.nr_entries = 0; 4792ec220e2SKen Chen trace.max_entries = MAX_STACK_TRACE_DEPTH; 4802ec220e2SKen Chen trace.entries = entries; 4812ec220e2SKen Chen trace.skip = 0; 482a9712bc1SAl Viro 483a9712bc1SAl Viro err = lock_trace(task); 484a9712bc1SAl Viro if (!err) { 4852ec220e2SKen Chen save_stack_trace_tsk(task, &trace); 4862ec220e2SKen Chen 4872ec220e2SKen Chen for (i = 0; i < trace.nr_entries; i++) { 48851e03149SKonstantin Khlebnikov seq_printf(m, "[<%pK>] %pS\n", 4892ec220e2SKen Chen (void *)entries[i], (void *)entries[i]); 4902ec220e2SKen Chen } 491a9712bc1SAl Viro unlock_trace(task); 492a9712bc1SAl Viro } 4932ec220e2SKen Chen kfree(entries); 4942ec220e2SKen Chen 495a9712bc1SAl Viro return err; 4962ec220e2SKen Chen } 4972ec220e2SKen Chen #endif 4982ec220e2SKen Chen 4995968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 5001da177e4SLinus Torvalds /* 5011da177e4SLinus Torvalds * Provides /proc/PID/schedstat 5021da177e4SLinus Torvalds */ 503f6e826caSAlexey Dobriyan static int proc_pid_schedstat(struct seq_file *m, struct pid_namespace *ns, 504f6e826caSAlexey Dobriyan struct pid *pid, struct task_struct *task) 5051da177e4SLinus Torvalds { 5065968ceceSNaveen N. Rao if (unlikely(!sched_info_on())) 5075968ceceSNaveen N. Rao seq_printf(m, "0 0 0\n"); 5085968ceceSNaveen N. Rao else 50925ce3191SJoe Perches seq_printf(m, "%llu %llu %lu\n", 510826e08b0SIngo Molnar (unsigned long long)task->se.sum_exec_runtime, 511826e08b0SIngo Molnar (unsigned long long)task->sched_info.run_delay, 5122d72376bSIngo Molnar task->sched_info.pcount); 51325ce3191SJoe Perches 51425ce3191SJoe Perches return 0; 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds #endif 5171da177e4SLinus Torvalds 5189745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 5199745512cSArjan van de Ven static int lstats_show_proc(struct seq_file *m, void *v) 5209745512cSArjan van de Ven { 5219745512cSArjan van de Ven int i; 52213d77c37SHiroshi Shimamoto struct inode *inode = m->private; 52313d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(inode); 5249745512cSArjan van de Ven 52513d77c37SHiroshi Shimamoto if (!task) 52613d77c37SHiroshi Shimamoto return -ESRCH; 52713d77c37SHiroshi Shimamoto seq_puts(m, "Latency Top version : v0.1\n"); 5289745512cSArjan van de Ven for (i = 0; i < 32; i++) { 52934e49d4fSJoe Perches struct latency_record *lr = &task->latency_record[i]; 53034e49d4fSJoe Perches if (lr->backtrace[0]) { 5319745512cSArjan van de Ven int q; 5329745512cSArjan van de Ven seq_printf(m, "%i %li %li", 53334e49d4fSJoe Perches lr->count, lr->time, lr->max); 5349745512cSArjan van de Ven for (q = 0; q < LT_BACKTRACEDEPTH; q++) { 53534e49d4fSJoe Perches unsigned long bt = lr->backtrace[q]; 53634e49d4fSJoe Perches if (!bt) 5379745512cSArjan van de Ven break; 53834e49d4fSJoe Perches if (bt == ULONG_MAX) 5399745512cSArjan van de Ven break; 54034e49d4fSJoe Perches seq_printf(m, " %ps", (void *)bt); 5419745512cSArjan van de Ven } 5429d6de12fSAlexey Dobriyan seq_putc(m, '\n'); 5439745512cSArjan van de Ven } 5449745512cSArjan van de Ven 5459745512cSArjan van de Ven } 54613d77c37SHiroshi Shimamoto put_task_struct(task); 5479745512cSArjan van de Ven return 0; 5489745512cSArjan van de Ven } 5499745512cSArjan van de Ven 5509745512cSArjan van de Ven static int lstats_open(struct inode *inode, struct file *file) 5519745512cSArjan van de Ven { 55213d77c37SHiroshi Shimamoto return single_open(file, lstats_show_proc, inode); 553d6643d12SHiroshi Shimamoto } 554d6643d12SHiroshi Shimamoto 5559745512cSArjan van de Ven static ssize_t lstats_write(struct file *file, const char __user *buf, 5569745512cSArjan van de Ven size_t count, loff_t *offs) 5579745512cSArjan van de Ven { 558496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 5599745512cSArjan van de Ven 56013d77c37SHiroshi Shimamoto if (!task) 56113d77c37SHiroshi Shimamoto return -ESRCH; 5629745512cSArjan van de Ven clear_all_latency_tracing(task); 56313d77c37SHiroshi Shimamoto put_task_struct(task); 5649745512cSArjan van de Ven 5659745512cSArjan van de Ven return count; 5669745512cSArjan van de Ven } 5679745512cSArjan van de Ven 5689745512cSArjan van de Ven static const struct file_operations proc_lstats_operations = { 5699745512cSArjan van de Ven .open = lstats_open, 5709745512cSArjan van de Ven .read = seq_read, 5719745512cSArjan van de Ven .write = lstats_write, 5729745512cSArjan van de Ven .llseek = seq_lseek, 57313d77c37SHiroshi Shimamoto .release = single_release, 5749745512cSArjan van de Ven }; 5759745512cSArjan van de Ven 5769745512cSArjan van de Ven #endif 5779745512cSArjan van de Ven 5786ba51e37SAlexey Dobriyan static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns, 5796ba51e37SAlexey Dobriyan struct pid *pid, struct task_struct *task) 5801da177e4SLinus Torvalds { 581a7f638f9SDavid Rientjes unsigned long totalpages = totalram_pages + total_swap_pages; 582b95c35e7SOleg Nesterov unsigned long points = 0; 5831da177e4SLinus Torvalds 58419c5d45aSAlexey Dobriyan read_lock(&tasklist_lock); 585b95c35e7SOleg Nesterov if (pid_alive(task)) 586a7f638f9SDavid Rientjes points = oom_badness(task, NULL, NULL, totalpages) * 587a7f638f9SDavid Rientjes 1000 / totalpages; 58819c5d45aSAlexey Dobriyan read_unlock(&tasklist_lock); 58925ce3191SJoe Perches seq_printf(m, "%lu\n", points); 59025ce3191SJoe Perches 59125ce3191SJoe Perches return 0; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds 594d85f50d5SNeil Horman struct limit_names { 595cedbccabSAlexey Dobriyan const char *name; 596cedbccabSAlexey Dobriyan const char *unit; 597d85f50d5SNeil Horman }; 598d85f50d5SNeil Horman 599d85f50d5SNeil Horman static const struct limit_names lnames[RLIM_NLIMITS] = { 600cff4edb5SKees Cook [RLIMIT_CPU] = {"Max cpu time", "seconds"}, 601d85f50d5SNeil Horman [RLIMIT_FSIZE] = {"Max file size", "bytes"}, 602d85f50d5SNeil Horman [RLIMIT_DATA] = {"Max data size", "bytes"}, 603d85f50d5SNeil Horman [RLIMIT_STACK] = {"Max stack size", "bytes"}, 604d85f50d5SNeil Horman [RLIMIT_CORE] = {"Max core file size", "bytes"}, 605d85f50d5SNeil Horman [RLIMIT_RSS] = {"Max resident set", "bytes"}, 606d85f50d5SNeil Horman [RLIMIT_NPROC] = {"Max processes", "processes"}, 607d85f50d5SNeil Horman [RLIMIT_NOFILE] = {"Max open files", "files"}, 608d85f50d5SNeil Horman [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"}, 609d85f50d5SNeil Horman [RLIMIT_AS] = {"Max address space", "bytes"}, 610d85f50d5SNeil Horman [RLIMIT_LOCKS] = {"Max file locks", "locks"}, 611d85f50d5SNeil Horman [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"}, 612d85f50d5SNeil Horman [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"}, 613d85f50d5SNeil Horman [RLIMIT_NICE] = {"Max nice priority", NULL}, 614d85f50d5SNeil Horman [RLIMIT_RTPRIO] = {"Max realtime priority", NULL}, 6158808117cSEugene Teo [RLIMIT_RTTIME] = {"Max realtime timeout", "us"}, 616d85f50d5SNeil Horman }; 617d85f50d5SNeil Horman 618d85f50d5SNeil Horman /* Display limits for a process */ 6191c963eb1SAlexey Dobriyan static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns, 6201c963eb1SAlexey Dobriyan struct pid *pid, struct task_struct *task) 621d85f50d5SNeil Horman { 622d85f50d5SNeil Horman unsigned int i; 623d85f50d5SNeil Horman unsigned long flags; 624d85f50d5SNeil Horman 625d85f50d5SNeil Horman struct rlimit rlim[RLIM_NLIMITS]; 626d85f50d5SNeil Horman 627a6bebbc8SLai Jiangshan if (!lock_task_sighand(task, &flags)) 628d85f50d5SNeil Horman return 0; 629d85f50d5SNeil Horman memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS); 630d85f50d5SNeil Horman unlock_task_sighand(task, &flags); 631d85f50d5SNeil Horman 632d85f50d5SNeil Horman /* 633d85f50d5SNeil Horman * print the file header 634d85f50d5SNeil Horman */ 6351c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s %-20s %-10s\n", 636d85f50d5SNeil Horman "Limit", "Soft Limit", "Hard Limit", "Units"); 637d85f50d5SNeil Horman 638d85f50d5SNeil Horman for (i = 0; i < RLIM_NLIMITS; i++) { 639d85f50d5SNeil Horman if (rlim[i].rlim_cur == RLIM_INFINITY) 6401c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s ", 641d85f50d5SNeil Horman lnames[i].name, "unlimited"); 642d85f50d5SNeil Horman else 6431c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20lu ", 644d85f50d5SNeil Horman lnames[i].name, rlim[i].rlim_cur); 645d85f50d5SNeil Horman 646d85f50d5SNeil Horman if (rlim[i].rlim_max == RLIM_INFINITY) 6471c963eb1SAlexey Dobriyan seq_printf(m, "%-20s ", "unlimited"); 648d85f50d5SNeil Horman else 6491c963eb1SAlexey Dobriyan seq_printf(m, "%-20lu ", rlim[i].rlim_max); 650d85f50d5SNeil Horman 651d85f50d5SNeil Horman if (lnames[i].unit) 6521c963eb1SAlexey Dobriyan seq_printf(m, "%-10s\n", lnames[i].unit); 653d85f50d5SNeil Horman else 6541c963eb1SAlexey Dobriyan seq_putc(m, '\n'); 655d85f50d5SNeil Horman } 656d85f50d5SNeil Horman 6571c963eb1SAlexey Dobriyan return 0; 658d85f50d5SNeil Horman } 659d85f50d5SNeil Horman 660ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 66109d93bd6SAlexey Dobriyan static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns, 66209d93bd6SAlexey Dobriyan struct pid *pid, struct task_struct *task) 663ebcb6734SRoland McGrath { 664ebcb6734SRoland McGrath long nr; 665ebcb6734SRoland McGrath unsigned long args[6], sp, pc; 66625ce3191SJoe Perches int res; 66725ce3191SJoe Perches 66825ce3191SJoe Perches res = lock_trace(task); 669a9712bc1SAl Viro if (res) 670a9712bc1SAl Viro return res; 671ebcb6734SRoland McGrath 672ebcb6734SRoland McGrath if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) 67309d93bd6SAlexey Dobriyan seq_puts(m, "running\n"); 674a9712bc1SAl Viro else if (nr < 0) 67509d93bd6SAlexey Dobriyan seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc); 676a9712bc1SAl Viro else 67709d93bd6SAlexey Dobriyan seq_printf(m, 678ebcb6734SRoland McGrath "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 679ebcb6734SRoland McGrath nr, 680ebcb6734SRoland McGrath args[0], args[1], args[2], args[3], args[4], args[5], 681ebcb6734SRoland McGrath sp, pc); 682a9712bc1SAl Viro unlock_trace(task); 68325ce3191SJoe Perches 68425ce3191SJoe Perches return 0; 685ebcb6734SRoland McGrath } 686ebcb6734SRoland McGrath #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */ 687ebcb6734SRoland McGrath 6881da177e4SLinus Torvalds /************************************************************************/ 6891da177e4SLinus Torvalds /* Here the fs part begins */ 6901da177e4SLinus Torvalds /************************************************************************/ 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds /* permission checks */ 693778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 6941da177e4SLinus Torvalds { 695778c1144SEric W. Biederman struct task_struct *task; 696778c1144SEric W. Biederman int allowed = 0; 697df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 698df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 699df26c40eSEric W. Biederman * information. 700778c1144SEric W. Biederman */ 701778c1144SEric W. Biederman task = get_proc_task(inode); 702df26c40eSEric W. Biederman if (task) { 703006ebb40SStephen Smalley allowed = ptrace_may_access(task, PTRACE_MODE_READ); 704778c1144SEric W. Biederman put_task_struct(task); 705df26c40eSEric W. Biederman } 706778c1144SEric W. Biederman return allowed; 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 7096b4e306aSEric W. Biederman int proc_setattr(struct dentry *dentry, struct iattr *attr) 7106d76fa58SLinus Torvalds { 7116d76fa58SLinus Torvalds int error; 7122b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 7136d76fa58SLinus Torvalds 7146d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 7156d76fa58SLinus Torvalds return -EPERM; 7166d76fa58SLinus Torvalds 7176d76fa58SLinus Torvalds error = inode_change_ok(inode, attr); 7181025774cSChristoph Hellwig if (error) 7196d76fa58SLinus Torvalds return error; 7201025774cSChristoph Hellwig 7211025774cSChristoph Hellwig setattr_copy(inode, attr); 7221025774cSChristoph Hellwig mark_inode_dirty(inode); 7231025774cSChristoph Hellwig return 0; 7246d76fa58SLinus Torvalds } 7256d76fa58SLinus Torvalds 7260499680aSVasiliy Kulikov /* 7270499680aSVasiliy Kulikov * May current process learn task's sched/cmdline info (for hide_pid_min=1) 7280499680aSVasiliy Kulikov * or euid/egid (for hide_pid_min=2)? 7290499680aSVasiliy Kulikov */ 7300499680aSVasiliy Kulikov static bool has_pid_permissions(struct pid_namespace *pid, 7310499680aSVasiliy Kulikov struct task_struct *task, 7320499680aSVasiliy Kulikov int hide_pid_min) 7330499680aSVasiliy Kulikov { 7340499680aSVasiliy Kulikov if (pid->hide_pid < hide_pid_min) 7350499680aSVasiliy Kulikov return true; 7360499680aSVasiliy Kulikov if (in_group_p(pid->pid_gid)) 7370499680aSVasiliy Kulikov return true; 7380499680aSVasiliy Kulikov return ptrace_may_access(task, PTRACE_MODE_READ); 7390499680aSVasiliy Kulikov } 7400499680aSVasiliy Kulikov 7410499680aSVasiliy Kulikov 7420499680aSVasiliy Kulikov static int proc_pid_permission(struct inode *inode, int mask) 7430499680aSVasiliy Kulikov { 7440499680aSVasiliy Kulikov struct pid_namespace *pid = inode->i_sb->s_fs_info; 7450499680aSVasiliy Kulikov struct task_struct *task; 7460499680aSVasiliy Kulikov bool has_perms; 7470499680aSVasiliy Kulikov 7480499680aSVasiliy Kulikov task = get_proc_task(inode); 749a2ef990aSXiaotian Feng if (!task) 750a2ef990aSXiaotian Feng return -ESRCH; 7510499680aSVasiliy Kulikov has_perms = has_pid_permissions(pid, task, 1); 7520499680aSVasiliy Kulikov put_task_struct(task); 7530499680aSVasiliy Kulikov 7540499680aSVasiliy Kulikov if (!has_perms) { 7550499680aSVasiliy Kulikov if (pid->hide_pid == 2) { 7560499680aSVasiliy Kulikov /* 7570499680aSVasiliy Kulikov * Let's make getdents(), stat(), and open() 7580499680aSVasiliy Kulikov * consistent with each other. If a process 7590499680aSVasiliy Kulikov * may not stat() a file, it shouldn't be seen 7600499680aSVasiliy Kulikov * in procfs at all. 7610499680aSVasiliy Kulikov */ 7620499680aSVasiliy Kulikov return -ENOENT; 7630499680aSVasiliy Kulikov } 7640499680aSVasiliy Kulikov 7650499680aSVasiliy Kulikov return -EPERM; 7660499680aSVasiliy Kulikov } 7670499680aSVasiliy Kulikov return generic_permission(inode, mask); 7680499680aSVasiliy Kulikov } 7690499680aSVasiliy Kulikov 7700499680aSVasiliy Kulikov 7710499680aSVasiliy Kulikov 772c5ef1c42SArjan van de Ven static const struct inode_operations proc_def_inode_operations = { 7736d76fa58SLinus Torvalds .setattr = proc_setattr, 7746d76fa58SLinus Torvalds }; 7756d76fa58SLinus Torvalds 776be614086SEric W. Biederman static int proc_single_show(struct seq_file *m, void *v) 777be614086SEric W. Biederman { 778be614086SEric W. Biederman struct inode *inode = m->private; 779be614086SEric W. Biederman struct pid_namespace *ns; 780be614086SEric W. Biederman struct pid *pid; 781be614086SEric W. Biederman struct task_struct *task; 782be614086SEric W. Biederman int ret; 783be614086SEric W. Biederman 784be614086SEric W. Biederman ns = inode->i_sb->s_fs_info; 785be614086SEric W. Biederman pid = proc_pid(inode); 786be614086SEric W. Biederman task = get_pid_task(pid, PIDTYPE_PID); 787be614086SEric W. Biederman if (!task) 788be614086SEric W. Biederman return -ESRCH; 789be614086SEric W. Biederman 790be614086SEric W. Biederman ret = PROC_I(inode)->op.proc_show(m, ns, pid, task); 791be614086SEric W. Biederman 792be614086SEric W. Biederman put_task_struct(task); 793be614086SEric W. Biederman return ret; 794be614086SEric W. Biederman } 795be614086SEric W. Biederman 796be614086SEric W. Biederman static int proc_single_open(struct inode *inode, struct file *filp) 797be614086SEric W. Biederman { 798c6a34058SJovi Zhang return single_open(filp, proc_single_show, inode); 799be614086SEric W. Biederman } 800be614086SEric W. Biederman 801be614086SEric W. Biederman static const struct file_operations proc_single_file_operations = { 802be614086SEric W. Biederman .open = proc_single_open, 803be614086SEric W. Biederman .read = seq_read, 804be614086SEric W. Biederman .llseek = seq_lseek, 805be614086SEric W. Biederman .release = single_release, 806be614086SEric W. Biederman }; 807be614086SEric W. Biederman 8085381e169SOleg Nesterov 8095381e169SOleg Nesterov struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode) 8101da177e4SLinus Torvalds { 8115381e169SOleg Nesterov struct task_struct *task = get_proc_task(inode); 8125381e169SOleg Nesterov struct mm_struct *mm = ERR_PTR(-ESRCH); 813e268337dSLinus Torvalds 8145381e169SOleg Nesterov if (task) { 815b409e578SCong Wang mm = mm_access(task, mode); 816e268337dSLinus Torvalds put_task_struct(task); 817e268337dSLinus Torvalds 8185381e169SOleg Nesterov if (!IS_ERR_OR_NULL(mm)) { 8196d08f2c7SOleg Nesterov /* ensure this mm_struct can't be freed */ 8206d08f2c7SOleg Nesterov atomic_inc(&mm->mm_count); 8216d08f2c7SOleg Nesterov /* but do not pin its memory */ 8226d08f2c7SOleg Nesterov mmput(mm); 8236d08f2c7SOleg Nesterov } 8245381e169SOleg Nesterov } 8255381e169SOleg Nesterov 8265381e169SOleg Nesterov return mm; 8275381e169SOleg Nesterov } 8285381e169SOleg Nesterov 8295381e169SOleg Nesterov static int __mem_open(struct inode *inode, struct file *file, unsigned int mode) 8305381e169SOleg Nesterov { 8315381e169SOleg Nesterov struct mm_struct *mm = proc_mem_open(inode, mode); 8325381e169SOleg Nesterov 8335381e169SOleg Nesterov if (IS_ERR(mm)) 8345381e169SOleg Nesterov return PTR_ERR(mm); 8356d08f2c7SOleg Nesterov 836e268337dSLinus Torvalds file->private_data = mm; 8371da177e4SLinus Torvalds return 0; 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds 840b409e578SCong Wang static int mem_open(struct inode *inode, struct file *file) 841b409e578SCong Wang { 842bc452b4bSDjalal Harouni int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH); 843bc452b4bSDjalal Harouni 844bc452b4bSDjalal Harouni /* OK to pass negative loff_t, we can catch out-of-range */ 845bc452b4bSDjalal Harouni file->f_mode |= FMODE_UNSIGNED_OFFSET; 846bc452b4bSDjalal Harouni 847bc452b4bSDjalal Harouni return ret; 848b409e578SCong Wang } 849b409e578SCong Wang 850572d34b9SOleg Nesterov static ssize_t mem_rw(struct file *file, char __user *buf, 851572d34b9SOleg Nesterov size_t count, loff_t *ppos, int write) 8521da177e4SLinus Torvalds { 853e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 854572d34b9SOleg Nesterov unsigned long addr = *ppos; 855572d34b9SOleg Nesterov ssize_t copied; 8561da177e4SLinus Torvalds char *page; 8571da177e4SLinus Torvalds 858e268337dSLinus Torvalds if (!mm) 859e268337dSLinus Torvalds return 0; 8601da177e4SLinus Torvalds 861e12ba74dSMel Gorman page = (char *)__get_free_page(GFP_TEMPORARY); 8621da177e4SLinus Torvalds if (!page) 863e268337dSLinus Torvalds return -ENOMEM; 8641da177e4SLinus Torvalds 865f7ca54f4SFrederik Deweerdt copied = 0; 8666d08f2c7SOleg Nesterov if (!atomic_inc_not_zero(&mm->mm_users)) 8676d08f2c7SOleg Nesterov goto free; 8686d08f2c7SOleg Nesterov 8691da177e4SLinus Torvalds while (count > 0) { 870572d34b9SOleg Nesterov int this_len = min_t(int, count, PAGE_SIZE); 8711da177e4SLinus Torvalds 872572d34b9SOleg Nesterov if (write && copy_from_user(page, buf, this_len)) { 8731da177e4SLinus Torvalds copied = -EFAULT; 8741da177e4SLinus Torvalds break; 8751da177e4SLinus Torvalds } 876572d34b9SOleg Nesterov 877572d34b9SOleg Nesterov this_len = access_remote_vm(mm, addr, page, this_len, write); 878572d34b9SOleg Nesterov if (!this_len) { 8791da177e4SLinus Torvalds if (!copied) 8801da177e4SLinus Torvalds copied = -EIO; 8811da177e4SLinus Torvalds break; 8821da177e4SLinus Torvalds } 883572d34b9SOleg Nesterov 884572d34b9SOleg Nesterov if (!write && copy_to_user(buf, page, this_len)) { 885572d34b9SOleg Nesterov copied = -EFAULT; 886572d34b9SOleg Nesterov break; 8871da177e4SLinus Torvalds } 888572d34b9SOleg Nesterov 889572d34b9SOleg Nesterov buf += this_len; 890572d34b9SOleg Nesterov addr += this_len; 891572d34b9SOleg Nesterov copied += this_len; 892572d34b9SOleg Nesterov count -= this_len; 893572d34b9SOleg Nesterov } 894572d34b9SOleg Nesterov *ppos = addr; 89530cd8903SKOSAKI Motohiro 8966d08f2c7SOleg Nesterov mmput(mm); 8976d08f2c7SOleg Nesterov free: 89830cd8903SKOSAKI Motohiro free_page((unsigned long) page); 8991da177e4SLinus Torvalds return copied; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 902572d34b9SOleg Nesterov static ssize_t mem_read(struct file *file, char __user *buf, 903572d34b9SOleg Nesterov size_t count, loff_t *ppos) 904572d34b9SOleg Nesterov { 905572d34b9SOleg Nesterov return mem_rw(file, buf, count, ppos, 0); 906572d34b9SOleg Nesterov } 907572d34b9SOleg Nesterov 908572d34b9SOleg Nesterov static ssize_t mem_write(struct file *file, const char __user *buf, 909572d34b9SOleg Nesterov size_t count, loff_t *ppos) 910572d34b9SOleg Nesterov { 911572d34b9SOleg Nesterov return mem_rw(file, (char __user*)buf, count, ppos, 1); 912572d34b9SOleg Nesterov } 913572d34b9SOleg Nesterov 91485863e47SMatt Mackall loff_t mem_lseek(struct file *file, loff_t offset, int orig) 9151da177e4SLinus Torvalds { 9161da177e4SLinus Torvalds switch (orig) { 9171da177e4SLinus Torvalds case 0: 9181da177e4SLinus Torvalds file->f_pos = offset; 9191da177e4SLinus Torvalds break; 9201da177e4SLinus Torvalds case 1: 9211da177e4SLinus Torvalds file->f_pos += offset; 9221da177e4SLinus Torvalds break; 9231da177e4SLinus Torvalds default: 9241da177e4SLinus Torvalds return -EINVAL; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds force_successful_syscall_return(); 9271da177e4SLinus Torvalds return file->f_pos; 9281da177e4SLinus Torvalds } 9291da177e4SLinus Torvalds 930e268337dSLinus Torvalds static int mem_release(struct inode *inode, struct file *file) 931e268337dSLinus Torvalds { 932e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 93371879d3cSOleg Nesterov if (mm) 9346d08f2c7SOleg Nesterov mmdrop(mm); 935e268337dSLinus Torvalds return 0; 936e268337dSLinus Torvalds } 937e268337dSLinus Torvalds 93800977a59SArjan van de Ven static const struct file_operations proc_mem_operations = { 9391da177e4SLinus Torvalds .llseek = mem_lseek, 9401da177e4SLinus Torvalds .read = mem_read, 9411da177e4SLinus Torvalds .write = mem_write, 9421da177e4SLinus Torvalds .open = mem_open, 943e268337dSLinus Torvalds .release = mem_release, 9441da177e4SLinus Torvalds }; 9451da177e4SLinus Torvalds 946b409e578SCong Wang static int environ_open(struct inode *inode, struct file *file) 947b409e578SCong Wang { 948b409e578SCong Wang return __mem_open(inode, file, PTRACE_MODE_READ); 949b409e578SCong Wang } 950b409e578SCong Wang 951315e28c8SJames Pearson static ssize_t environ_read(struct file *file, char __user *buf, 952315e28c8SJames Pearson size_t count, loff_t *ppos) 953315e28c8SJames Pearson { 954315e28c8SJames Pearson char *page; 955315e28c8SJames Pearson unsigned long src = *ppos; 956b409e578SCong Wang int ret = 0; 957b409e578SCong Wang struct mm_struct *mm = file->private_data; 958315e28c8SJames Pearson 959b409e578SCong Wang if (!mm) 960b409e578SCong Wang return 0; 961315e28c8SJames Pearson 962315e28c8SJames Pearson page = (char *)__get_free_page(GFP_TEMPORARY); 963315e28c8SJames Pearson if (!page) 964b409e578SCong Wang return -ENOMEM; 965315e28c8SJames Pearson 966d6f64b89SAl Viro ret = 0; 967b409e578SCong Wang if (!atomic_inc_not_zero(&mm->mm_users)) 968b409e578SCong Wang goto free; 969315e28c8SJames Pearson while (count > 0) { 970e8905ec2SDjalal Harouni size_t this_len, max_len; 971e8905ec2SDjalal Harouni int retval; 972e8905ec2SDjalal Harouni 973e8905ec2SDjalal Harouni if (src >= (mm->env_end - mm->env_start)) 974e8905ec2SDjalal Harouni break; 975315e28c8SJames Pearson 976315e28c8SJames Pearson this_len = mm->env_end - (mm->env_start + src); 977315e28c8SJames Pearson 978e8905ec2SDjalal Harouni max_len = min_t(size_t, PAGE_SIZE, count); 979e8905ec2SDjalal Harouni this_len = min(max_len, this_len); 980315e28c8SJames Pearson 981b409e578SCong Wang retval = access_remote_vm(mm, (mm->env_start + src), 982315e28c8SJames Pearson page, this_len, 0); 983315e28c8SJames Pearson 984315e28c8SJames Pearson if (retval <= 0) { 985315e28c8SJames Pearson ret = retval; 986315e28c8SJames Pearson break; 987315e28c8SJames Pearson } 988315e28c8SJames Pearson 989315e28c8SJames Pearson if (copy_to_user(buf, page, retval)) { 990315e28c8SJames Pearson ret = -EFAULT; 991315e28c8SJames Pearson break; 992315e28c8SJames Pearson } 993315e28c8SJames Pearson 994315e28c8SJames Pearson ret += retval; 995315e28c8SJames Pearson src += retval; 996315e28c8SJames Pearson buf += retval; 997315e28c8SJames Pearson count -= retval; 998315e28c8SJames Pearson } 999315e28c8SJames Pearson *ppos = src; 1000315e28c8SJames Pearson mmput(mm); 1001b409e578SCong Wang 1002b409e578SCong Wang free: 1003315e28c8SJames Pearson free_page((unsigned long) page); 1004315e28c8SJames Pearson return ret; 1005315e28c8SJames Pearson } 1006315e28c8SJames Pearson 1007315e28c8SJames Pearson static const struct file_operations proc_environ_operations = { 1008b409e578SCong Wang .open = environ_open, 1009315e28c8SJames Pearson .read = environ_read, 101087df8424SArnd Bergmann .llseek = generic_file_llseek, 1011b409e578SCong Wang .release = mem_release, 1012315e28c8SJames Pearson }; 1013315e28c8SJames Pearson 1014fa0cbbf1SDavid Rientjes static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count, 1015fa0cbbf1SDavid Rientjes loff_t *ppos) 1016fa0cbbf1SDavid Rientjes { 1017496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1018fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 1019fa0cbbf1SDavid Rientjes int oom_adj = OOM_ADJUST_MIN; 1020fa0cbbf1SDavid Rientjes size_t len; 1021fa0cbbf1SDavid Rientjes unsigned long flags; 1022fa0cbbf1SDavid Rientjes 1023fa0cbbf1SDavid Rientjes if (!task) 1024fa0cbbf1SDavid Rientjes return -ESRCH; 1025fa0cbbf1SDavid Rientjes if (lock_task_sighand(task, &flags)) { 1026fa0cbbf1SDavid Rientjes if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX) 1027fa0cbbf1SDavid Rientjes oom_adj = OOM_ADJUST_MAX; 1028fa0cbbf1SDavid Rientjes else 1029fa0cbbf1SDavid Rientjes oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) / 1030fa0cbbf1SDavid Rientjes OOM_SCORE_ADJ_MAX; 1031fa0cbbf1SDavid Rientjes unlock_task_sighand(task, &flags); 1032fa0cbbf1SDavid Rientjes } 1033fa0cbbf1SDavid Rientjes put_task_struct(task); 1034fa0cbbf1SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj); 1035fa0cbbf1SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1036fa0cbbf1SDavid Rientjes } 1037fa0cbbf1SDavid Rientjes 1038fa0cbbf1SDavid Rientjes static ssize_t oom_adj_write(struct file *file, const char __user *buf, 1039fa0cbbf1SDavid Rientjes size_t count, loff_t *ppos) 1040fa0cbbf1SDavid Rientjes { 1041fa0cbbf1SDavid Rientjes struct task_struct *task; 1042fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 1043fa0cbbf1SDavid Rientjes int oom_adj; 1044fa0cbbf1SDavid Rientjes unsigned long flags; 1045fa0cbbf1SDavid Rientjes int err; 1046fa0cbbf1SDavid Rientjes 1047fa0cbbf1SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1048fa0cbbf1SDavid Rientjes if (count > sizeof(buffer) - 1) 1049fa0cbbf1SDavid Rientjes count = sizeof(buffer) - 1; 1050fa0cbbf1SDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1051fa0cbbf1SDavid Rientjes err = -EFAULT; 1052fa0cbbf1SDavid Rientjes goto out; 1053fa0cbbf1SDavid Rientjes } 1054fa0cbbf1SDavid Rientjes 1055fa0cbbf1SDavid Rientjes err = kstrtoint(strstrip(buffer), 0, &oom_adj); 1056fa0cbbf1SDavid Rientjes if (err) 1057fa0cbbf1SDavid Rientjes goto out; 1058fa0cbbf1SDavid Rientjes if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) && 1059fa0cbbf1SDavid Rientjes oom_adj != OOM_DISABLE) { 1060fa0cbbf1SDavid Rientjes err = -EINVAL; 1061fa0cbbf1SDavid Rientjes goto out; 1062fa0cbbf1SDavid Rientjes } 1063fa0cbbf1SDavid Rientjes 1064496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1065fa0cbbf1SDavid Rientjes if (!task) { 1066fa0cbbf1SDavid Rientjes err = -ESRCH; 1067fa0cbbf1SDavid Rientjes goto out; 1068fa0cbbf1SDavid Rientjes } 1069fa0cbbf1SDavid Rientjes 1070fa0cbbf1SDavid Rientjes task_lock(task); 1071fa0cbbf1SDavid Rientjes if (!task->mm) { 1072fa0cbbf1SDavid Rientjes err = -EINVAL; 1073fa0cbbf1SDavid Rientjes goto err_task_lock; 1074fa0cbbf1SDavid Rientjes } 1075fa0cbbf1SDavid Rientjes 1076fa0cbbf1SDavid Rientjes if (!lock_task_sighand(task, &flags)) { 1077fa0cbbf1SDavid Rientjes err = -ESRCH; 1078fa0cbbf1SDavid Rientjes goto err_task_lock; 1079fa0cbbf1SDavid Rientjes } 1080fa0cbbf1SDavid Rientjes 1081fa0cbbf1SDavid Rientjes /* 1082fa0cbbf1SDavid Rientjes * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum 1083fa0cbbf1SDavid Rientjes * value is always attainable. 1084fa0cbbf1SDavid Rientjes */ 1085fa0cbbf1SDavid Rientjes if (oom_adj == OOM_ADJUST_MAX) 1086fa0cbbf1SDavid Rientjes oom_adj = OOM_SCORE_ADJ_MAX; 1087fa0cbbf1SDavid Rientjes else 1088fa0cbbf1SDavid Rientjes oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE; 1089fa0cbbf1SDavid Rientjes 1090fa0cbbf1SDavid Rientjes if (oom_adj < task->signal->oom_score_adj && 1091fa0cbbf1SDavid Rientjes !capable(CAP_SYS_RESOURCE)) { 1092fa0cbbf1SDavid Rientjes err = -EACCES; 1093fa0cbbf1SDavid Rientjes goto err_sighand; 1094fa0cbbf1SDavid Rientjes } 1095fa0cbbf1SDavid Rientjes 1096fa0cbbf1SDavid Rientjes /* 1097fa0cbbf1SDavid Rientjes * /proc/pid/oom_adj is provided for legacy purposes, ask users to use 1098fa0cbbf1SDavid Rientjes * /proc/pid/oom_score_adj instead. 1099fa0cbbf1SDavid Rientjes */ 110087ebdc00SAndrew Morton pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n", 1101fa0cbbf1SDavid Rientjes current->comm, task_pid_nr(current), task_pid_nr(task), 1102fa0cbbf1SDavid Rientjes task_pid_nr(task)); 1103fa0cbbf1SDavid Rientjes 1104fa0cbbf1SDavid Rientjes task->signal->oom_score_adj = oom_adj; 1105fa0cbbf1SDavid Rientjes trace_oom_score_adj_update(task); 1106fa0cbbf1SDavid Rientjes err_sighand: 1107fa0cbbf1SDavid Rientjes unlock_task_sighand(task, &flags); 1108fa0cbbf1SDavid Rientjes err_task_lock: 1109fa0cbbf1SDavid Rientjes task_unlock(task); 1110fa0cbbf1SDavid Rientjes put_task_struct(task); 1111fa0cbbf1SDavid Rientjes out: 1112fa0cbbf1SDavid Rientjes return err < 0 ? err : count; 1113fa0cbbf1SDavid Rientjes } 1114fa0cbbf1SDavid Rientjes 1115fa0cbbf1SDavid Rientjes static const struct file_operations proc_oom_adj_operations = { 1116fa0cbbf1SDavid Rientjes .read = oom_adj_read, 1117fa0cbbf1SDavid Rientjes .write = oom_adj_write, 1118fa0cbbf1SDavid Rientjes .llseek = generic_file_llseek, 1119fa0cbbf1SDavid Rientjes }; 1120fa0cbbf1SDavid Rientjes 1121a63d83f4SDavid Rientjes static ssize_t oom_score_adj_read(struct file *file, char __user *buf, 1122a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1123a63d83f4SDavid Rientjes { 1124496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1125a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1126a9c58b90SDavid Rientjes short oom_score_adj = OOM_SCORE_ADJ_MIN; 1127a63d83f4SDavid Rientjes unsigned long flags; 1128a63d83f4SDavid Rientjes size_t len; 1129a63d83f4SDavid Rientjes 1130a63d83f4SDavid Rientjes if (!task) 1131a63d83f4SDavid Rientjes return -ESRCH; 1132a63d83f4SDavid Rientjes if (lock_task_sighand(task, &flags)) { 1133a63d83f4SDavid Rientjes oom_score_adj = task->signal->oom_score_adj; 1134a63d83f4SDavid Rientjes unlock_task_sighand(task, &flags); 1135a63d83f4SDavid Rientjes } 1136a63d83f4SDavid Rientjes put_task_struct(task); 1137a9c58b90SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj); 1138a63d83f4SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1139a63d83f4SDavid Rientjes } 1140a63d83f4SDavid Rientjes 1141a63d83f4SDavid Rientjes static ssize_t oom_score_adj_write(struct file *file, const char __user *buf, 1142a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1143a63d83f4SDavid Rientjes { 1144a63d83f4SDavid Rientjes struct task_struct *task; 1145a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1146a63d83f4SDavid Rientjes unsigned long flags; 11470a8cb8e3SAlexey Dobriyan int oom_score_adj; 1148a63d83f4SDavid Rientjes int err; 1149a63d83f4SDavid Rientjes 1150a63d83f4SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1151a63d83f4SDavid Rientjes if (count > sizeof(buffer) - 1) 1152a63d83f4SDavid Rientjes count = sizeof(buffer) - 1; 1153723548bfSDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1154723548bfSDavid Rientjes err = -EFAULT; 1155723548bfSDavid Rientjes goto out; 1156723548bfSDavid Rientjes } 1157a63d83f4SDavid Rientjes 11580a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &oom_score_adj); 1159a63d83f4SDavid Rientjes if (err) 1160723548bfSDavid Rientjes goto out; 1161a63d83f4SDavid Rientjes if (oom_score_adj < OOM_SCORE_ADJ_MIN || 1162723548bfSDavid Rientjes oom_score_adj > OOM_SCORE_ADJ_MAX) { 1163723548bfSDavid Rientjes err = -EINVAL; 1164723548bfSDavid Rientjes goto out; 1165723548bfSDavid Rientjes } 1166a63d83f4SDavid Rientjes 1167496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1168723548bfSDavid Rientjes if (!task) { 1169723548bfSDavid Rientjes err = -ESRCH; 1170723548bfSDavid Rientjes goto out; 1171723548bfSDavid Rientjes } 1172a63d83f4SDavid Rientjes 11733d5992d2SYing Han task_lock(task); 11743d5992d2SYing Han if (!task->mm) { 1175723548bfSDavid Rientjes err = -EINVAL; 1176723548bfSDavid Rientjes goto err_task_lock; 11773d5992d2SYing Han } 1178d19d5476SDavid Rientjes 1179d19d5476SDavid Rientjes if (!lock_task_sighand(task, &flags)) { 1180d19d5476SDavid Rientjes err = -ESRCH; 1181d19d5476SDavid Rientjes goto err_task_lock; 1182d19d5476SDavid Rientjes } 1183d19d5476SDavid Rientjes 1184a9c58b90SDavid Rientjes if ((short)oom_score_adj < task->signal->oom_score_adj_min && 1185d19d5476SDavid Rientjes !capable(CAP_SYS_RESOURCE)) { 1186d19d5476SDavid Rientjes err = -EACCES; 1187d19d5476SDavid Rientjes goto err_sighand; 1188d19d5476SDavid Rientjes } 1189d19d5476SDavid Rientjes 1190a9c58b90SDavid Rientjes task->signal->oom_score_adj = (short)oom_score_adj; 1191dabb16f6SMandeep Singh Baines if (has_capability_noaudit(current, CAP_SYS_RESOURCE)) 1192a9c58b90SDavid Rientjes task->signal->oom_score_adj_min = (short)oom_score_adj; 119343d2b113SKAMEZAWA Hiroyuki trace_oom_score_adj_update(task); 119401dc52ebSDavidlohr Bueso 1195723548bfSDavid Rientjes err_sighand: 1196a63d83f4SDavid Rientjes unlock_task_sighand(task, &flags); 1197d19d5476SDavid Rientjes err_task_lock: 1198d19d5476SDavid Rientjes task_unlock(task); 1199a63d83f4SDavid Rientjes put_task_struct(task); 1200723548bfSDavid Rientjes out: 1201723548bfSDavid Rientjes return err < 0 ? err : count; 1202a63d83f4SDavid Rientjes } 1203a63d83f4SDavid Rientjes 1204a63d83f4SDavid Rientjes static const struct file_operations proc_oom_score_adj_operations = { 1205a63d83f4SDavid Rientjes .read = oom_score_adj_read, 1206a63d83f4SDavid Rientjes .write = oom_score_adj_write, 12076038f373SArnd Bergmann .llseek = default_llseek, 1208a63d83f4SDavid Rientjes }; 1209a63d83f4SDavid Rientjes 12101da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 12111da177e4SLinus Torvalds #define TMPBUFLEN 21 12121da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 12131da177e4SLinus Torvalds size_t count, loff_t *ppos) 12141da177e4SLinus Torvalds { 1215496ad9aaSAl Viro struct inode * inode = file_inode(file); 121699f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 12171da177e4SLinus Torvalds ssize_t length; 12181da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 12191da177e4SLinus Torvalds 122099f89551SEric W. Biederman if (!task) 122199f89551SEric W. Biederman return -ESRCH; 12221da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 1223e1760bd5SEric W. Biederman from_kuid(file->f_cred->user_ns, 1224e1760bd5SEric W. Biederman audit_get_loginuid(task))); 122599f89551SEric W. Biederman put_task_struct(task); 12261da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 12301da177e4SLinus Torvalds size_t count, loff_t *ppos) 12311da177e4SLinus Torvalds { 1232496ad9aaSAl Viro struct inode * inode = file_inode(file); 12331da177e4SLinus Torvalds char *page, *tmp; 12341da177e4SLinus Torvalds ssize_t length; 12351da177e4SLinus Torvalds uid_t loginuid; 1236e1760bd5SEric W. Biederman kuid_t kloginuid; 12371da177e4SLinus Torvalds 12387dc52157SPaul E. McKenney rcu_read_lock(); 12397dc52157SPaul E. McKenney if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) { 12407dc52157SPaul E. McKenney rcu_read_unlock(); 12411da177e4SLinus Torvalds return -EPERM; 12427dc52157SPaul E. McKenney } 12437dc52157SPaul E. McKenney rcu_read_unlock(); 12441da177e4SLinus Torvalds 1245e0182909SAl Viro if (count >= PAGE_SIZE) 1246e0182909SAl Viro count = PAGE_SIZE - 1; 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds if (*ppos != 0) { 12491da177e4SLinus Torvalds /* No partial writes. */ 12501da177e4SLinus Torvalds return -EINVAL; 12511da177e4SLinus Torvalds } 1252e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 12531da177e4SLinus Torvalds if (!page) 12541da177e4SLinus Torvalds return -ENOMEM; 12551da177e4SLinus Torvalds length = -EFAULT; 12561da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 12571da177e4SLinus Torvalds goto out_free_page; 12581da177e4SLinus Torvalds 1259e0182909SAl Viro page[count] = '\0'; 12601da177e4SLinus Torvalds loginuid = simple_strtoul(page, &tmp, 10); 12611da177e4SLinus Torvalds if (tmp == page) { 12621da177e4SLinus Torvalds length = -EINVAL; 12631da177e4SLinus Torvalds goto out_free_page; 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds } 126681407c84SEric Paris 126781407c84SEric Paris /* is userspace tring to explicitly UNSET the loginuid? */ 126881407c84SEric Paris if (loginuid == AUDIT_UID_UNSET) { 126981407c84SEric Paris kloginuid = INVALID_UID; 127081407c84SEric Paris } else { 1271e1760bd5SEric W. Biederman kloginuid = make_kuid(file->f_cred->user_ns, loginuid); 1272e1760bd5SEric W. Biederman if (!uid_valid(kloginuid)) { 1273e1760bd5SEric W. Biederman length = -EINVAL; 1274e1760bd5SEric W. Biederman goto out_free_page; 1275e1760bd5SEric W. Biederman } 127681407c84SEric Paris } 1277e1760bd5SEric W. Biederman 1278e1760bd5SEric W. Biederman length = audit_set_loginuid(kloginuid); 12791da177e4SLinus Torvalds if (likely(length == 0)) 12801da177e4SLinus Torvalds length = count; 12811da177e4SLinus Torvalds 12821da177e4SLinus Torvalds out_free_page: 12831da177e4SLinus Torvalds free_page((unsigned long) page); 12841da177e4SLinus Torvalds return length; 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds 128700977a59SArjan van de Ven static const struct file_operations proc_loginuid_operations = { 12881da177e4SLinus Torvalds .read = proc_loginuid_read, 12891da177e4SLinus Torvalds .write = proc_loginuid_write, 129087df8424SArnd Bergmann .llseek = generic_file_llseek, 12911da177e4SLinus Torvalds }; 12921e0bd755SEric Paris 12931e0bd755SEric Paris static ssize_t proc_sessionid_read(struct file * file, char __user * buf, 12941e0bd755SEric Paris size_t count, loff_t *ppos) 12951e0bd755SEric Paris { 1296496ad9aaSAl Viro struct inode * inode = file_inode(file); 12971e0bd755SEric Paris struct task_struct *task = get_proc_task(inode); 12981e0bd755SEric Paris ssize_t length; 12991e0bd755SEric Paris char tmpbuf[TMPBUFLEN]; 13001e0bd755SEric Paris 13011e0bd755SEric Paris if (!task) 13021e0bd755SEric Paris return -ESRCH; 13031e0bd755SEric Paris length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 13041e0bd755SEric Paris audit_get_sessionid(task)); 13051e0bd755SEric Paris put_task_struct(task); 13061e0bd755SEric Paris return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 13071e0bd755SEric Paris } 13081e0bd755SEric Paris 13091e0bd755SEric Paris static const struct file_operations proc_sessionid_operations = { 13101e0bd755SEric Paris .read = proc_sessionid_read, 131187df8424SArnd Bergmann .llseek = generic_file_llseek, 13121e0bd755SEric Paris }; 13131da177e4SLinus Torvalds #endif 13141da177e4SLinus Torvalds 1315f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1316f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_read(struct file * file, char __user * buf, 1317f4f154fdSAkinobu Mita size_t count, loff_t *ppos) 1318f4f154fdSAkinobu Mita { 1319496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1320f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF]; 1321f4f154fdSAkinobu Mita size_t len; 1322f4f154fdSAkinobu Mita int make_it_fail; 1323f4f154fdSAkinobu Mita 1324f4f154fdSAkinobu Mita if (!task) 1325f4f154fdSAkinobu Mita return -ESRCH; 1326f4f154fdSAkinobu Mita make_it_fail = task->make_it_fail; 1327f4f154fdSAkinobu Mita put_task_struct(task); 1328f4f154fdSAkinobu Mita 1329f4f154fdSAkinobu Mita len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail); 13300c28f287SAkinobu Mita 13310c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 1332f4f154fdSAkinobu Mita } 1333f4f154fdSAkinobu Mita 1334f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_write(struct file * file, 1335f4f154fdSAkinobu Mita const char __user * buf, size_t count, loff_t *ppos) 1336f4f154fdSAkinobu Mita { 1337f4f154fdSAkinobu Mita struct task_struct *task; 1338f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF], *end; 1339f4f154fdSAkinobu Mita int make_it_fail; 1340f4f154fdSAkinobu Mita 1341f4f154fdSAkinobu Mita if (!capable(CAP_SYS_RESOURCE)) 1342f4f154fdSAkinobu Mita return -EPERM; 1343f4f154fdSAkinobu Mita memset(buffer, 0, sizeof(buffer)); 1344f4f154fdSAkinobu Mita if (count > sizeof(buffer) - 1) 1345f4f154fdSAkinobu Mita count = sizeof(buffer) - 1; 1346f4f154fdSAkinobu Mita if (copy_from_user(buffer, buf, count)) 1347f4f154fdSAkinobu Mita return -EFAULT; 1348cba8aafeSVincent Li make_it_fail = simple_strtol(strstrip(buffer), &end, 0); 1349cba8aafeSVincent Li if (*end) 1350cba8aafeSVincent Li return -EINVAL; 135116caed31SDave Jones if (make_it_fail < 0 || make_it_fail > 1) 135216caed31SDave Jones return -EINVAL; 135316caed31SDave Jones 1354496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1355f4f154fdSAkinobu Mita if (!task) 1356f4f154fdSAkinobu Mita return -ESRCH; 1357f4f154fdSAkinobu Mita task->make_it_fail = make_it_fail; 1358f4f154fdSAkinobu Mita put_task_struct(task); 1359cba8aafeSVincent Li 1360cba8aafeSVincent Li return count; 1361f4f154fdSAkinobu Mita } 1362f4f154fdSAkinobu Mita 136300977a59SArjan van de Ven static const struct file_operations proc_fault_inject_operations = { 1364f4f154fdSAkinobu Mita .read = proc_fault_inject_read, 1365f4f154fdSAkinobu Mita .write = proc_fault_inject_write, 136687df8424SArnd Bergmann .llseek = generic_file_llseek, 1367f4f154fdSAkinobu Mita }; 1368f4f154fdSAkinobu Mita #endif 1369f4f154fdSAkinobu Mita 13709745512cSArjan van de Ven 137143ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 137243ae34cbSIngo Molnar /* 137343ae34cbSIngo Molnar * Print out various scheduling related per-task fields: 137443ae34cbSIngo Molnar */ 137543ae34cbSIngo Molnar static int sched_show(struct seq_file *m, void *v) 137643ae34cbSIngo Molnar { 137743ae34cbSIngo Molnar struct inode *inode = m->private; 137843ae34cbSIngo Molnar struct task_struct *p; 137943ae34cbSIngo Molnar 138043ae34cbSIngo Molnar p = get_proc_task(inode); 138143ae34cbSIngo Molnar if (!p) 138243ae34cbSIngo Molnar return -ESRCH; 138343ae34cbSIngo Molnar proc_sched_show_task(p, m); 138443ae34cbSIngo Molnar 138543ae34cbSIngo Molnar put_task_struct(p); 138643ae34cbSIngo Molnar 138743ae34cbSIngo Molnar return 0; 138843ae34cbSIngo Molnar } 138943ae34cbSIngo Molnar 139043ae34cbSIngo Molnar static ssize_t 139143ae34cbSIngo Molnar sched_write(struct file *file, const char __user *buf, 139243ae34cbSIngo Molnar size_t count, loff_t *offset) 139343ae34cbSIngo Molnar { 1394496ad9aaSAl Viro struct inode *inode = file_inode(file); 139543ae34cbSIngo Molnar struct task_struct *p; 139643ae34cbSIngo Molnar 139743ae34cbSIngo Molnar p = get_proc_task(inode); 139843ae34cbSIngo Molnar if (!p) 139943ae34cbSIngo Molnar return -ESRCH; 140043ae34cbSIngo Molnar proc_sched_set_task(p); 140143ae34cbSIngo Molnar 140243ae34cbSIngo Molnar put_task_struct(p); 140343ae34cbSIngo Molnar 140443ae34cbSIngo Molnar return count; 140543ae34cbSIngo Molnar } 140643ae34cbSIngo Molnar 140743ae34cbSIngo Molnar static int sched_open(struct inode *inode, struct file *filp) 140843ae34cbSIngo Molnar { 1409c6a34058SJovi Zhang return single_open(filp, sched_show, inode); 141043ae34cbSIngo Molnar } 141143ae34cbSIngo Molnar 141243ae34cbSIngo Molnar static const struct file_operations proc_pid_sched_operations = { 141343ae34cbSIngo Molnar .open = sched_open, 141443ae34cbSIngo Molnar .read = seq_read, 141543ae34cbSIngo Molnar .write = sched_write, 141643ae34cbSIngo Molnar .llseek = seq_lseek, 14175ea473a1SAlexey Dobriyan .release = single_release, 141843ae34cbSIngo Molnar }; 141943ae34cbSIngo Molnar 142043ae34cbSIngo Molnar #endif 142143ae34cbSIngo Molnar 14225091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 14235091faa4SMike Galbraith /* 14245091faa4SMike Galbraith * Print out autogroup related information: 14255091faa4SMike Galbraith */ 14265091faa4SMike Galbraith static int sched_autogroup_show(struct seq_file *m, void *v) 14275091faa4SMike Galbraith { 14285091faa4SMike Galbraith struct inode *inode = m->private; 14295091faa4SMike Galbraith struct task_struct *p; 14305091faa4SMike Galbraith 14315091faa4SMike Galbraith p = get_proc_task(inode); 14325091faa4SMike Galbraith if (!p) 14335091faa4SMike Galbraith return -ESRCH; 14345091faa4SMike Galbraith proc_sched_autogroup_show_task(p, m); 14355091faa4SMike Galbraith 14365091faa4SMike Galbraith put_task_struct(p); 14375091faa4SMike Galbraith 14385091faa4SMike Galbraith return 0; 14395091faa4SMike Galbraith } 14405091faa4SMike Galbraith 14415091faa4SMike Galbraith static ssize_t 14425091faa4SMike Galbraith sched_autogroup_write(struct file *file, const char __user *buf, 14435091faa4SMike Galbraith size_t count, loff_t *offset) 14445091faa4SMike Galbraith { 1445496ad9aaSAl Viro struct inode *inode = file_inode(file); 14465091faa4SMike Galbraith struct task_struct *p; 14475091faa4SMike Galbraith char buffer[PROC_NUMBUF]; 14480a8cb8e3SAlexey Dobriyan int nice; 14495091faa4SMike Galbraith int err; 14505091faa4SMike Galbraith 14515091faa4SMike Galbraith memset(buffer, 0, sizeof(buffer)); 14525091faa4SMike Galbraith if (count > sizeof(buffer) - 1) 14535091faa4SMike Galbraith count = sizeof(buffer) - 1; 14545091faa4SMike Galbraith if (copy_from_user(buffer, buf, count)) 14555091faa4SMike Galbraith return -EFAULT; 14565091faa4SMike Galbraith 14570a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &nice); 14580a8cb8e3SAlexey Dobriyan if (err < 0) 14590a8cb8e3SAlexey Dobriyan return err; 14605091faa4SMike Galbraith 14615091faa4SMike Galbraith p = get_proc_task(inode); 14625091faa4SMike Galbraith if (!p) 14635091faa4SMike Galbraith return -ESRCH; 14645091faa4SMike Galbraith 14652e5b5b3aSHiroshi Shimamoto err = proc_sched_autogroup_set_nice(p, nice); 14665091faa4SMike Galbraith if (err) 14675091faa4SMike Galbraith count = err; 14685091faa4SMike Galbraith 14695091faa4SMike Galbraith put_task_struct(p); 14705091faa4SMike Galbraith 14715091faa4SMike Galbraith return count; 14725091faa4SMike Galbraith } 14735091faa4SMike Galbraith 14745091faa4SMike Galbraith static int sched_autogroup_open(struct inode *inode, struct file *filp) 14755091faa4SMike Galbraith { 14765091faa4SMike Galbraith int ret; 14775091faa4SMike Galbraith 14785091faa4SMike Galbraith ret = single_open(filp, sched_autogroup_show, NULL); 14795091faa4SMike Galbraith if (!ret) { 14805091faa4SMike Galbraith struct seq_file *m = filp->private_data; 14815091faa4SMike Galbraith 14825091faa4SMike Galbraith m->private = inode; 14835091faa4SMike Galbraith } 14845091faa4SMike Galbraith return ret; 14855091faa4SMike Galbraith } 14865091faa4SMike Galbraith 14875091faa4SMike Galbraith static const struct file_operations proc_pid_sched_autogroup_operations = { 14885091faa4SMike Galbraith .open = sched_autogroup_open, 14895091faa4SMike Galbraith .read = seq_read, 14905091faa4SMike Galbraith .write = sched_autogroup_write, 14915091faa4SMike Galbraith .llseek = seq_lseek, 14925091faa4SMike Galbraith .release = single_release, 14935091faa4SMike Galbraith }; 14945091faa4SMike Galbraith 14955091faa4SMike Galbraith #endif /* CONFIG_SCHED_AUTOGROUP */ 14965091faa4SMike Galbraith 14974614a696Sjohn stultz static ssize_t comm_write(struct file *file, const char __user *buf, 14984614a696Sjohn stultz size_t count, loff_t *offset) 14994614a696Sjohn stultz { 1500496ad9aaSAl Viro struct inode *inode = file_inode(file); 15014614a696Sjohn stultz struct task_struct *p; 15024614a696Sjohn stultz char buffer[TASK_COMM_LEN]; 1503830e0fc9SDavid Rientjes const size_t maxlen = sizeof(buffer) - 1; 15044614a696Sjohn stultz 15054614a696Sjohn stultz memset(buffer, 0, sizeof(buffer)); 1506830e0fc9SDavid Rientjes if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count)) 15074614a696Sjohn stultz return -EFAULT; 15084614a696Sjohn stultz 15094614a696Sjohn stultz p = get_proc_task(inode); 15104614a696Sjohn stultz if (!p) 15114614a696Sjohn stultz return -ESRCH; 15124614a696Sjohn stultz 15134614a696Sjohn stultz if (same_thread_group(current, p)) 15144614a696Sjohn stultz set_task_comm(p, buffer); 15154614a696Sjohn stultz else 15164614a696Sjohn stultz count = -EINVAL; 15174614a696Sjohn stultz 15184614a696Sjohn stultz put_task_struct(p); 15194614a696Sjohn stultz 15204614a696Sjohn stultz return count; 15214614a696Sjohn stultz } 15224614a696Sjohn stultz 15234614a696Sjohn stultz static int comm_show(struct seq_file *m, void *v) 15244614a696Sjohn stultz { 15254614a696Sjohn stultz struct inode *inode = m->private; 15264614a696Sjohn stultz struct task_struct *p; 15274614a696Sjohn stultz 15284614a696Sjohn stultz p = get_proc_task(inode); 15294614a696Sjohn stultz if (!p) 15304614a696Sjohn stultz return -ESRCH; 15314614a696Sjohn stultz 15324614a696Sjohn stultz task_lock(p); 15334614a696Sjohn stultz seq_printf(m, "%s\n", p->comm); 15344614a696Sjohn stultz task_unlock(p); 15354614a696Sjohn stultz 15364614a696Sjohn stultz put_task_struct(p); 15374614a696Sjohn stultz 15384614a696Sjohn stultz return 0; 15394614a696Sjohn stultz } 15404614a696Sjohn stultz 15414614a696Sjohn stultz static int comm_open(struct inode *inode, struct file *filp) 15424614a696Sjohn stultz { 1543c6a34058SJovi Zhang return single_open(filp, comm_show, inode); 15444614a696Sjohn stultz } 15454614a696Sjohn stultz 15464614a696Sjohn stultz static const struct file_operations proc_pid_set_comm_operations = { 15474614a696Sjohn stultz .open = comm_open, 15484614a696Sjohn stultz .read = seq_read, 15494614a696Sjohn stultz .write = comm_write, 15504614a696Sjohn stultz .llseek = seq_lseek, 15514614a696Sjohn stultz .release = single_release, 15524614a696Sjohn stultz }; 15534614a696Sjohn stultz 15547773fbc5SCyrill Gorcunov static int proc_exe_link(struct dentry *dentry, struct path *exe_path) 1555925d1c40SMatt Helsley { 1556925d1c40SMatt Helsley struct task_struct *task; 1557925d1c40SMatt Helsley struct mm_struct *mm; 1558925d1c40SMatt Helsley struct file *exe_file; 1559925d1c40SMatt Helsley 15602b0143b5SDavid Howells task = get_proc_task(d_inode(dentry)); 1561925d1c40SMatt Helsley if (!task) 1562925d1c40SMatt Helsley return -ENOENT; 1563925d1c40SMatt Helsley mm = get_task_mm(task); 1564925d1c40SMatt Helsley put_task_struct(task); 1565925d1c40SMatt Helsley if (!mm) 1566925d1c40SMatt Helsley return -ENOENT; 1567925d1c40SMatt Helsley exe_file = get_mm_exe_file(mm); 1568925d1c40SMatt Helsley mmput(mm); 1569925d1c40SMatt Helsley if (exe_file) { 1570925d1c40SMatt Helsley *exe_path = exe_file->f_path; 1571925d1c40SMatt Helsley path_get(&exe_file->f_path); 1572925d1c40SMatt Helsley fput(exe_file); 1573925d1c40SMatt Helsley return 0; 1574925d1c40SMatt Helsley } else 1575925d1c40SMatt Helsley return -ENOENT; 1576925d1c40SMatt Helsley } 1577925d1c40SMatt Helsley 15786e77137bSAl Viro static const char *proc_pid_follow_link(struct dentry *dentry, void **cookie) 15791da177e4SLinus Torvalds { 15802b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 1581408ef013SChristoph Hellwig struct path path; 15821da177e4SLinus Torvalds int error = -EACCES; 15831da177e4SLinus Torvalds 1584778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1585778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 15861da177e4SLinus Torvalds goto out; 15871da177e4SLinus Torvalds 1588408ef013SChristoph Hellwig error = PROC_I(inode)->op.proc_get_link(dentry, &path); 1589408ef013SChristoph Hellwig if (error) 1590408ef013SChristoph Hellwig goto out; 1591408ef013SChristoph Hellwig 15926e77137bSAl Viro nd_jump_link(&path); 1593408ef013SChristoph Hellwig return NULL; 15941da177e4SLinus Torvalds out: 1595008b150aSAl Viro return ERR_PTR(error); 15961da177e4SLinus Torvalds } 15971da177e4SLinus Torvalds 15983dcd25f3SJan Blunck static int do_proc_readlink(struct path *path, char __user *buffer, int buflen) 15991da177e4SLinus Torvalds { 1600e12ba74dSMel Gorman char *tmp = (char*)__get_free_page(GFP_TEMPORARY); 16013dcd25f3SJan Blunck char *pathname; 16021da177e4SLinus Torvalds int len; 16031da177e4SLinus Torvalds 16041da177e4SLinus Torvalds if (!tmp) 16051da177e4SLinus Torvalds return -ENOMEM; 16061da177e4SLinus Torvalds 16077b2a69baSEric W. Biederman pathname = d_path(path, tmp, PAGE_SIZE); 16083dcd25f3SJan Blunck len = PTR_ERR(pathname); 16093dcd25f3SJan Blunck if (IS_ERR(pathname)) 16101da177e4SLinus Torvalds goto out; 16113dcd25f3SJan Blunck len = tmp + PAGE_SIZE - 1 - pathname; 16121da177e4SLinus Torvalds 16131da177e4SLinus Torvalds if (len > buflen) 16141da177e4SLinus Torvalds len = buflen; 16153dcd25f3SJan Blunck if (copy_to_user(buffer, pathname, len)) 16161da177e4SLinus Torvalds len = -EFAULT; 16171da177e4SLinus Torvalds out: 16181da177e4SLinus Torvalds free_page((unsigned long)tmp); 16191da177e4SLinus Torvalds return len; 16201da177e4SLinus Torvalds } 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 16231da177e4SLinus Torvalds { 16241da177e4SLinus Torvalds int error = -EACCES; 16252b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 16263dcd25f3SJan Blunck struct path path; 16271da177e4SLinus Torvalds 1628778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1629778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 16301da177e4SLinus Torvalds goto out; 16311da177e4SLinus Torvalds 16327773fbc5SCyrill Gorcunov error = PROC_I(inode)->op.proc_get_link(dentry, &path); 16331da177e4SLinus Torvalds if (error) 16341da177e4SLinus Torvalds goto out; 16351da177e4SLinus Torvalds 16363dcd25f3SJan Blunck error = do_proc_readlink(&path, buffer, buflen); 16373dcd25f3SJan Blunck path_put(&path); 16381da177e4SLinus Torvalds out: 16391da177e4SLinus Torvalds return error; 16401da177e4SLinus Torvalds } 16411da177e4SLinus Torvalds 1642faf60af1SCyrill Gorcunov const struct inode_operations proc_pid_link_inode_operations = { 16431da177e4SLinus Torvalds .readlink = proc_pid_readlink, 16446d76fa58SLinus Torvalds .follow_link = proc_pid_follow_link, 16456d76fa58SLinus Torvalds .setattr = proc_setattr, 16461da177e4SLinus Torvalds }; 16471da177e4SLinus Torvalds 164828a6d671SEric W. Biederman 164928a6d671SEric W. Biederman /* building an inode */ 165028a6d671SEric W. Biederman 16516b4e306aSEric W. Biederman struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task) 165228a6d671SEric W. Biederman { 165328a6d671SEric W. Biederman struct inode * inode; 165428a6d671SEric W. Biederman struct proc_inode *ei; 1655c69e8d9cSDavid Howells const struct cred *cred; 165628a6d671SEric W. Biederman 165728a6d671SEric W. Biederman /* We need a new inode */ 165828a6d671SEric W. Biederman 165928a6d671SEric W. Biederman inode = new_inode(sb); 166028a6d671SEric W. Biederman if (!inode) 166128a6d671SEric W. Biederman goto out; 166228a6d671SEric W. Biederman 166328a6d671SEric W. Biederman /* Common stuff */ 166428a6d671SEric W. Biederman ei = PROC_I(inode); 166585fe4025SChristoph Hellwig inode->i_ino = get_next_ino(); 166628a6d671SEric W. Biederman inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 166728a6d671SEric W. Biederman inode->i_op = &proc_def_inode_operations; 166828a6d671SEric W. Biederman 166928a6d671SEric W. Biederman /* 167028a6d671SEric W. Biederman * grab the reference to task. 167128a6d671SEric W. Biederman */ 16721a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 167328a6d671SEric W. Biederman if (!ei->pid) 167428a6d671SEric W. Biederman goto out_unlock; 167528a6d671SEric W. Biederman 167628a6d671SEric W. Biederman if (task_dumpable(task)) { 1677c69e8d9cSDavid Howells rcu_read_lock(); 1678c69e8d9cSDavid Howells cred = __task_cred(task); 1679c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1680c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1681c69e8d9cSDavid Howells rcu_read_unlock(); 168228a6d671SEric W. Biederman } 168328a6d671SEric W. Biederman security_task_to_inode(task, inode); 168428a6d671SEric W. Biederman 168528a6d671SEric W. Biederman out: 168628a6d671SEric W. Biederman return inode; 168728a6d671SEric W. Biederman 168828a6d671SEric W. Biederman out_unlock: 168928a6d671SEric W. Biederman iput(inode); 169028a6d671SEric W. Biederman return NULL; 169128a6d671SEric W. Biederman } 169228a6d671SEric W. Biederman 16936b4e306aSEric W. Biederman int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 169428a6d671SEric W. Biederman { 16952b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 169628a6d671SEric W. Biederman struct task_struct *task; 1697c69e8d9cSDavid Howells const struct cred *cred; 16980499680aSVasiliy Kulikov struct pid_namespace *pid = dentry->d_sb->s_fs_info; 1699c69e8d9cSDavid Howells 170028a6d671SEric W. Biederman generic_fillattr(inode, stat); 170128a6d671SEric W. Biederman 170228a6d671SEric W. Biederman rcu_read_lock(); 1703dcb0f222SEric W. Biederman stat->uid = GLOBAL_ROOT_UID; 1704dcb0f222SEric W. Biederman stat->gid = GLOBAL_ROOT_GID; 170528a6d671SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 170628a6d671SEric W. Biederman if (task) { 17070499680aSVasiliy Kulikov if (!has_pid_permissions(pid, task, 2)) { 17080499680aSVasiliy Kulikov rcu_read_unlock(); 17090499680aSVasiliy Kulikov /* 17100499680aSVasiliy Kulikov * This doesn't prevent learning whether PID exists, 17110499680aSVasiliy Kulikov * it only makes getattr() consistent with readdir(). 17120499680aSVasiliy Kulikov */ 17130499680aSVasiliy Kulikov return -ENOENT; 17140499680aSVasiliy Kulikov } 171528a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 171628a6d671SEric W. Biederman task_dumpable(task)) { 1717c69e8d9cSDavid Howells cred = __task_cred(task); 1718c69e8d9cSDavid Howells stat->uid = cred->euid; 1719c69e8d9cSDavid Howells stat->gid = cred->egid; 172028a6d671SEric W. Biederman } 172128a6d671SEric W. Biederman } 172228a6d671SEric W. Biederman rcu_read_unlock(); 172328a6d671SEric W. Biederman return 0; 172428a6d671SEric W. Biederman } 172528a6d671SEric W. Biederman 172628a6d671SEric W. Biederman /* dentry stuff */ 172728a6d671SEric W. Biederman 172828a6d671SEric W. Biederman /* 172928a6d671SEric W. Biederman * Exceptional case: normally we are not allowed to unhash a busy 173028a6d671SEric W. Biederman * directory. In this case, however, we can do it - no aliasing problems 173128a6d671SEric W. Biederman * due to the way we treat inodes. 173228a6d671SEric W. Biederman * 173328a6d671SEric W. Biederman * Rewrite the inode's ownerships here because the owning task may have 173428a6d671SEric W. Biederman * performed a setuid(), etc. 173528a6d671SEric W. Biederman * 173628a6d671SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 173728a6d671SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 173828a6d671SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 173928a6d671SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 174028a6d671SEric W. Biederman * made this apply to all per process world readable and executable 174128a6d671SEric W. Biederman * directories. 174228a6d671SEric W. Biederman */ 17430b728e19SAl Viro int pid_revalidate(struct dentry *dentry, unsigned int flags) 174428a6d671SEric W. Biederman { 174534286d66SNick Piggin struct inode *inode; 174634286d66SNick Piggin struct task_struct *task; 1747c69e8d9cSDavid Howells const struct cred *cred; 1748c69e8d9cSDavid Howells 17490b728e19SAl Viro if (flags & LOOKUP_RCU) 175034286d66SNick Piggin return -ECHILD; 175134286d66SNick Piggin 17522b0143b5SDavid Howells inode = d_inode(dentry); 175334286d66SNick Piggin task = get_proc_task(inode); 175434286d66SNick Piggin 175528a6d671SEric W. Biederman if (task) { 175628a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 175728a6d671SEric W. Biederman task_dumpable(task)) { 1758c69e8d9cSDavid Howells rcu_read_lock(); 1759c69e8d9cSDavid Howells cred = __task_cred(task); 1760c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1761c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1762c69e8d9cSDavid Howells rcu_read_unlock(); 176328a6d671SEric W. Biederman } else { 1764dcb0f222SEric W. Biederman inode->i_uid = GLOBAL_ROOT_UID; 1765dcb0f222SEric W. Biederman inode->i_gid = GLOBAL_ROOT_GID; 176628a6d671SEric W. Biederman } 176728a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 176828a6d671SEric W. Biederman security_task_to_inode(task, inode); 176928a6d671SEric W. Biederman put_task_struct(task); 177028a6d671SEric W. Biederman return 1; 177128a6d671SEric W. Biederman } 177228a6d671SEric W. Biederman return 0; 177328a6d671SEric W. Biederman } 177428a6d671SEric W. Biederman 1775d855a4b7SOleg Nesterov static inline bool proc_inode_is_dead(struct inode *inode) 1776d855a4b7SOleg Nesterov { 1777d855a4b7SOleg Nesterov return !proc_pid(inode)->tasks[PIDTYPE_PID].first; 1778d855a4b7SOleg Nesterov } 1779d855a4b7SOleg Nesterov 17801dd704b6SDavid Howells int pid_delete_dentry(const struct dentry *dentry) 17811dd704b6SDavid Howells { 17821dd704b6SDavid Howells /* Is the task we represent dead? 17831dd704b6SDavid Howells * If so, then don't put the dentry on the lru list, 17841dd704b6SDavid Howells * kill it immediately. 17851dd704b6SDavid Howells */ 17862b0143b5SDavid Howells return proc_inode_is_dead(d_inode(dentry)); 17871dd704b6SDavid Howells } 17881dd704b6SDavid Howells 17896b4e306aSEric W. Biederman const struct dentry_operations pid_dentry_operations = 179028a6d671SEric W. Biederman { 179128a6d671SEric W. Biederman .d_revalidate = pid_revalidate, 179228a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 179328a6d671SEric W. Biederman }; 179428a6d671SEric W. Biederman 179528a6d671SEric W. Biederman /* Lookups */ 179628a6d671SEric W. Biederman 17971c0d04c9SEric W. Biederman /* 17981c0d04c9SEric W. Biederman * Fill a directory entry. 17991c0d04c9SEric W. Biederman * 18001c0d04c9SEric W. Biederman * If possible create the dcache entry and derive our inode number and 18011c0d04c9SEric W. Biederman * file type from dcache entry. 18021c0d04c9SEric W. Biederman * 18031c0d04c9SEric W. Biederman * Since all of the proc inode numbers are dynamically generated, the inode 18041c0d04c9SEric W. Biederman * numbers do not exist until the inode is cache. This means creating the 18051c0d04c9SEric W. Biederman * the dcache entry in readdir is necessary to keep the inode numbers 18061c0d04c9SEric W. Biederman * reported by readdir in sync with the inode numbers reported 18071c0d04c9SEric W. Biederman * by stat. 18081c0d04c9SEric W. Biederman */ 1809f0c3b509SAl Viro bool proc_fill_cache(struct file *file, struct dir_context *ctx, 18106b4e306aSEric W. Biederman const char *name, int len, 1811c5141e6dSEric Dumazet instantiate_t instantiate, struct task_struct *task, const void *ptr) 181261a28784SEric W. Biederman { 1813f0c3b509SAl Viro struct dentry *child, *dir = file->f_path.dentry; 18141df98b8bSAl Viro struct qstr qname = QSTR_INIT(name, len); 181561a28784SEric W. Biederman struct inode *inode; 18161df98b8bSAl Viro unsigned type; 18171df98b8bSAl Viro ino_t ino; 181861a28784SEric W. Biederman 18191df98b8bSAl Viro child = d_hash_and_lookup(dir, &qname); 182061a28784SEric W. Biederman if (!child) { 18211df98b8bSAl Viro child = d_alloc(dir, &qname); 18221df98b8bSAl Viro if (!child) 182361a28784SEric W. Biederman goto end_instantiate; 18242b0143b5SDavid Howells if (instantiate(d_inode(dir), child, task, ptr) < 0) { 18251df98b8bSAl Viro dput(child); 18261df98b8bSAl Viro goto end_instantiate; 18271df98b8bSAl Viro } 18281df98b8bSAl Viro } 18292b0143b5SDavid Howells inode = d_inode(child); 183061a28784SEric W. Biederman ino = inode->i_ino; 183161a28784SEric W. Biederman type = inode->i_mode >> 12; 183261a28784SEric W. Biederman dput(child); 1833f0c3b509SAl Viro return dir_emit(ctx, name, len, ino, type); 18341df98b8bSAl Viro 18351df98b8bSAl Viro end_instantiate: 18361df98b8bSAl Viro return dir_emit(ctx, name, len, 1, DT_UNKNOWN); 183761a28784SEric W. Biederman } 183861a28784SEric W. Biederman 1839640708a2SPavel Emelyanov /* 1840640708a2SPavel Emelyanov * dname_to_vma_addr - maps a dentry name into two unsigned longs 1841640708a2SPavel Emelyanov * which represent vma start and end addresses. 1842640708a2SPavel Emelyanov */ 1843640708a2SPavel Emelyanov static int dname_to_vma_addr(struct dentry *dentry, 1844640708a2SPavel Emelyanov unsigned long *start, unsigned long *end) 1845640708a2SPavel Emelyanov { 1846640708a2SPavel Emelyanov if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2) 1847640708a2SPavel Emelyanov return -EINVAL; 1848640708a2SPavel Emelyanov 1849640708a2SPavel Emelyanov return 0; 1850640708a2SPavel Emelyanov } 1851640708a2SPavel Emelyanov 18520b728e19SAl Viro static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags) 1853640708a2SPavel Emelyanov { 1854640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1855640708a2SPavel Emelyanov bool exact_vma_exists = false; 1856640708a2SPavel Emelyanov struct mm_struct *mm = NULL; 1857640708a2SPavel Emelyanov struct task_struct *task; 1858640708a2SPavel Emelyanov const struct cred *cred; 1859640708a2SPavel Emelyanov struct inode *inode; 1860640708a2SPavel Emelyanov int status = 0; 1861640708a2SPavel Emelyanov 18620b728e19SAl Viro if (flags & LOOKUP_RCU) 1863640708a2SPavel Emelyanov return -ECHILD; 1864640708a2SPavel Emelyanov 18652b0143b5SDavid Howells inode = d_inode(dentry); 1866640708a2SPavel Emelyanov task = get_proc_task(inode); 1867640708a2SPavel Emelyanov if (!task) 1868640708a2SPavel Emelyanov goto out_notask; 1869640708a2SPavel Emelyanov 18702344bec7SCong Wang mm = mm_access(task, PTRACE_MODE_READ); 18712344bec7SCong Wang if (IS_ERR_OR_NULL(mm)) 1872640708a2SPavel Emelyanov goto out; 1873640708a2SPavel Emelyanov 1874640708a2SPavel Emelyanov if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) { 1875640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1876640708a2SPavel Emelyanov exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end); 1877640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1878640708a2SPavel Emelyanov } 1879640708a2SPavel Emelyanov 1880640708a2SPavel Emelyanov mmput(mm); 1881640708a2SPavel Emelyanov 1882640708a2SPavel Emelyanov if (exact_vma_exists) { 1883640708a2SPavel Emelyanov if (task_dumpable(task)) { 1884640708a2SPavel Emelyanov rcu_read_lock(); 1885640708a2SPavel Emelyanov cred = __task_cred(task); 1886640708a2SPavel Emelyanov inode->i_uid = cred->euid; 1887640708a2SPavel Emelyanov inode->i_gid = cred->egid; 1888640708a2SPavel Emelyanov rcu_read_unlock(); 1889640708a2SPavel Emelyanov } else { 1890dcb0f222SEric W. Biederman inode->i_uid = GLOBAL_ROOT_UID; 1891dcb0f222SEric W. Biederman inode->i_gid = GLOBAL_ROOT_GID; 1892640708a2SPavel Emelyanov } 1893640708a2SPavel Emelyanov security_task_to_inode(task, inode); 1894640708a2SPavel Emelyanov status = 1; 1895640708a2SPavel Emelyanov } 1896640708a2SPavel Emelyanov 1897640708a2SPavel Emelyanov out: 1898640708a2SPavel Emelyanov put_task_struct(task); 1899640708a2SPavel Emelyanov 1900640708a2SPavel Emelyanov out_notask: 1901640708a2SPavel Emelyanov return status; 1902640708a2SPavel Emelyanov } 1903640708a2SPavel Emelyanov 1904640708a2SPavel Emelyanov static const struct dentry_operations tid_map_files_dentry_operations = { 1905640708a2SPavel Emelyanov .d_revalidate = map_files_d_revalidate, 1906640708a2SPavel Emelyanov .d_delete = pid_delete_dentry, 1907640708a2SPavel Emelyanov }; 1908640708a2SPavel Emelyanov 1909640708a2SPavel Emelyanov static int proc_map_files_get_link(struct dentry *dentry, struct path *path) 1910640708a2SPavel Emelyanov { 1911640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1912640708a2SPavel Emelyanov struct vm_area_struct *vma; 1913640708a2SPavel Emelyanov struct task_struct *task; 1914640708a2SPavel Emelyanov struct mm_struct *mm; 1915640708a2SPavel Emelyanov int rc; 1916640708a2SPavel Emelyanov 1917640708a2SPavel Emelyanov rc = -ENOENT; 19182b0143b5SDavid Howells task = get_proc_task(d_inode(dentry)); 1919640708a2SPavel Emelyanov if (!task) 1920640708a2SPavel Emelyanov goto out; 1921640708a2SPavel Emelyanov 1922640708a2SPavel Emelyanov mm = get_task_mm(task); 1923640708a2SPavel Emelyanov put_task_struct(task); 1924640708a2SPavel Emelyanov if (!mm) 1925640708a2SPavel Emelyanov goto out; 1926640708a2SPavel Emelyanov 1927640708a2SPavel Emelyanov rc = dname_to_vma_addr(dentry, &vm_start, &vm_end); 1928640708a2SPavel Emelyanov if (rc) 1929640708a2SPavel Emelyanov goto out_mmput; 1930640708a2SPavel Emelyanov 193170335abbSArtem Fetishev rc = -ENOENT; 1932640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1933640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 1934640708a2SPavel Emelyanov if (vma && vma->vm_file) { 1935640708a2SPavel Emelyanov *path = vma->vm_file->f_path; 1936640708a2SPavel Emelyanov path_get(path); 1937640708a2SPavel Emelyanov rc = 0; 1938640708a2SPavel Emelyanov } 1939640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1940640708a2SPavel Emelyanov 1941640708a2SPavel Emelyanov out_mmput: 1942640708a2SPavel Emelyanov mmput(mm); 1943640708a2SPavel Emelyanov out: 1944640708a2SPavel Emelyanov return rc; 1945640708a2SPavel Emelyanov } 1946640708a2SPavel Emelyanov 1947640708a2SPavel Emelyanov struct map_files_info { 19487b540d06SAl Viro fmode_t mode; 1949640708a2SPavel Emelyanov unsigned long len; 1950640708a2SPavel Emelyanov unsigned char name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */ 1951640708a2SPavel Emelyanov }; 1952640708a2SPavel Emelyanov 1953*bdb4d100SCalvin Owens /* 1954*bdb4d100SCalvin Owens * Only allow CAP_SYS_ADMIN to follow the links, due to concerns about how the 1955*bdb4d100SCalvin Owens * symlinks may be used to bypass permissions on ancestor directories in the 1956*bdb4d100SCalvin Owens * path to the file in question. 1957*bdb4d100SCalvin Owens */ 1958*bdb4d100SCalvin Owens static const char * 1959*bdb4d100SCalvin Owens proc_map_files_follow_link(struct dentry *dentry, void **cookie) 1960*bdb4d100SCalvin Owens { 1961*bdb4d100SCalvin Owens if (!capable(CAP_SYS_ADMIN)) 1962*bdb4d100SCalvin Owens return ERR_PTR(-EPERM); 1963*bdb4d100SCalvin Owens 1964*bdb4d100SCalvin Owens return proc_pid_follow_link(dentry, NULL); 1965*bdb4d100SCalvin Owens } 1966*bdb4d100SCalvin Owens 1967*bdb4d100SCalvin Owens /* 1968*bdb4d100SCalvin Owens * Identical to proc_pid_link_inode_operations except for follow_link() 1969*bdb4d100SCalvin Owens */ 1970*bdb4d100SCalvin Owens static const struct inode_operations proc_map_files_link_inode_operations = { 1971*bdb4d100SCalvin Owens .readlink = proc_pid_readlink, 1972*bdb4d100SCalvin Owens .follow_link = proc_map_files_follow_link, 1973*bdb4d100SCalvin Owens .setattr = proc_setattr, 1974*bdb4d100SCalvin Owens }; 1975*bdb4d100SCalvin Owens 1976c52a47acSAl Viro static int 1977640708a2SPavel Emelyanov proc_map_files_instantiate(struct inode *dir, struct dentry *dentry, 1978640708a2SPavel Emelyanov struct task_struct *task, const void *ptr) 1979640708a2SPavel Emelyanov { 19807b540d06SAl Viro fmode_t mode = (fmode_t)(unsigned long)ptr; 1981640708a2SPavel Emelyanov struct proc_inode *ei; 1982640708a2SPavel Emelyanov struct inode *inode; 1983640708a2SPavel Emelyanov 1984640708a2SPavel Emelyanov inode = proc_pid_make_inode(dir->i_sb, task); 1985640708a2SPavel Emelyanov if (!inode) 1986c52a47acSAl Viro return -ENOENT; 1987640708a2SPavel Emelyanov 1988640708a2SPavel Emelyanov ei = PROC_I(inode); 1989640708a2SPavel Emelyanov ei->op.proc_get_link = proc_map_files_get_link; 1990640708a2SPavel Emelyanov 1991*bdb4d100SCalvin Owens inode->i_op = &proc_map_files_link_inode_operations; 1992640708a2SPavel Emelyanov inode->i_size = 64; 1993640708a2SPavel Emelyanov inode->i_mode = S_IFLNK; 1994640708a2SPavel Emelyanov 19957b540d06SAl Viro if (mode & FMODE_READ) 1996640708a2SPavel Emelyanov inode->i_mode |= S_IRUSR; 19977b540d06SAl Viro if (mode & FMODE_WRITE) 1998640708a2SPavel Emelyanov inode->i_mode |= S_IWUSR; 1999640708a2SPavel Emelyanov 2000640708a2SPavel Emelyanov d_set_d_op(dentry, &tid_map_files_dentry_operations); 2001640708a2SPavel Emelyanov d_add(dentry, inode); 2002640708a2SPavel Emelyanov 2003c52a47acSAl Viro return 0; 2004640708a2SPavel Emelyanov } 2005640708a2SPavel Emelyanov 2006640708a2SPavel Emelyanov static struct dentry *proc_map_files_lookup(struct inode *dir, 200700cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 2008640708a2SPavel Emelyanov { 2009640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 2010640708a2SPavel Emelyanov struct vm_area_struct *vma; 2011640708a2SPavel Emelyanov struct task_struct *task; 2012c52a47acSAl Viro int result; 2013640708a2SPavel Emelyanov struct mm_struct *mm; 2014640708a2SPavel Emelyanov 2015c52a47acSAl Viro result = -ENOENT; 2016640708a2SPavel Emelyanov task = get_proc_task(dir); 2017640708a2SPavel Emelyanov if (!task) 2018640708a2SPavel Emelyanov goto out; 2019640708a2SPavel Emelyanov 2020c52a47acSAl Viro result = -EACCES; 2021eb94cd96SCyrill Gorcunov if (!ptrace_may_access(task, PTRACE_MODE_READ)) 2022640708a2SPavel Emelyanov goto out_put_task; 2023640708a2SPavel Emelyanov 2024c52a47acSAl Viro result = -ENOENT; 2025640708a2SPavel Emelyanov if (dname_to_vma_addr(dentry, &vm_start, &vm_end)) 2026eb94cd96SCyrill Gorcunov goto out_put_task; 2027640708a2SPavel Emelyanov 2028640708a2SPavel Emelyanov mm = get_task_mm(task); 2029640708a2SPavel Emelyanov if (!mm) 2030eb94cd96SCyrill Gorcunov goto out_put_task; 2031640708a2SPavel Emelyanov 2032640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 2033640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 2034640708a2SPavel Emelyanov if (!vma) 2035640708a2SPavel Emelyanov goto out_no_vma; 2036640708a2SPavel Emelyanov 203705f56484SStanislav Kinsbursky if (vma->vm_file) 20387b540d06SAl Viro result = proc_map_files_instantiate(dir, dentry, task, 20397b540d06SAl Viro (void *)(unsigned long)vma->vm_file->f_mode); 2040640708a2SPavel Emelyanov 2041640708a2SPavel Emelyanov out_no_vma: 2042640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2043640708a2SPavel Emelyanov mmput(mm); 2044640708a2SPavel Emelyanov out_put_task: 2045640708a2SPavel Emelyanov put_task_struct(task); 2046640708a2SPavel Emelyanov out: 2047c52a47acSAl Viro return ERR_PTR(result); 2048640708a2SPavel Emelyanov } 2049640708a2SPavel Emelyanov 2050640708a2SPavel Emelyanov static const struct inode_operations proc_map_files_inode_operations = { 2051640708a2SPavel Emelyanov .lookup = proc_map_files_lookup, 2052640708a2SPavel Emelyanov .permission = proc_fd_permission, 2053640708a2SPavel Emelyanov .setattr = proc_setattr, 2054640708a2SPavel Emelyanov }; 2055640708a2SPavel Emelyanov 2056640708a2SPavel Emelyanov static int 2057f0c3b509SAl Viro proc_map_files_readdir(struct file *file, struct dir_context *ctx) 2058640708a2SPavel Emelyanov { 2059640708a2SPavel Emelyanov struct vm_area_struct *vma; 2060640708a2SPavel Emelyanov struct task_struct *task; 2061640708a2SPavel Emelyanov struct mm_struct *mm; 2062f0c3b509SAl Viro unsigned long nr_files, pos, i; 2063f0c3b509SAl Viro struct flex_array *fa = NULL; 2064f0c3b509SAl Viro struct map_files_info info; 2065f0c3b509SAl Viro struct map_files_info *p; 2066640708a2SPavel Emelyanov int ret; 2067640708a2SPavel Emelyanov 2068640708a2SPavel Emelyanov ret = -ENOENT; 2069f0c3b509SAl Viro task = get_proc_task(file_inode(file)); 2070640708a2SPavel Emelyanov if (!task) 2071640708a2SPavel Emelyanov goto out; 2072640708a2SPavel Emelyanov 2073640708a2SPavel Emelyanov ret = -EACCES; 2074eb94cd96SCyrill Gorcunov if (!ptrace_may_access(task, PTRACE_MODE_READ)) 2075640708a2SPavel Emelyanov goto out_put_task; 2076640708a2SPavel Emelyanov 2077640708a2SPavel Emelyanov ret = 0; 2078f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 2079eb94cd96SCyrill Gorcunov goto out_put_task; 2080640708a2SPavel Emelyanov 2081640708a2SPavel Emelyanov mm = get_task_mm(task); 2082640708a2SPavel Emelyanov if (!mm) 2083eb94cd96SCyrill Gorcunov goto out_put_task; 2084640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 2085640708a2SPavel Emelyanov 2086640708a2SPavel Emelyanov nr_files = 0; 2087640708a2SPavel Emelyanov 2088640708a2SPavel Emelyanov /* 2089640708a2SPavel Emelyanov * We need two passes here: 2090640708a2SPavel Emelyanov * 2091640708a2SPavel Emelyanov * 1) Collect vmas of mapped files with mmap_sem taken 2092640708a2SPavel Emelyanov * 2) Release mmap_sem and instantiate entries 2093640708a2SPavel Emelyanov * 2094640708a2SPavel Emelyanov * otherwise we get lockdep complained, since filldir() 2095640708a2SPavel Emelyanov * routine might require mmap_sem taken in might_fault(). 2096640708a2SPavel Emelyanov */ 2097640708a2SPavel Emelyanov 2098640708a2SPavel Emelyanov for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) { 2099f0c3b509SAl Viro if (vma->vm_file && ++pos > ctx->pos) 2100640708a2SPavel Emelyanov nr_files++; 2101640708a2SPavel Emelyanov } 2102640708a2SPavel Emelyanov 2103640708a2SPavel Emelyanov if (nr_files) { 2104640708a2SPavel Emelyanov fa = flex_array_alloc(sizeof(info), nr_files, 2105640708a2SPavel Emelyanov GFP_KERNEL); 2106640708a2SPavel Emelyanov if (!fa || flex_array_prealloc(fa, 0, nr_files, 2107640708a2SPavel Emelyanov GFP_KERNEL)) { 2108640708a2SPavel Emelyanov ret = -ENOMEM; 2109640708a2SPavel Emelyanov if (fa) 2110640708a2SPavel Emelyanov flex_array_free(fa); 2111640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2112640708a2SPavel Emelyanov mmput(mm); 2113eb94cd96SCyrill Gorcunov goto out_put_task; 2114640708a2SPavel Emelyanov } 2115640708a2SPavel Emelyanov for (i = 0, vma = mm->mmap, pos = 2; vma; 2116640708a2SPavel Emelyanov vma = vma->vm_next) { 2117640708a2SPavel Emelyanov if (!vma->vm_file) 2118640708a2SPavel Emelyanov continue; 2119f0c3b509SAl Viro if (++pos <= ctx->pos) 2120640708a2SPavel Emelyanov continue; 2121640708a2SPavel Emelyanov 21227b540d06SAl Viro info.mode = vma->vm_file->f_mode; 2123640708a2SPavel Emelyanov info.len = snprintf(info.name, 2124640708a2SPavel Emelyanov sizeof(info.name), "%lx-%lx", 2125640708a2SPavel Emelyanov vma->vm_start, vma->vm_end); 2126640708a2SPavel Emelyanov if (flex_array_put(fa, i++, &info, GFP_KERNEL)) 2127640708a2SPavel Emelyanov BUG(); 2128640708a2SPavel Emelyanov } 2129640708a2SPavel Emelyanov } 2130640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 2131640708a2SPavel Emelyanov 2132640708a2SPavel Emelyanov for (i = 0; i < nr_files; i++) { 2133640708a2SPavel Emelyanov p = flex_array_get(fa, i); 2134f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, 2135640708a2SPavel Emelyanov p->name, p->len, 2136640708a2SPavel Emelyanov proc_map_files_instantiate, 21377b540d06SAl Viro task, 2138f0c3b509SAl Viro (void *)(unsigned long)p->mode)) 2139640708a2SPavel Emelyanov break; 2140f0c3b509SAl Viro ctx->pos++; 2141640708a2SPavel Emelyanov } 2142640708a2SPavel Emelyanov if (fa) 2143640708a2SPavel Emelyanov flex_array_free(fa); 2144640708a2SPavel Emelyanov mmput(mm); 2145640708a2SPavel Emelyanov 2146640708a2SPavel Emelyanov out_put_task: 2147640708a2SPavel Emelyanov put_task_struct(task); 2148640708a2SPavel Emelyanov out: 2149640708a2SPavel Emelyanov return ret; 2150640708a2SPavel Emelyanov } 2151640708a2SPavel Emelyanov 2152640708a2SPavel Emelyanov static const struct file_operations proc_map_files_operations = { 2153640708a2SPavel Emelyanov .read = generic_read_dir, 2154f0c3b509SAl Viro .iterate = proc_map_files_readdir, 2155640708a2SPavel Emelyanov .llseek = default_llseek, 2156640708a2SPavel Emelyanov }; 2157640708a2SPavel Emelyanov 215848f6a7a5SPavel Emelyanov struct timers_private { 215948f6a7a5SPavel Emelyanov struct pid *pid; 216048f6a7a5SPavel Emelyanov struct task_struct *task; 216148f6a7a5SPavel Emelyanov struct sighand_struct *sighand; 216257b8015eSPavel Emelyanov struct pid_namespace *ns; 216348f6a7a5SPavel Emelyanov unsigned long flags; 216448f6a7a5SPavel Emelyanov }; 216548f6a7a5SPavel Emelyanov 216648f6a7a5SPavel Emelyanov static void *timers_start(struct seq_file *m, loff_t *pos) 216748f6a7a5SPavel Emelyanov { 216848f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 216948f6a7a5SPavel Emelyanov 217048f6a7a5SPavel Emelyanov tp->task = get_pid_task(tp->pid, PIDTYPE_PID); 217148f6a7a5SPavel Emelyanov if (!tp->task) 217248f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 217348f6a7a5SPavel Emelyanov 217448f6a7a5SPavel Emelyanov tp->sighand = lock_task_sighand(tp->task, &tp->flags); 217548f6a7a5SPavel Emelyanov if (!tp->sighand) 217648f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 217748f6a7a5SPavel Emelyanov 217848f6a7a5SPavel Emelyanov return seq_list_start(&tp->task->signal->posix_timers, *pos); 217948f6a7a5SPavel Emelyanov } 218048f6a7a5SPavel Emelyanov 218148f6a7a5SPavel Emelyanov static void *timers_next(struct seq_file *m, void *v, loff_t *pos) 218248f6a7a5SPavel Emelyanov { 218348f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 218448f6a7a5SPavel Emelyanov return seq_list_next(v, &tp->task->signal->posix_timers, pos); 218548f6a7a5SPavel Emelyanov } 218648f6a7a5SPavel Emelyanov 218748f6a7a5SPavel Emelyanov static void timers_stop(struct seq_file *m, void *v) 218848f6a7a5SPavel Emelyanov { 218948f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 219048f6a7a5SPavel Emelyanov 219148f6a7a5SPavel Emelyanov if (tp->sighand) { 219248f6a7a5SPavel Emelyanov unlock_task_sighand(tp->task, &tp->flags); 219348f6a7a5SPavel Emelyanov tp->sighand = NULL; 219448f6a7a5SPavel Emelyanov } 219548f6a7a5SPavel Emelyanov 219648f6a7a5SPavel Emelyanov if (tp->task) { 219748f6a7a5SPavel Emelyanov put_task_struct(tp->task); 219848f6a7a5SPavel Emelyanov tp->task = NULL; 219948f6a7a5SPavel Emelyanov } 220048f6a7a5SPavel Emelyanov } 220148f6a7a5SPavel Emelyanov 220248f6a7a5SPavel Emelyanov static int show_timer(struct seq_file *m, void *v) 220348f6a7a5SPavel Emelyanov { 220448f6a7a5SPavel Emelyanov struct k_itimer *timer; 220557b8015eSPavel Emelyanov struct timers_private *tp = m->private; 220657b8015eSPavel Emelyanov int notify; 2207cedbccabSAlexey Dobriyan static const char * const nstr[] = { 220857b8015eSPavel Emelyanov [SIGEV_SIGNAL] = "signal", 220957b8015eSPavel Emelyanov [SIGEV_NONE] = "none", 221057b8015eSPavel Emelyanov [SIGEV_THREAD] = "thread", 221157b8015eSPavel Emelyanov }; 221248f6a7a5SPavel Emelyanov 221348f6a7a5SPavel Emelyanov timer = list_entry((struct list_head *)v, struct k_itimer, list); 221457b8015eSPavel Emelyanov notify = timer->it_sigev_notify; 221557b8015eSPavel Emelyanov 221648f6a7a5SPavel Emelyanov seq_printf(m, "ID: %d\n", timer->it_id); 221725ce3191SJoe Perches seq_printf(m, "signal: %d/%p\n", 221825ce3191SJoe Perches timer->sigq->info.si_signo, 221957b8015eSPavel Emelyanov timer->sigq->info.si_value.sival_ptr); 222057b8015eSPavel Emelyanov seq_printf(m, "notify: %s/%s.%d\n", 222157b8015eSPavel Emelyanov nstr[notify & ~SIGEV_THREAD_ID], 222257b8015eSPavel Emelyanov (notify & SIGEV_THREAD_ID) ? "tid" : "pid", 222357b8015eSPavel Emelyanov pid_nr_ns(timer->it_pid, tp->ns)); 222415ef0298SPavel Tikhomirov seq_printf(m, "ClockID: %d\n", timer->it_clock); 222548f6a7a5SPavel Emelyanov 222648f6a7a5SPavel Emelyanov return 0; 222748f6a7a5SPavel Emelyanov } 222848f6a7a5SPavel Emelyanov 222948f6a7a5SPavel Emelyanov static const struct seq_operations proc_timers_seq_ops = { 223048f6a7a5SPavel Emelyanov .start = timers_start, 223148f6a7a5SPavel Emelyanov .next = timers_next, 223248f6a7a5SPavel Emelyanov .stop = timers_stop, 223348f6a7a5SPavel Emelyanov .show = show_timer, 223448f6a7a5SPavel Emelyanov }; 223548f6a7a5SPavel Emelyanov 223648f6a7a5SPavel Emelyanov static int proc_timers_open(struct inode *inode, struct file *file) 223748f6a7a5SPavel Emelyanov { 223848f6a7a5SPavel Emelyanov struct timers_private *tp; 223948f6a7a5SPavel Emelyanov 224048f6a7a5SPavel Emelyanov tp = __seq_open_private(file, &proc_timers_seq_ops, 224148f6a7a5SPavel Emelyanov sizeof(struct timers_private)); 224248f6a7a5SPavel Emelyanov if (!tp) 224348f6a7a5SPavel Emelyanov return -ENOMEM; 224448f6a7a5SPavel Emelyanov 224548f6a7a5SPavel Emelyanov tp->pid = proc_pid(inode); 224657b8015eSPavel Emelyanov tp->ns = inode->i_sb->s_fs_info; 224748f6a7a5SPavel Emelyanov return 0; 224848f6a7a5SPavel Emelyanov } 224948f6a7a5SPavel Emelyanov 225048f6a7a5SPavel Emelyanov static const struct file_operations proc_timers_operations = { 225148f6a7a5SPavel Emelyanov .open = proc_timers_open, 225248f6a7a5SPavel Emelyanov .read = seq_read, 225348f6a7a5SPavel Emelyanov .llseek = seq_lseek, 225448f6a7a5SPavel Emelyanov .release = seq_release_private, 225548f6a7a5SPavel Emelyanov }; 2256640708a2SPavel Emelyanov 2257c52a47acSAl Viro static int proc_pident_instantiate(struct inode *dir, 2258c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2259444ceed8SEric W. Biederman { 2260c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2261444ceed8SEric W. Biederman struct inode *inode; 2262444ceed8SEric W. Biederman struct proc_inode *ei; 2263444ceed8SEric W. Biederman 226461a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2265444ceed8SEric W. Biederman if (!inode) 2266444ceed8SEric W. Biederman goto out; 2267444ceed8SEric W. Biederman 2268444ceed8SEric W. Biederman ei = PROC_I(inode); 2269444ceed8SEric W. Biederman inode->i_mode = p->mode; 2270444ceed8SEric W. Biederman if (S_ISDIR(inode->i_mode)) 2271bfe86848SMiklos Szeredi set_nlink(inode, 2); /* Use getattr to fix if necessary */ 2272444ceed8SEric W. Biederman if (p->iop) 2273444ceed8SEric W. Biederman inode->i_op = p->iop; 2274444ceed8SEric W. Biederman if (p->fop) 2275444ceed8SEric W. Biederman inode->i_fop = p->fop; 2276444ceed8SEric W. Biederman ei->op = p->op; 2277fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2278444ceed8SEric W. Biederman d_add(dentry, inode); 2279444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 22800b728e19SAl Viro if (pid_revalidate(dentry, 0)) 2281c52a47acSAl Viro return 0; 2282444ceed8SEric W. Biederman out: 2283c52a47acSAl Viro return -ENOENT; 2284444ceed8SEric W. Biederman } 2285444ceed8SEric W. Biederman 22861da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 22871da177e4SLinus Torvalds struct dentry *dentry, 2288c5141e6dSEric Dumazet const struct pid_entry *ents, 22897bcd6b0eSEric W. Biederman unsigned int nents) 22901da177e4SLinus Torvalds { 2291c52a47acSAl Viro int error; 229299f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2293c5141e6dSEric Dumazet const struct pid_entry *p, *last; 22941da177e4SLinus Torvalds 2295c52a47acSAl Viro error = -ENOENT; 22961da177e4SLinus Torvalds 229799f89551SEric W. Biederman if (!task) 229899f89551SEric W. Biederman goto out_no_task; 22991da177e4SLinus Torvalds 230020cdc894SEric W. Biederman /* 230120cdc894SEric W. Biederman * Yes, it does not scale. And it should not. Don't add 230220cdc894SEric W. Biederman * new entries into /proc/<tgid>/ without very good reasons. 230320cdc894SEric W. Biederman */ 23047bcd6b0eSEric W. Biederman last = &ents[nents - 1]; 23057bcd6b0eSEric W. Biederman for (p = ents; p <= last; p++) { 23061da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 23071da177e4SLinus Torvalds continue; 23081da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 23091da177e4SLinus Torvalds break; 23101da177e4SLinus Torvalds } 23117bcd6b0eSEric W. Biederman if (p > last) 23121da177e4SLinus Torvalds goto out; 23131da177e4SLinus Torvalds 2314444ceed8SEric W. Biederman error = proc_pident_instantiate(dir, dentry, task, p); 23151da177e4SLinus Torvalds out: 231699f89551SEric W. Biederman put_task_struct(task); 231799f89551SEric W. Biederman out_no_task: 2318c52a47acSAl Viro return ERR_PTR(error); 23191da177e4SLinus Torvalds } 23201da177e4SLinus Torvalds 2321f0c3b509SAl Viro static int proc_pident_readdir(struct file *file, struct dir_context *ctx, 2322c5141e6dSEric Dumazet const struct pid_entry *ents, unsigned int nents) 232328a6d671SEric W. Biederman { 2324f0c3b509SAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 2325f0c3b509SAl Viro const struct pid_entry *p; 232628a6d671SEric W. Biederman 232728a6d671SEric W. Biederman if (!task) 2328f0c3b509SAl Viro return -ENOENT; 232928a6d671SEric W. Biederman 2330f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 233128a6d671SEric W. Biederman goto out; 23321da177e4SLinus Torvalds 2333f0c3b509SAl Viro if (ctx->pos >= nents + 2) 2334f0c3b509SAl Viro goto out; 2335f0c3b509SAl Viro 2336f0c3b509SAl Viro for (p = ents + (ctx->pos - 2); p <= ents + nents - 1; p++) { 2337f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, p->name, p->len, 2338f0c3b509SAl Viro proc_pident_instantiate, task, p)) 2339f0c3b509SAl Viro break; 2340f0c3b509SAl Viro ctx->pos++; 2341f0c3b509SAl Viro } 234228a6d671SEric W. Biederman out: 234361a28784SEric W. Biederman put_task_struct(task); 2344f0c3b509SAl Viro return 0; 23451da177e4SLinus Torvalds } 23461da177e4SLinus Torvalds 23471da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 234828a6d671SEric W. Biederman static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 234928a6d671SEric W. Biederman size_t count, loff_t *ppos) 235028a6d671SEric W. Biederman { 2351496ad9aaSAl Viro struct inode * inode = file_inode(file); 235204ff9708SAl Viro char *p = NULL; 235328a6d671SEric W. Biederman ssize_t length; 235428a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 235528a6d671SEric W. Biederman 235628a6d671SEric W. Biederman if (!task) 235704ff9708SAl Viro return -ESRCH; 235828a6d671SEric W. Biederman 235928a6d671SEric W. Biederman length = security_getprocattr(task, 23602fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 236104ff9708SAl Viro &p); 236228a6d671SEric W. Biederman put_task_struct(task); 236304ff9708SAl Viro if (length > 0) 236404ff9708SAl Viro length = simple_read_from_buffer(buf, count, ppos, p, length); 236504ff9708SAl Viro kfree(p); 236628a6d671SEric W. Biederman return length; 236728a6d671SEric W. Biederman } 236828a6d671SEric W. Biederman 236928a6d671SEric W. Biederman static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 237028a6d671SEric W. Biederman size_t count, loff_t *ppos) 237128a6d671SEric W. Biederman { 2372496ad9aaSAl Viro struct inode * inode = file_inode(file); 237328a6d671SEric W. Biederman char *page; 237428a6d671SEric W. Biederman ssize_t length; 237528a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 237628a6d671SEric W. Biederman 237728a6d671SEric W. Biederman length = -ESRCH; 237828a6d671SEric W. Biederman if (!task) 237928a6d671SEric W. Biederman goto out_no_task; 238028a6d671SEric W. Biederman if (count > PAGE_SIZE) 238128a6d671SEric W. Biederman count = PAGE_SIZE; 238228a6d671SEric W. Biederman 238328a6d671SEric W. Biederman /* No partial writes. */ 238428a6d671SEric W. Biederman length = -EINVAL; 238528a6d671SEric W. Biederman if (*ppos != 0) 238628a6d671SEric W. Biederman goto out; 238728a6d671SEric W. Biederman 238828a6d671SEric W. Biederman length = -ENOMEM; 2389e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 239028a6d671SEric W. Biederman if (!page) 239128a6d671SEric W. Biederman goto out; 239228a6d671SEric W. Biederman 239328a6d671SEric W. Biederman length = -EFAULT; 239428a6d671SEric W. Biederman if (copy_from_user(page, buf, count)) 239528a6d671SEric W. Biederman goto out_free; 239628a6d671SEric W. Biederman 2397107db7c7SDavid Howells /* Guard against adverse ptrace interaction */ 23989b1bf12dSKOSAKI Motohiro length = mutex_lock_interruptible(&task->signal->cred_guard_mutex); 2399107db7c7SDavid Howells if (length < 0) 2400107db7c7SDavid Howells goto out_free; 2401107db7c7SDavid Howells 240228a6d671SEric W. Biederman length = security_setprocattr(task, 24032fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 240428a6d671SEric W. Biederman (void*)page, count); 24059b1bf12dSKOSAKI Motohiro mutex_unlock(&task->signal->cred_guard_mutex); 240628a6d671SEric W. Biederman out_free: 240728a6d671SEric W. Biederman free_page((unsigned long) page); 240828a6d671SEric W. Biederman out: 240928a6d671SEric W. Biederman put_task_struct(task); 241028a6d671SEric W. Biederman out_no_task: 241128a6d671SEric W. Biederman return length; 241228a6d671SEric W. Biederman } 241328a6d671SEric W. Biederman 241400977a59SArjan van de Ven static const struct file_operations proc_pid_attr_operations = { 241528a6d671SEric W. Biederman .read = proc_pid_attr_read, 241628a6d671SEric W. Biederman .write = proc_pid_attr_write, 241787df8424SArnd Bergmann .llseek = generic_file_llseek, 241828a6d671SEric W. Biederman }; 241928a6d671SEric W. Biederman 2420c5141e6dSEric Dumazet static const struct pid_entry attr_dir_stuff[] = { 2421631f9c18SAlexey Dobriyan REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2422631f9c18SAlexey Dobriyan REG("prev", S_IRUGO, proc_pid_attr_operations), 2423631f9c18SAlexey Dobriyan REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2424631f9c18SAlexey Dobriyan REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2425631f9c18SAlexey Dobriyan REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2426631f9c18SAlexey Dobriyan REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 242728a6d671SEric W. Biederman }; 242828a6d671SEric W. Biederman 2429f0c3b509SAl Viro static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx) 24301da177e4SLinus Torvalds { 2431f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 243272d9dcfcSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 24331da177e4SLinus Torvalds } 24341da177e4SLinus Torvalds 243500977a59SArjan van de Ven static const struct file_operations proc_attr_dir_operations = { 24361da177e4SLinus Torvalds .read = generic_read_dir, 2437f0c3b509SAl Viro .iterate = proc_attr_dir_readdir, 24386038f373SArnd Bergmann .llseek = default_llseek, 24391da177e4SLinus Torvalds }; 24401da177e4SLinus Torvalds 244172d9dcfcSEric W. Biederman static struct dentry *proc_attr_dir_lookup(struct inode *dir, 244200cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 24431da177e4SLinus Torvalds { 24447bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 24457bcd6b0eSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 24461da177e4SLinus Torvalds } 24471da177e4SLinus Torvalds 2448c5ef1c42SArjan van de Ven static const struct inode_operations proc_attr_dir_inode_operations = { 244972d9dcfcSEric W. Biederman .lookup = proc_attr_dir_lookup, 245099f89551SEric W. Biederman .getattr = pid_getattr, 24516d76fa58SLinus Torvalds .setattr = proc_setattr, 24521da177e4SLinus Torvalds }; 24531da177e4SLinus Torvalds 24541da177e4SLinus Torvalds #endif 24551da177e4SLinus Torvalds 2456698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 24573cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, 24583cb4a0bbSKawai, Hidehiro size_t count, loff_t *ppos) 24593cb4a0bbSKawai, Hidehiro { 2460496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 24613cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 24623cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF]; 24633cb4a0bbSKawai, Hidehiro size_t len; 24643cb4a0bbSKawai, Hidehiro int ret; 24653cb4a0bbSKawai, Hidehiro 24663cb4a0bbSKawai, Hidehiro if (!task) 24673cb4a0bbSKawai, Hidehiro return -ESRCH; 24683cb4a0bbSKawai, Hidehiro 24693cb4a0bbSKawai, Hidehiro ret = 0; 24703cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 24713cb4a0bbSKawai, Hidehiro if (mm) { 24723cb4a0bbSKawai, Hidehiro len = snprintf(buffer, sizeof(buffer), "%08lx\n", 24733cb4a0bbSKawai, Hidehiro ((mm->flags & MMF_DUMP_FILTER_MASK) >> 24743cb4a0bbSKawai, Hidehiro MMF_DUMP_FILTER_SHIFT)); 24753cb4a0bbSKawai, Hidehiro mmput(mm); 24763cb4a0bbSKawai, Hidehiro ret = simple_read_from_buffer(buf, count, ppos, buffer, len); 24773cb4a0bbSKawai, Hidehiro } 24783cb4a0bbSKawai, Hidehiro 24793cb4a0bbSKawai, Hidehiro put_task_struct(task); 24803cb4a0bbSKawai, Hidehiro 24813cb4a0bbSKawai, Hidehiro return ret; 24823cb4a0bbSKawai, Hidehiro } 24833cb4a0bbSKawai, Hidehiro 24843cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_write(struct file *file, 24853cb4a0bbSKawai, Hidehiro const char __user *buf, 24863cb4a0bbSKawai, Hidehiro size_t count, 24873cb4a0bbSKawai, Hidehiro loff_t *ppos) 24883cb4a0bbSKawai, Hidehiro { 24893cb4a0bbSKawai, Hidehiro struct task_struct *task; 24903cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 24913cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF], *end; 24923cb4a0bbSKawai, Hidehiro unsigned int val; 24933cb4a0bbSKawai, Hidehiro int ret; 24943cb4a0bbSKawai, Hidehiro int i; 24953cb4a0bbSKawai, Hidehiro unsigned long mask; 24963cb4a0bbSKawai, Hidehiro 24973cb4a0bbSKawai, Hidehiro ret = -EFAULT; 24983cb4a0bbSKawai, Hidehiro memset(buffer, 0, sizeof(buffer)); 24993cb4a0bbSKawai, Hidehiro if (count > sizeof(buffer) - 1) 25003cb4a0bbSKawai, Hidehiro count = sizeof(buffer) - 1; 25013cb4a0bbSKawai, Hidehiro if (copy_from_user(buffer, buf, count)) 25023cb4a0bbSKawai, Hidehiro goto out_no_task; 25033cb4a0bbSKawai, Hidehiro 25043cb4a0bbSKawai, Hidehiro ret = -EINVAL; 25053cb4a0bbSKawai, Hidehiro val = (unsigned int)simple_strtoul(buffer, &end, 0); 25063cb4a0bbSKawai, Hidehiro if (*end == '\n') 25073cb4a0bbSKawai, Hidehiro end++; 25083cb4a0bbSKawai, Hidehiro if (end - buffer == 0) 25093cb4a0bbSKawai, Hidehiro goto out_no_task; 25103cb4a0bbSKawai, Hidehiro 25113cb4a0bbSKawai, Hidehiro ret = -ESRCH; 2512496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 25133cb4a0bbSKawai, Hidehiro if (!task) 25143cb4a0bbSKawai, Hidehiro goto out_no_task; 25153cb4a0bbSKawai, Hidehiro 25163cb4a0bbSKawai, Hidehiro ret = end - buffer; 25173cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 25183cb4a0bbSKawai, Hidehiro if (!mm) 25193cb4a0bbSKawai, Hidehiro goto out_no_mm; 25203cb4a0bbSKawai, Hidehiro 25213cb4a0bbSKawai, Hidehiro for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) { 25223cb4a0bbSKawai, Hidehiro if (val & mask) 25233cb4a0bbSKawai, Hidehiro set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 25243cb4a0bbSKawai, Hidehiro else 25253cb4a0bbSKawai, Hidehiro clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 25263cb4a0bbSKawai, Hidehiro } 25273cb4a0bbSKawai, Hidehiro 25283cb4a0bbSKawai, Hidehiro mmput(mm); 25293cb4a0bbSKawai, Hidehiro out_no_mm: 25303cb4a0bbSKawai, Hidehiro put_task_struct(task); 25313cb4a0bbSKawai, Hidehiro out_no_task: 25323cb4a0bbSKawai, Hidehiro return ret; 25333cb4a0bbSKawai, Hidehiro } 25343cb4a0bbSKawai, Hidehiro 25353cb4a0bbSKawai, Hidehiro static const struct file_operations proc_coredump_filter_operations = { 25363cb4a0bbSKawai, Hidehiro .read = proc_coredump_filter_read, 25373cb4a0bbSKawai, Hidehiro .write = proc_coredump_filter_write, 253887df8424SArnd Bergmann .llseek = generic_file_llseek, 25393cb4a0bbSKawai, Hidehiro }; 25403cb4a0bbSKawai, Hidehiro #endif 25413cb4a0bbSKawai, Hidehiro 2542aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 254319aadc98SAlexey Dobriyan static int do_io_accounting(struct task_struct *task, struct seq_file *m, int whole) 2544aba76fdbSAndrew Morton { 2545940389b8SAndrea Righi struct task_io_accounting acct = task->ioac; 2546297c5d92SAndrea Righi unsigned long flags; 2547293eb1e7SVasiliy Kulikov int result; 2548297c5d92SAndrea Righi 2549293eb1e7SVasiliy Kulikov result = mutex_lock_killable(&task->signal->cred_guard_mutex); 2550293eb1e7SVasiliy Kulikov if (result) 2551293eb1e7SVasiliy Kulikov return result; 2552293eb1e7SVasiliy Kulikov 2553293eb1e7SVasiliy Kulikov if (!ptrace_may_access(task, PTRACE_MODE_READ)) { 2554293eb1e7SVasiliy Kulikov result = -EACCES; 2555293eb1e7SVasiliy Kulikov goto out_unlock; 2556293eb1e7SVasiliy Kulikov } 25571d1221f3SVasiliy Kulikov 25585995477aSAndrea Righi if (whole && lock_task_sighand(task, &flags)) { 2559b2d002dbSAndrea Righi struct task_struct *t = task; 2560297c5d92SAndrea Righi 25615995477aSAndrea Righi task_io_accounting_add(&acct, &task->signal->ioac); 25625995477aSAndrea Righi while_each_thread(task, t) 25635995477aSAndrea Righi task_io_accounting_add(&acct, &t->ioac); 2564297c5d92SAndrea Righi 2565297c5d92SAndrea Righi unlock_task_sighand(task, &flags); 2566297c5d92SAndrea Righi } 256725ce3191SJoe Perches seq_printf(m, 2568aba76fdbSAndrew Morton "rchar: %llu\n" 2569aba76fdbSAndrew Morton "wchar: %llu\n" 2570aba76fdbSAndrew Morton "syscr: %llu\n" 2571aba76fdbSAndrew Morton "syscw: %llu\n" 2572aba76fdbSAndrew Morton "read_bytes: %llu\n" 2573aba76fdbSAndrew Morton "write_bytes: %llu\n" 2574aba76fdbSAndrew Morton "cancelled_write_bytes: %llu\n", 25757c44319dSAlexander Beregalov (unsigned long long)acct.rchar, 25767c44319dSAlexander Beregalov (unsigned long long)acct.wchar, 25777c44319dSAlexander Beregalov (unsigned long long)acct.syscr, 25787c44319dSAlexander Beregalov (unsigned long long)acct.syscw, 25797c44319dSAlexander Beregalov (unsigned long long)acct.read_bytes, 25807c44319dSAlexander Beregalov (unsigned long long)acct.write_bytes, 25817c44319dSAlexander Beregalov (unsigned long long)acct.cancelled_write_bytes); 258225ce3191SJoe Perches result = 0; 258325ce3191SJoe Perches 2584293eb1e7SVasiliy Kulikov out_unlock: 2585293eb1e7SVasiliy Kulikov mutex_unlock(&task->signal->cred_guard_mutex); 2586293eb1e7SVasiliy Kulikov return result; 2587aba76fdbSAndrew Morton } 2588297c5d92SAndrea Righi 258919aadc98SAlexey Dobriyan static int proc_tid_io_accounting(struct seq_file *m, struct pid_namespace *ns, 259019aadc98SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2591297c5d92SAndrea Righi { 259219aadc98SAlexey Dobriyan return do_io_accounting(task, m, 0); 2593297c5d92SAndrea Righi } 2594297c5d92SAndrea Righi 259519aadc98SAlexey Dobriyan static int proc_tgid_io_accounting(struct seq_file *m, struct pid_namespace *ns, 259619aadc98SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2597297c5d92SAndrea Righi { 259819aadc98SAlexey Dobriyan return do_io_accounting(task, m, 1); 2599297c5d92SAndrea Righi } 2600297c5d92SAndrea Righi #endif /* CONFIG_TASK_IO_ACCOUNTING */ 2601aba76fdbSAndrew Morton 260222d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 260322d917d8SEric W. Biederman static int proc_id_map_open(struct inode *inode, struct file *file, 2604ccf94f1bSFabian Frederick const struct seq_operations *seq_ops) 260522d917d8SEric W. Biederman { 260622d917d8SEric W. Biederman struct user_namespace *ns = NULL; 260722d917d8SEric W. Biederman struct task_struct *task; 260822d917d8SEric W. Biederman struct seq_file *seq; 260922d917d8SEric W. Biederman int ret = -EINVAL; 261022d917d8SEric W. Biederman 261122d917d8SEric W. Biederman task = get_proc_task(inode); 261222d917d8SEric W. Biederman if (task) { 261322d917d8SEric W. Biederman rcu_read_lock(); 261422d917d8SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 261522d917d8SEric W. Biederman rcu_read_unlock(); 261622d917d8SEric W. Biederman put_task_struct(task); 261722d917d8SEric W. Biederman } 261822d917d8SEric W. Biederman if (!ns) 261922d917d8SEric W. Biederman goto err; 262022d917d8SEric W. Biederman 262122d917d8SEric W. Biederman ret = seq_open(file, seq_ops); 262222d917d8SEric W. Biederman if (ret) 262322d917d8SEric W. Biederman goto err_put_ns; 262422d917d8SEric W. Biederman 262522d917d8SEric W. Biederman seq = file->private_data; 262622d917d8SEric W. Biederman seq->private = ns; 262722d917d8SEric W. Biederman 262822d917d8SEric W. Biederman return 0; 262922d917d8SEric W. Biederman err_put_ns: 263022d917d8SEric W. Biederman put_user_ns(ns); 263122d917d8SEric W. Biederman err: 263222d917d8SEric W. Biederman return ret; 263322d917d8SEric W. Biederman } 263422d917d8SEric W. Biederman 263522d917d8SEric W. Biederman static int proc_id_map_release(struct inode *inode, struct file *file) 263622d917d8SEric W. Biederman { 263722d917d8SEric W. Biederman struct seq_file *seq = file->private_data; 263822d917d8SEric W. Biederman struct user_namespace *ns = seq->private; 263922d917d8SEric W. Biederman put_user_ns(ns); 264022d917d8SEric W. Biederman return seq_release(inode, file); 264122d917d8SEric W. Biederman } 264222d917d8SEric W. Biederman 264322d917d8SEric W. Biederman static int proc_uid_map_open(struct inode *inode, struct file *file) 264422d917d8SEric W. Biederman { 264522d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_uid_seq_operations); 264622d917d8SEric W. Biederman } 264722d917d8SEric W. Biederman 264822d917d8SEric W. Biederman static int proc_gid_map_open(struct inode *inode, struct file *file) 264922d917d8SEric W. Biederman { 265022d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_gid_seq_operations); 265122d917d8SEric W. Biederman } 265222d917d8SEric W. Biederman 2653f76d207aSEric W. Biederman static int proc_projid_map_open(struct inode *inode, struct file *file) 2654f76d207aSEric W. Biederman { 2655f76d207aSEric W. Biederman return proc_id_map_open(inode, file, &proc_projid_seq_operations); 2656f76d207aSEric W. Biederman } 2657f76d207aSEric W. Biederman 265822d917d8SEric W. Biederman static const struct file_operations proc_uid_map_operations = { 265922d917d8SEric W. Biederman .open = proc_uid_map_open, 266022d917d8SEric W. Biederman .write = proc_uid_map_write, 266122d917d8SEric W. Biederman .read = seq_read, 266222d917d8SEric W. Biederman .llseek = seq_lseek, 266322d917d8SEric W. Biederman .release = proc_id_map_release, 266422d917d8SEric W. Biederman }; 266522d917d8SEric W. Biederman 266622d917d8SEric W. Biederman static const struct file_operations proc_gid_map_operations = { 266722d917d8SEric W. Biederman .open = proc_gid_map_open, 266822d917d8SEric W. Biederman .write = proc_gid_map_write, 266922d917d8SEric W. Biederman .read = seq_read, 267022d917d8SEric W. Biederman .llseek = seq_lseek, 267122d917d8SEric W. Biederman .release = proc_id_map_release, 267222d917d8SEric W. Biederman }; 2673f76d207aSEric W. Biederman 2674f76d207aSEric W. Biederman static const struct file_operations proc_projid_map_operations = { 2675f76d207aSEric W. Biederman .open = proc_projid_map_open, 2676f76d207aSEric W. Biederman .write = proc_projid_map_write, 2677f76d207aSEric W. Biederman .read = seq_read, 2678f76d207aSEric W. Biederman .llseek = seq_lseek, 2679f76d207aSEric W. Biederman .release = proc_id_map_release, 2680f76d207aSEric W. Biederman }; 26819cc46516SEric W. Biederman 26829cc46516SEric W. Biederman static int proc_setgroups_open(struct inode *inode, struct file *file) 26839cc46516SEric W. Biederman { 26849cc46516SEric W. Biederman struct user_namespace *ns = NULL; 26859cc46516SEric W. Biederman struct task_struct *task; 26869cc46516SEric W. Biederman int ret; 26879cc46516SEric W. Biederman 26889cc46516SEric W. Biederman ret = -ESRCH; 26899cc46516SEric W. Biederman task = get_proc_task(inode); 26909cc46516SEric W. Biederman if (task) { 26919cc46516SEric W. Biederman rcu_read_lock(); 26929cc46516SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 26939cc46516SEric W. Biederman rcu_read_unlock(); 26949cc46516SEric W. Biederman put_task_struct(task); 26959cc46516SEric W. Biederman } 26969cc46516SEric W. Biederman if (!ns) 26979cc46516SEric W. Biederman goto err; 26989cc46516SEric W. Biederman 26999cc46516SEric W. Biederman if (file->f_mode & FMODE_WRITE) { 27009cc46516SEric W. Biederman ret = -EACCES; 27019cc46516SEric W. Biederman if (!ns_capable(ns, CAP_SYS_ADMIN)) 27029cc46516SEric W. Biederman goto err_put_ns; 27039cc46516SEric W. Biederman } 27049cc46516SEric W. Biederman 27059cc46516SEric W. Biederman ret = single_open(file, &proc_setgroups_show, ns); 27069cc46516SEric W. Biederman if (ret) 27079cc46516SEric W. Biederman goto err_put_ns; 27089cc46516SEric W. Biederman 27099cc46516SEric W. Biederman return 0; 27109cc46516SEric W. Biederman err_put_ns: 27119cc46516SEric W. Biederman put_user_ns(ns); 27129cc46516SEric W. Biederman err: 27139cc46516SEric W. Biederman return ret; 27149cc46516SEric W. Biederman } 27159cc46516SEric W. Biederman 27169cc46516SEric W. Biederman static int proc_setgroups_release(struct inode *inode, struct file *file) 27179cc46516SEric W. Biederman { 27189cc46516SEric W. Biederman struct seq_file *seq = file->private_data; 27199cc46516SEric W. Biederman struct user_namespace *ns = seq->private; 27209cc46516SEric W. Biederman int ret = single_release(inode, file); 27219cc46516SEric W. Biederman put_user_ns(ns); 27229cc46516SEric W. Biederman return ret; 27239cc46516SEric W. Biederman } 27249cc46516SEric W. Biederman 27259cc46516SEric W. Biederman static const struct file_operations proc_setgroups_operations = { 27269cc46516SEric W. Biederman .open = proc_setgroups_open, 27279cc46516SEric W. Biederman .write = proc_setgroups_write, 27289cc46516SEric W. Biederman .read = seq_read, 27299cc46516SEric W. Biederman .llseek = seq_lseek, 27309cc46516SEric W. Biederman .release = proc_setgroups_release, 27319cc46516SEric W. Biederman }; 273222d917d8SEric W. Biederman #endif /* CONFIG_USER_NS */ 273322d917d8SEric W. Biederman 273447830723SKees Cook static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns, 273547830723SKees Cook struct pid *pid, struct task_struct *task) 273647830723SKees Cook { 2737a9712bc1SAl Viro int err = lock_trace(task); 2738a9712bc1SAl Viro if (!err) { 273947830723SKees Cook seq_printf(m, "%08x\n", task->personality); 2740a9712bc1SAl Viro unlock_trace(task); 2741a9712bc1SAl Viro } 2742a9712bc1SAl Viro return err; 274347830723SKees Cook } 274447830723SKees Cook 2745801199ceSEric W. Biederman /* 274628a6d671SEric W. Biederman * Thread groups 274728a6d671SEric W. Biederman */ 274800977a59SArjan van de Ven static const struct file_operations proc_task_operations; 2749c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations; 275020cdc894SEric W. Biederman 2751c5141e6dSEric Dumazet static const struct pid_entry tgid_base_stuff[] = { 2752631f9c18SAlexey Dobriyan DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations), 2753631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 2754640708a2SPavel Emelyanov DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations), 2755631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 27566b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 2757b2211a36SAndrew Morton #ifdef CONFIG_NET 2758631f9c18SAlexey Dobriyan DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 2759b2211a36SAndrew Morton #endif 2760631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2761f9ea536eSAlexey Dobriyan ONE("auxv", S_IRUSR, proc_pid_auxv), 2762631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 276335a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 27641c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 276543ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2766631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 276743ae34cbSIngo Molnar #endif 27685091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 27695091faa4SMike Galbraith REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations), 27705091faa4SMike Galbraith #endif 27714614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 2772ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 277309d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 2774ebcb6734SRoland McGrath #endif 2775c2c0bb44SAlexey Dobriyan REG("cmdline", S_IRUGO, proc_pid_cmdline_ops), 2776631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tgid_stat), 2777631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2778b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_pid_maps_operations), 277928a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2780b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations), 278128a6d671SEric W. Biederman #endif 2782631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2783631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2784631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2785631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2786631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2787631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 2788631f9c18SAlexey Dobriyan REG("mountstats", S_IRUSR, proc_mountstats_operations), 27891e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2790631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2791b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_pid_smaps_operations), 279232ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 279328a6d671SEric W. Biederman #endif 279428a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2795631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 279628a6d671SEric W. Biederman #endif 279728a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2798edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 279928a6d671SEric W. Biederman #endif 28002ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 280135a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 280228a6d671SEric W. Biederman #endif 28035968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 2804f6e826caSAlexey Dobriyan ONE("schedstat", S_IRUGO, proc_pid_schedstat), 280528a6d671SEric W. Biederman #endif 28069745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2807631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 28089745512cSArjan van de Ven #endif 28098793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 281052de4779SZefan Li ONE("cpuset", S_IRUGO, proc_cpuset_show), 281128a6d671SEric W. Biederman #endif 2812a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2813006f4ac4SZefan Li ONE("cgroup", S_IRUGO, proc_cgroup_show), 2814a424316cSPaul Menage #endif 28156ba51e37SAlexey Dobriyan ONE("oom_score", S_IRUGO, proc_oom_score), 2816fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 2817a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 281828a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2819631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 2820631f9c18SAlexey Dobriyan REG("sessionid", S_IRUGO, proc_sessionid_operations), 282128a6d671SEric W. Biederman #endif 2822f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2823631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2824f4f154fdSAkinobu Mita #endif 2825698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 2826631f9c18SAlexey Dobriyan REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations), 28273cb4a0bbSKawai, Hidehiro #endif 2828aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 282919aadc98SAlexey Dobriyan ONE("io", S_IRUSR, proc_tgid_io_accounting), 2830aba76fdbSAndrew Morton #endif 2831f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 2832d962c144SAlexey Dobriyan ONE("hardwall", S_IRUGO, proc_pid_hardwall), 2833f133eccaSChris Metcalf #endif 283422d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 283522d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 283622d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 2837f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 28389cc46516SEric W. Biederman REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), 283922d917d8SEric W. Biederman #endif 284048f6a7a5SPavel Emelyanov #ifdef CONFIG_CHECKPOINT_RESTORE 284148f6a7a5SPavel Emelyanov REG("timers", S_IRUGO, proc_timers_operations), 284248f6a7a5SPavel Emelyanov #endif 284328a6d671SEric W. Biederman }; 284428a6d671SEric W. Biederman 2845f0c3b509SAl Viro static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx) 284628a6d671SEric W. Biederman { 2847f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 284828a6d671SEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 284928a6d671SEric W. Biederman } 285028a6d671SEric W. Biederman 285100977a59SArjan van de Ven static const struct file_operations proc_tgid_base_operations = { 285228a6d671SEric W. Biederman .read = generic_read_dir, 2853f0c3b509SAl Viro .iterate = proc_tgid_base_readdir, 28546038f373SArnd Bergmann .llseek = default_llseek, 285528a6d671SEric W. Biederman }; 285628a6d671SEric W. Biederman 285700cd8dd3SAl Viro static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 285800cd8dd3SAl Viro { 28597bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 28607bcd6b0eSEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 286128a6d671SEric W. Biederman } 286228a6d671SEric W. Biederman 2863c5ef1c42SArjan van de Ven static const struct inode_operations proc_tgid_base_inode_operations = { 286428a6d671SEric W. Biederman .lookup = proc_tgid_base_lookup, 286528a6d671SEric W. Biederman .getattr = pid_getattr, 286628a6d671SEric W. Biederman .setattr = proc_setattr, 28670499680aSVasiliy Kulikov .permission = proc_pid_permission, 286828a6d671SEric W. Biederman }; 286928a6d671SEric W. Biederman 287060347f67SPavel Emelyanov static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid) 28711da177e4SLinus Torvalds { 287248e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 28738578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 287448e6484dSEric W. Biederman struct qstr name; 28751da177e4SLinus Torvalds 287648e6484dSEric W. Biederman name.name = buf; 287760347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 28784f522a24SAl Viro /* no ->d_hash() rejects on procfs */ 287960347f67SPavel Emelyanov dentry = d_hash_and_lookup(mnt->mnt_root, &name); 288048e6484dSEric W. Biederman if (dentry) { 2881bbd51924SEric W. Biederman d_invalidate(dentry); 288248e6484dSEric W. Biederman dput(dentry); 28831da177e4SLinus Torvalds } 28841da177e4SLinus Torvalds 2885c35a7f18SOleg Nesterov if (pid == tgid) 2886c35a7f18SOleg Nesterov return; 2887c35a7f18SOleg Nesterov 288848e6484dSEric W. Biederman name.name = buf; 288960347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", tgid); 289060347f67SPavel Emelyanov leader = d_hash_and_lookup(mnt->mnt_root, &name); 289148e6484dSEric W. Biederman if (!leader) 289248e6484dSEric W. Biederman goto out; 289348e6484dSEric W. Biederman 289448e6484dSEric W. Biederman name.name = "task"; 289548e6484dSEric W. Biederman name.len = strlen(name.name); 289648e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 289748e6484dSEric W. Biederman if (!dir) 289848e6484dSEric W. Biederman goto out_put_leader; 289948e6484dSEric W. Biederman 290048e6484dSEric W. Biederman name.name = buf; 290160347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 290248e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 290348e6484dSEric W. Biederman if (dentry) { 2904bbd51924SEric W. Biederman d_invalidate(dentry); 290548e6484dSEric W. Biederman dput(dentry); 29061da177e4SLinus Torvalds } 290748e6484dSEric W. Biederman 290848e6484dSEric W. Biederman dput(dir); 290948e6484dSEric W. Biederman out_put_leader: 291048e6484dSEric W. Biederman dput(leader); 291148e6484dSEric W. Biederman out: 291248e6484dSEric W. Biederman return; 29131da177e4SLinus Torvalds } 29141da177e4SLinus Torvalds 29150895e91dSRandy Dunlap /** 29160895e91dSRandy Dunlap * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 29170895e91dSRandy Dunlap * @task: task that should be flushed. 29180895e91dSRandy Dunlap * 29190895e91dSRandy Dunlap * When flushing dentries from proc, one needs to flush them from global 292060347f67SPavel Emelyanov * proc (proc_mnt) and from all the namespaces' procs this task was seen 29210895e91dSRandy Dunlap * in. This call is supposed to do all of this job. 29220895e91dSRandy Dunlap * 29230895e91dSRandy Dunlap * Looks in the dcache for 29240895e91dSRandy Dunlap * /proc/@pid 29250895e91dSRandy Dunlap * /proc/@tgid/task/@pid 29260895e91dSRandy Dunlap * if either directory is present flushes it and all of it'ts children 29270895e91dSRandy Dunlap * from the dcache. 29280895e91dSRandy Dunlap * 29290895e91dSRandy Dunlap * It is safe and reasonable to cache /proc entries for a task until 29300895e91dSRandy Dunlap * that task exits. After that they just clog up the dcache with 29310895e91dSRandy Dunlap * useless entries, possibly causing useful dcache entries to be 29320895e91dSRandy Dunlap * flushed instead. This routine is proved to flush those useless 29330895e91dSRandy Dunlap * dcache entries at process exit time. 29340895e91dSRandy Dunlap * 29350895e91dSRandy Dunlap * NOTE: This routine is just an optimization so it does not guarantee 29360895e91dSRandy Dunlap * that no dcache entries will exist at process exit time it 29370895e91dSRandy Dunlap * just makes it very unlikely that any will persist. 293860347f67SPavel Emelyanov */ 293960347f67SPavel Emelyanov 294060347f67SPavel Emelyanov void proc_flush_task(struct task_struct *task) 294160347f67SPavel Emelyanov { 29429fcc2d15SEric W. Biederman int i; 29439b4d1cbeSOleg Nesterov struct pid *pid, *tgid; 2944130f77ecSPavel Emelyanov struct upid *upid; 2945130f77ecSPavel Emelyanov 2946130f77ecSPavel Emelyanov pid = task_pid(task); 2947130f77ecSPavel Emelyanov tgid = task_tgid(task); 29489fcc2d15SEric W. Biederman 29499fcc2d15SEric W. Biederman for (i = 0; i <= pid->level; i++) { 2950130f77ecSPavel Emelyanov upid = &pid->numbers[i]; 2951130f77ecSPavel Emelyanov proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr, 29529b4d1cbeSOleg Nesterov tgid->numbers[i].nr); 2953130f77ecSPavel Emelyanov } 295460347f67SPavel Emelyanov } 295560347f67SPavel Emelyanov 2956c52a47acSAl Viro static int proc_pid_instantiate(struct inode *dir, 29579711ef99SAdrian Bunk struct dentry * dentry, 2958c5141e6dSEric Dumazet struct task_struct *task, const void *ptr) 2959444ceed8SEric W. Biederman { 2960444ceed8SEric W. Biederman struct inode *inode; 2961444ceed8SEric W. Biederman 296261a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2963444ceed8SEric W. Biederman if (!inode) 2964444ceed8SEric W. Biederman goto out; 2965444ceed8SEric W. Biederman 2966444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 2967444ceed8SEric W. Biederman inode->i_op = &proc_tgid_base_inode_operations; 2968444ceed8SEric W. Biederman inode->i_fop = &proc_tgid_base_operations; 2969444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 2970aed54175SVegard Nossum 2971bfe86848SMiklos Szeredi set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff, 2972bfe86848SMiklos Szeredi ARRAY_SIZE(tgid_base_stuff))); 2973444ceed8SEric W. Biederman 2974fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2975444ceed8SEric W. Biederman 2976444ceed8SEric W. Biederman d_add(dentry, inode); 2977444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 29780b728e19SAl Viro if (pid_revalidate(dentry, 0)) 2979c52a47acSAl Viro return 0; 2980444ceed8SEric W. Biederman out: 2981c52a47acSAl Viro return -ENOENT; 2982444ceed8SEric W. Biederman } 2983444ceed8SEric W. Biederman 298400cd8dd3SAl Viro struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 29851da177e4SLinus Torvalds { 2986335eb531SAlexey Dobriyan int result = -ENOENT; 29871da177e4SLinus Torvalds struct task_struct *task; 29881da177e4SLinus Torvalds unsigned tgid; 2989b488893aSPavel Emelyanov struct pid_namespace *ns; 29901da177e4SLinus Torvalds 2991dbcdb504SAlexey Dobriyan tgid = name_to_int(&dentry->d_name); 29921da177e4SLinus Torvalds if (tgid == ~0U) 29931da177e4SLinus Torvalds goto out; 29941da177e4SLinus Torvalds 2995b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 2996de758734SEric W. Biederman rcu_read_lock(); 2997b488893aSPavel Emelyanov task = find_task_by_pid_ns(tgid, ns); 29981da177e4SLinus Torvalds if (task) 29991da177e4SLinus Torvalds get_task_struct(task); 3000de758734SEric W. Biederman rcu_read_unlock(); 30011da177e4SLinus Torvalds if (!task) 30021da177e4SLinus Torvalds goto out; 30031da177e4SLinus Torvalds 3004444ceed8SEric W. Biederman result = proc_pid_instantiate(dir, dentry, task, NULL); 300548e6484dSEric W. Biederman put_task_struct(task); 30061da177e4SLinus Torvalds out: 3007c52a47acSAl Viro return ERR_PTR(result); 30081da177e4SLinus Torvalds } 30091da177e4SLinus Torvalds 30101da177e4SLinus Torvalds /* 30110804ef4bSEric W. Biederman * Find the first task with tgid >= tgid 30120bc58a91SEric W. Biederman * 30131da177e4SLinus Torvalds */ 301419fd4bb2SEric W. Biederman struct tgid_iter { 301519fd4bb2SEric W. Biederman unsigned int tgid; 30160804ef4bSEric W. Biederman struct task_struct *task; 301719fd4bb2SEric W. Biederman }; 301819fd4bb2SEric W. Biederman static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter) 301919fd4bb2SEric W. Biederman { 30200804ef4bSEric W. Biederman struct pid *pid; 30211da177e4SLinus Torvalds 302219fd4bb2SEric W. Biederman if (iter.task) 302319fd4bb2SEric W. Biederman put_task_struct(iter.task); 30240804ef4bSEric W. Biederman rcu_read_lock(); 30250804ef4bSEric W. Biederman retry: 302619fd4bb2SEric W. Biederman iter.task = NULL; 302719fd4bb2SEric W. Biederman pid = find_ge_pid(iter.tgid, ns); 30280804ef4bSEric W. Biederman if (pid) { 302919fd4bb2SEric W. Biederman iter.tgid = pid_nr_ns(pid, ns); 303019fd4bb2SEric W. Biederman iter.task = pid_task(pid, PIDTYPE_PID); 30310804ef4bSEric W. Biederman /* What we to know is if the pid we have find is the 30320804ef4bSEric W. Biederman * pid of a thread_group_leader. Testing for task 30330804ef4bSEric W. Biederman * being a thread_group_leader is the obvious thing 30340804ef4bSEric W. Biederman * todo but there is a window when it fails, due to 30350804ef4bSEric W. Biederman * the pid transfer logic in de_thread. 30360804ef4bSEric W. Biederman * 30370804ef4bSEric W. Biederman * So we perform the straight forward test of seeing 30380804ef4bSEric W. Biederman * if the pid we have found is the pid of a thread 30390804ef4bSEric W. Biederman * group leader, and don't worry if the task we have 30400804ef4bSEric W. Biederman * found doesn't happen to be a thread group leader. 30410804ef4bSEric W. Biederman * As we don't care in the case of readdir. 30420bc58a91SEric W. Biederman */ 304319fd4bb2SEric W. Biederman if (!iter.task || !has_group_leader_pid(iter.task)) { 304419fd4bb2SEric W. Biederman iter.tgid += 1; 30450804ef4bSEric W. Biederman goto retry; 304619fd4bb2SEric W. Biederman } 304719fd4bb2SEric W. Biederman get_task_struct(iter.task); 30481da177e4SLinus Torvalds } 3049454cc105SEric W. Biederman rcu_read_unlock(); 305019fd4bb2SEric W. Biederman return iter; 30511da177e4SLinus Torvalds } 30521da177e4SLinus Torvalds 30530097875bSEric W. Biederman #define TGID_OFFSET (FIRST_PROCESS_ENTRY + 2) 30541da177e4SLinus Torvalds 30551da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 3056f0c3b509SAl Viro int proc_pid_readdir(struct file *file, struct dir_context *ctx) 30571da177e4SLinus Torvalds { 305819fd4bb2SEric W. Biederman struct tgid_iter iter; 30593aa3377fSAl Viro struct pid_namespace *ns = file_inode(file)->i_sb->s_fs_info; 3060f0c3b509SAl Viro loff_t pos = ctx->pos; 30611da177e4SLinus Torvalds 3062021ada7dSAl Viro if (pos >= PID_MAX_LIMIT + TGID_OFFSET) 3063f0c3b509SAl Viro return 0; 30641da177e4SLinus Torvalds 30650097875bSEric W. Biederman if (pos == TGID_OFFSET - 2) { 30662b0143b5SDavid Howells struct inode *inode = d_inode(ns->proc_self); 3067db963164SAl Viro if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK)) 3068f0c3b509SAl Viro return 0; 30690097875bSEric W. Biederman ctx->pos = pos = pos + 1; 3070021ada7dSAl Viro } 30710097875bSEric W. Biederman if (pos == TGID_OFFSET - 1) { 30722b0143b5SDavid Howells struct inode *inode = d_inode(ns->proc_thread_self); 30730097875bSEric W. Biederman if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK)) 30740097875bSEric W. Biederman return 0; 30750097875bSEric W. Biederman ctx->pos = pos = pos + 1; 30760097875bSEric W. Biederman } 30770097875bSEric W. Biederman iter.tgid = pos - TGID_OFFSET; 307819fd4bb2SEric W. Biederman iter.task = NULL; 307919fd4bb2SEric W. Biederman for (iter = next_tgid(ns, iter); 308019fd4bb2SEric W. Biederman iter.task; 308119fd4bb2SEric W. Biederman iter.tgid += 1, iter = next_tgid(ns, iter)) { 3082f0c3b509SAl Viro char name[PROC_NUMBUF]; 3083f0c3b509SAl Viro int len; 3084f0c3b509SAl Viro if (!has_pid_permissions(ns, iter.task, 2)) 3085f0c3b509SAl Viro continue; 30860499680aSVasiliy Kulikov 3087f0c3b509SAl Viro len = snprintf(name, sizeof(name), "%d", iter.tgid); 3088f0c3b509SAl Viro ctx->pos = iter.tgid + TGID_OFFSET; 3089f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3090f0c3b509SAl Viro proc_pid_instantiate, iter.task, NULL)) { 309119fd4bb2SEric W. Biederman put_task_struct(iter.task); 3092f0c3b509SAl Viro return 0; 30931da177e4SLinus Torvalds } 30941da177e4SLinus Torvalds } 3095f0c3b509SAl Viro ctx->pos = PID_MAX_LIMIT + TGID_OFFSET; 30961da177e4SLinus Torvalds return 0; 30971da177e4SLinus Torvalds } 30981da177e4SLinus Torvalds 30990bc58a91SEric W. Biederman /* 310028a6d671SEric W. Biederman * Tasks 310128a6d671SEric W. Biederman */ 3102c5141e6dSEric Dumazet static const struct pid_entry tid_base_stuff[] = { 3103631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 31043835541dSJerome Marchand DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 31056b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 31066ba8ed79SEric W. Biederman #ifdef CONFIG_NET 31076ba8ed79SEric W. Biederman DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 31086ba8ed79SEric W. Biederman #endif 3109631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 3110f9ea536eSAlexey Dobriyan ONE("auxv", S_IRUSR, proc_pid_auxv), 3111631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 311235a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 31131c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 311443ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 3115631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 311643ae34cbSIngo Molnar #endif 31174614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 3118ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 311909d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 3120ebcb6734SRoland McGrath #endif 3121c2c0bb44SAlexey Dobriyan REG("cmdline", S_IRUGO, proc_pid_cmdline_ops), 3122631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tid_stat), 3123631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 3124b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_tid_maps_operations), 31252e13ba54SIago López Galeiras #ifdef CONFIG_PROC_CHILDREN 312681841161SCyrill Gorcunov REG("children", S_IRUGO, proc_tid_children_operations), 312781841161SCyrill Gorcunov #endif 312828a6d671SEric W. Biederman #ifdef CONFIG_NUMA 3129b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations), 313028a6d671SEric W. Biederman #endif 3131631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 3132631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 3133631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 3134631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 3135631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 3136631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 31371e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 3138631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 3139b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_tid_smaps_operations), 314032ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 314128a6d671SEric W. Biederman #endif 314228a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 3143631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 314428a6d671SEric W. Biederman #endif 314528a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 3146edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 314728a6d671SEric W. Biederman #endif 31482ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 314935a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 315028a6d671SEric W. Biederman #endif 31515968ceceSNaveen N. Rao #ifdef CONFIG_SCHED_INFO 3152f6e826caSAlexey Dobriyan ONE("schedstat", S_IRUGO, proc_pid_schedstat), 315328a6d671SEric W. Biederman #endif 31549745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3155631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 31569745512cSArjan van de Ven #endif 31578793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 315852de4779SZefan Li ONE("cpuset", S_IRUGO, proc_cpuset_show), 315928a6d671SEric W. Biederman #endif 3160a424316cSPaul Menage #ifdef CONFIG_CGROUPS 3161006f4ac4SZefan Li ONE("cgroup", S_IRUGO, proc_cgroup_show), 3162a424316cSPaul Menage #endif 31636ba51e37SAlexey Dobriyan ONE("oom_score", S_IRUGO, proc_oom_score), 3164fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 3165a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 316628a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 3167631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 316826ec3c64SAl Viro REG("sessionid", S_IRUGO, proc_sessionid_operations), 316928a6d671SEric W. Biederman #endif 3170f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 3171631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 3172f4f154fdSAkinobu Mita #endif 3173297c5d92SAndrea Righi #ifdef CONFIG_TASK_IO_ACCOUNTING 317419aadc98SAlexey Dobriyan ONE("io", S_IRUSR, proc_tid_io_accounting), 3175297c5d92SAndrea Righi #endif 3176f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 3177d962c144SAlexey Dobriyan ONE("hardwall", S_IRUGO, proc_pid_hardwall), 3178f133eccaSChris Metcalf #endif 317922d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 318022d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 318122d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 3182f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 31839cc46516SEric W. Biederman REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_operations), 318422d917d8SEric W. Biederman #endif 318528a6d671SEric W. Biederman }; 318628a6d671SEric W. Biederman 3187f0c3b509SAl Viro static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx) 318828a6d671SEric W. Biederman { 3189f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 319028a6d671SEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 319128a6d671SEric W. Biederman } 319228a6d671SEric W. Biederman 319300cd8dd3SAl Viro static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 319400cd8dd3SAl Viro { 31957bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 31967bcd6b0eSEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 319728a6d671SEric W. Biederman } 319828a6d671SEric W. Biederman 319900977a59SArjan van de Ven static const struct file_operations proc_tid_base_operations = { 320028a6d671SEric W. Biederman .read = generic_read_dir, 3201f0c3b509SAl Viro .iterate = proc_tid_base_readdir, 32026038f373SArnd Bergmann .llseek = default_llseek, 320328a6d671SEric W. Biederman }; 320428a6d671SEric W. Biederman 3205c5ef1c42SArjan van de Ven static const struct inode_operations proc_tid_base_inode_operations = { 320628a6d671SEric W. Biederman .lookup = proc_tid_base_lookup, 320728a6d671SEric W. Biederman .getattr = pid_getattr, 320828a6d671SEric W. Biederman .setattr = proc_setattr, 320928a6d671SEric W. Biederman }; 321028a6d671SEric W. Biederman 3211c52a47acSAl Viro static int proc_task_instantiate(struct inode *dir, 3212c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 3213444ceed8SEric W. Biederman { 3214444ceed8SEric W. Biederman struct inode *inode; 321561a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 3216444ceed8SEric W. Biederman 3217444ceed8SEric W. Biederman if (!inode) 3218444ceed8SEric W. Biederman goto out; 3219444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 3220444ceed8SEric W. Biederman inode->i_op = &proc_tid_base_inode_operations; 3221444ceed8SEric W. Biederman inode->i_fop = &proc_tid_base_operations; 3222444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 3223aed54175SVegard Nossum 3224bfe86848SMiklos Szeredi set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff, 3225bfe86848SMiklos Szeredi ARRAY_SIZE(tid_base_stuff))); 3226444ceed8SEric W. Biederman 3227fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 3228444ceed8SEric W. Biederman 3229444ceed8SEric W. Biederman d_add(dentry, inode); 3230444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 32310b728e19SAl Viro if (pid_revalidate(dentry, 0)) 3232c52a47acSAl Viro return 0; 3233444ceed8SEric W. Biederman out: 3234c52a47acSAl Viro return -ENOENT; 3235444ceed8SEric W. Biederman } 3236444ceed8SEric W. Biederman 323700cd8dd3SAl Viro static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 323828a6d671SEric W. Biederman { 3239c52a47acSAl Viro int result = -ENOENT; 324028a6d671SEric W. Biederman struct task_struct *task; 324128a6d671SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 324228a6d671SEric W. Biederman unsigned tid; 3243b488893aSPavel Emelyanov struct pid_namespace *ns; 324428a6d671SEric W. Biederman 324528a6d671SEric W. Biederman if (!leader) 324628a6d671SEric W. Biederman goto out_no_task; 324728a6d671SEric W. Biederman 3248dbcdb504SAlexey Dobriyan tid = name_to_int(&dentry->d_name); 324928a6d671SEric W. Biederman if (tid == ~0U) 325028a6d671SEric W. Biederman goto out; 325128a6d671SEric W. Biederman 3252b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 325328a6d671SEric W. Biederman rcu_read_lock(); 3254b488893aSPavel Emelyanov task = find_task_by_pid_ns(tid, ns); 325528a6d671SEric W. Biederman if (task) 325628a6d671SEric W. Biederman get_task_struct(task); 325728a6d671SEric W. Biederman rcu_read_unlock(); 325828a6d671SEric W. Biederman if (!task) 325928a6d671SEric W. Biederman goto out; 3260bac0abd6SPavel Emelyanov if (!same_thread_group(leader, task)) 326128a6d671SEric W. Biederman goto out_drop_task; 326228a6d671SEric W. Biederman 3263444ceed8SEric W. Biederman result = proc_task_instantiate(dir, dentry, task, NULL); 326428a6d671SEric W. Biederman out_drop_task: 326528a6d671SEric W. Biederman put_task_struct(task); 326628a6d671SEric W. Biederman out: 326728a6d671SEric W. Biederman put_task_struct(leader); 326828a6d671SEric W. Biederman out_no_task: 3269c52a47acSAl Viro return ERR_PTR(result); 327028a6d671SEric W. Biederman } 327128a6d671SEric W. Biederman 327228a6d671SEric W. Biederman /* 32730bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 32740bc58a91SEric W. Biederman * 32750bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 32760bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 32770bc58a91SEric W. Biederman * directory we have more work todo. 32780bc58a91SEric W. Biederman * 32790bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 32800bc58a91SEric W. Biederman * 32810bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 32820bc58a91SEric W. Biederman * threads past it. 32830bc58a91SEric W. Biederman */ 32849f6e963fSOleg Nesterov static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos, 32859f6e963fSOleg Nesterov struct pid_namespace *ns) 32860bc58a91SEric W. Biederman { 3287d855a4b7SOleg Nesterov struct task_struct *pos, *task; 32889f6e963fSOleg Nesterov unsigned long nr = f_pos; 32899f6e963fSOleg Nesterov 32909f6e963fSOleg Nesterov if (nr != f_pos) /* 32bit overflow? */ 32919f6e963fSOleg Nesterov return NULL; 32920bc58a91SEric W. Biederman 3293cc288738SEric W. Biederman rcu_read_lock(); 3294d855a4b7SOleg Nesterov task = pid_task(pid, PIDTYPE_PID); 3295d855a4b7SOleg Nesterov if (!task) 3296d855a4b7SOleg Nesterov goto fail; 3297d855a4b7SOleg Nesterov 3298d855a4b7SOleg Nesterov /* Attempt to start with the tid of a thread */ 32999f6e963fSOleg Nesterov if (tid && nr) { 3300b488893aSPavel Emelyanov pos = find_task_by_pid_ns(tid, ns); 3301d855a4b7SOleg Nesterov if (pos && same_thread_group(pos, task)) 3302a872ff0cSOleg Nesterov goto found; 33030bc58a91SEric W. Biederman } 33040bc58a91SEric W. Biederman 33050bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 33069f6e963fSOleg Nesterov if (nr >= get_nr_threads(task)) 3307c986c14aSOleg Nesterov goto fail; 3308a872ff0cSOleg Nesterov 3309a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 3310a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 3311a872ff0cSOleg Nesterov */ 3312d855a4b7SOleg Nesterov pos = task = task->group_leader; 3313c986c14aSOleg Nesterov do { 33149f6e963fSOleg Nesterov if (!nr--) 3315c986c14aSOleg Nesterov goto found; 3316d855a4b7SOleg Nesterov } while_each_thread(task, pos); 3317c986c14aSOleg Nesterov fail: 3318a872ff0cSOleg Nesterov pos = NULL; 3319a872ff0cSOleg Nesterov goto out; 3320a872ff0cSOleg Nesterov found: 3321a872ff0cSOleg Nesterov get_task_struct(pos); 3322a872ff0cSOleg Nesterov out: 3323cc288738SEric W. Biederman rcu_read_unlock(); 33240bc58a91SEric W. Biederman return pos; 33250bc58a91SEric W. Biederman } 33260bc58a91SEric W. Biederman 33270bc58a91SEric W. Biederman /* 33280bc58a91SEric W. Biederman * Find the next thread in the thread list. 33290bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 33300bc58a91SEric W. Biederman * 33310bc58a91SEric W. Biederman * The reference to the input task_struct is released. 33320bc58a91SEric W. Biederman */ 33330bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 33340bc58a91SEric W. Biederman { 3335c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 3336cc288738SEric W. Biederman rcu_read_lock(); 3337c1df7fb8SOleg Nesterov if (pid_alive(start)) { 33380bc58a91SEric W. Biederman pos = next_thread(start); 3339c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 33400bc58a91SEric W. Biederman pos = NULL; 3341c1df7fb8SOleg Nesterov else 3342c1df7fb8SOleg Nesterov get_task_struct(pos); 3343c1df7fb8SOleg Nesterov } 3344cc288738SEric W. Biederman rcu_read_unlock(); 33450bc58a91SEric W. Biederman put_task_struct(start); 33460bc58a91SEric W. Biederman return pos; 33470bc58a91SEric W. Biederman } 33480bc58a91SEric W. Biederman 33491da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 3350f0c3b509SAl Viro static int proc_task_readdir(struct file *file, struct dir_context *ctx) 33511da177e4SLinus Torvalds { 3352d855a4b7SOleg Nesterov struct inode *inode = file_inode(file); 3353d855a4b7SOleg Nesterov struct task_struct *task; 3354b488893aSPavel Emelyanov struct pid_namespace *ns; 3355f0c3b509SAl Viro int tid; 33561da177e4SLinus Torvalds 3357d855a4b7SOleg Nesterov if (proc_inode_is_dead(inode)) 3358f0c3b509SAl Viro return -ENOENT; 33591da177e4SLinus Torvalds 3360f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 3361d855a4b7SOleg Nesterov return 0; 33621da177e4SLinus Torvalds 33630bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 33640bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 33650bc58a91SEric W. Biederman */ 33663aa3377fSAl Viro ns = inode->i_sb->s_fs_info; 3367f0c3b509SAl Viro tid = (int)file->f_version; 3368f0c3b509SAl Viro file->f_version = 0; 3369d855a4b7SOleg Nesterov for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns); 33700bc58a91SEric W. Biederman task; 3371f0c3b509SAl Viro task = next_tid(task), ctx->pos++) { 3372f0c3b509SAl Viro char name[PROC_NUMBUF]; 3373f0c3b509SAl Viro int len; 3374b488893aSPavel Emelyanov tid = task_pid_nr_ns(task, ns); 3375f0c3b509SAl Viro len = snprintf(name, sizeof(name), "%d", tid); 3376f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3377f0c3b509SAl Viro proc_task_instantiate, task, NULL)) { 33780bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 33790bc58a91SEric W. Biederman * pid for the next readir call */ 3380f0c3b509SAl Viro file->f_version = (u64)tid; 33810bc58a91SEric W. Biederman put_task_struct(task); 33821da177e4SLinus Torvalds break; 33830bc58a91SEric W. Biederman } 33841da177e4SLinus Torvalds } 3385d855a4b7SOleg Nesterov 3386f0c3b509SAl Viro return 0; 33871da177e4SLinus Torvalds } 33886e66b52bSEric W. Biederman 33896e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 33906e66b52bSEric W. Biederman { 33912b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 339299f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 33936e66b52bSEric W. Biederman generic_fillattr(inode, stat); 33946e66b52bSEric W. Biederman 339599f89551SEric W. Biederman if (p) { 339699f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 339799f89551SEric W. Biederman put_task_struct(p); 33986e66b52bSEric W. Biederman } 33996e66b52bSEric W. Biederman 34006e66b52bSEric W. Biederman return 0; 34016e66b52bSEric W. Biederman } 340228a6d671SEric W. Biederman 3403c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations = { 340428a6d671SEric W. Biederman .lookup = proc_task_lookup, 340528a6d671SEric W. Biederman .getattr = proc_task_getattr, 340628a6d671SEric W. Biederman .setattr = proc_setattr, 34070499680aSVasiliy Kulikov .permission = proc_pid_permission, 340828a6d671SEric W. Biederman }; 340928a6d671SEric W. Biederman 341000977a59SArjan van de Ven static const struct file_operations proc_task_operations = { 341128a6d671SEric W. Biederman .read = generic_read_dir, 3412f0c3b509SAl Viro .iterate = proc_task_readdir, 34136038f373SArnd Bergmann .llseek = default_llseek, 341428a6d671SEric W. Biederman }; 3415