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> 561da177e4SLinus Torvalds #include <linux/init.h> 5716f7e0feSRandy Dunlap #include <linux/capability.h> 581da177e4SLinus Torvalds #include <linux/file.h> 591da177e4SLinus Torvalds #include <linux/string.h> 601da177e4SLinus Torvalds #include <linux/seq_file.h> 611da177e4SLinus Torvalds #include <linux/namei.h> 621da177e4SLinus Torvalds #include <linux/namespace.h> 631da177e4SLinus Torvalds #include <linux/mm.h> 641da177e4SLinus Torvalds #include <linux/smp_lock.h> 65b835996fSDipankar Sarma #include <linux/rcupdate.h> 661da177e4SLinus Torvalds #include <linux/kallsyms.h> 671da177e4SLinus Torvalds #include <linux/mount.h> 681da177e4SLinus Torvalds #include <linux/security.h> 691da177e4SLinus Torvalds #include <linux/ptrace.h> 701da177e4SLinus Torvalds #include <linux/seccomp.h> 711da177e4SLinus Torvalds #include <linux/cpuset.h> 721da177e4SLinus Torvalds #include <linux/audit.h> 735addc5ddSAl Viro #include <linux/poll.h> 741da177e4SLinus Torvalds #include "internal.h" 751da177e4SLinus Torvalds 760f2fe20fSEric W. Biederman /* NOTE: 770f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 780f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 790f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 800f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 810f2fe20fSEric W. Biederman * 820f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 830f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 840f2fe20fSEric W. Biederman */ 850f2fe20fSEric W. Biederman 861da177e4SLinus Torvalds /* 871da177e4SLinus Torvalds * For hysterical raisins we keep the same inumbers as in the old procfs. 881da177e4SLinus Torvalds * Feel free to change the macro below - just keep the range distinct from 891da177e4SLinus Torvalds * inumbers of the rest of procfs (currently those are in 0x0000--0xffff). 901da177e4SLinus Torvalds * As soon as we'll get a separate superblock we will be able to forget 911da177e4SLinus Torvalds * about magical ranges too. 921da177e4SLinus Torvalds */ 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds #define fake_ino(pid,ino) (((pid)<<16)|(ino)) 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds enum pid_directory_inos { 971da177e4SLinus Torvalds PROC_TGID_INO = 2, 981da177e4SLinus Torvalds PROC_TGID_TASK, 991da177e4SLinus Torvalds PROC_TGID_STATUS, 1001da177e4SLinus Torvalds PROC_TGID_MEM, 1011da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 1021da177e4SLinus Torvalds PROC_TGID_SECCOMP, 1031da177e4SLinus Torvalds #endif 1041da177e4SLinus Torvalds PROC_TGID_CWD, 1051da177e4SLinus Torvalds PROC_TGID_ROOT, 1061da177e4SLinus Torvalds PROC_TGID_EXE, 1071da177e4SLinus Torvalds PROC_TGID_FD, 1081da177e4SLinus Torvalds PROC_TGID_ENVIRON, 1091da177e4SLinus Torvalds PROC_TGID_AUXV, 1101da177e4SLinus Torvalds PROC_TGID_CMDLINE, 1111da177e4SLinus Torvalds PROC_TGID_STAT, 1121da177e4SLinus Torvalds PROC_TGID_STATM, 1131da177e4SLinus Torvalds PROC_TGID_MAPS, 1146e21c8f1SChristoph Lameter PROC_TGID_NUMA_MAPS, 1151da177e4SLinus Torvalds PROC_TGID_MOUNTS, 116b4629fe2SChuck Lever PROC_TGID_MOUNTSTATS, 1171da177e4SLinus Torvalds PROC_TGID_WCHAN, 11863c6764cSYoshinori Sato #ifdef CONFIG_MMU 119e070ad49SMauricio Lin PROC_TGID_SMAPS, 12063c6764cSYoshinori Sato #endif 1211da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 1221da177e4SLinus Torvalds PROC_TGID_SCHEDSTAT, 1231da177e4SLinus Torvalds #endif 1241da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 1251da177e4SLinus Torvalds PROC_TGID_CPUSET, 1261da177e4SLinus Torvalds #endif 1271da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 1281da177e4SLinus Torvalds PROC_TGID_ATTR, 1291da177e4SLinus Torvalds PROC_TGID_ATTR_CURRENT, 1301da177e4SLinus Torvalds PROC_TGID_ATTR_PREV, 1311da177e4SLinus Torvalds PROC_TGID_ATTR_EXEC, 1321da177e4SLinus Torvalds PROC_TGID_ATTR_FSCREATE, 1334eb582cfSMichael LeMay PROC_TGID_ATTR_KEYCREATE, 13442c3e03eSEric Paris PROC_TGID_ATTR_SOCKCREATE, 1351da177e4SLinus Torvalds #endif 1361da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 1371da177e4SLinus Torvalds PROC_TGID_LOGINUID, 1381da177e4SLinus Torvalds #endif 1391da177e4SLinus Torvalds PROC_TGID_OOM_SCORE, 1401da177e4SLinus Torvalds PROC_TGID_OOM_ADJUST, 1411da177e4SLinus Torvalds PROC_TID_INO, 1421da177e4SLinus Torvalds PROC_TID_STATUS, 1431da177e4SLinus Torvalds PROC_TID_MEM, 1441da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 1451da177e4SLinus Torvalds PROC_TID_SECCOMP, 1461da177e4SLinus Torvalds #endif 1471da177e4SLinus Torvalds PROC_TID_CWD, 1481da177e4SLinus Torvalds PROC_TID_ROOT, 1491da177e4SLinus Torvalds PROC_TID_EXE, 1501da177e4SLinus Torvalds PROC_TID_FD, 1511da177e4SLinus Torvalds PROC_TID_ENVIRON, 1521da177e4SLinus Torvalds PROC_TID_AUXV, 1531da177e4SLinus Torvalds PROC_TID_CMDLINE, 1541da177e4SLinus Torvalds PROC_TID_STAT, 1551da177e4SLinus Torvalds PROC_TID_STATM, 1561da177e4SLinus Torvalds PROC_TID_MAPS, 1576e21c8f1SChristoph Lameter PROC_TID_NUMA_MAPS, 1581da177e4SLinus Torvalds PROC_TID_MOUNTS, 159b4629fe2SChuck Lever PROC_TID_MOUNTSTATS, 1601da177e4SLinus Torvalds PROC_TID_WCHAN, 16163c6764cSYoshinori Sato #ifdef CONFIG_MMU 162e070ad49SMauricio Lin PROC_TID_SMAPS, 16363c6764cSYoshinori Sato #endif 1641da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 1651da177e4SLinus Torvalds PROC_TID_SCHEDSTAT, 1661da177e4SLinus Torvalds #endif 1671da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 1681da177e4SLinus Torvalds PROC_TID_CPUSET, 1691da177e4SLinus Torvalds #endif 1701da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 1711da177e4SLinus Torvalds PROC_TID_ATTR, 1721da177e4SLinus Torvalds PROC_TID_ATTR_CURRENT, 1731da177e4SLinus Torvalds PROC_TID_ATTR_PREV, 1741da177e4SLinus Torvalds PROC_TID_ATTR_EXEC, 1751da177e4SLinus Torvalds PROC_TID_ATTR_FSCREATE, 1764eb582cfSMichael LeMay PROC_TID_ATTR_KEYCREATE, 17742c3e03eSEric Paris PROC_TID_ATTR_SOCKCREATE, 1781da177e4SLinus Torvalds #endif 1791da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 1801da177e4SLinus Torvalds PROC_TID_LOGINUID, 1811da177e4SLinus Torvalds #endif 1821da177e4SLinus Torvalds PROC_TID_OOM_SCORE, 1831da177e4SLinus Torvalds PROC_TID_OOM_ADJUST, 1845e21ccb1SMiklos Szeredi 1855e21ccb1SMiklos Szeredi /* Add new entries before this */ 1865e21ccb1SMiklos Szeredi PROC_TID_FD_DIR = 0x8000, /* 0x8000-0xffff */ 1871da177e4SLinus Torvalds }; 1881da177e4SLinus Torvalds 1898578cea7SEric W. Biederman /* Worst case buffer size needed for holding an integer. */ 1908578cea7SEric W. Biederman #define PROC_NUMBUF 10 1918578cea7SEric W. Biederman 1921da177e4SLinus Torvalds struct pid_entry { 1931da177e4SLinus Torvalds int type; 1941da177e4SLinus Torvalds int len; 1951da177e4SLinus Torvalds char *name; 1961da177e4SLinus Torvalds mode_t mode; 1971da177e4SLinus Torvalds }; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds #define E(type,name,mode) {(type),sizeof(name)-1,(name),(mode)} 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds static struct pid_entry tgid_base_stuff[] = { 2021da177e4SLinus Torvalds E(PROC_TGID_TASK, "task", S_IFDIR|S_IRUGO|S_IXUGO), 2031da177e4SLinus Torvalds E(PROC_TGID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR), 2041da177e4SLinus Torvalds E(PROC_TGID_ENVIRON, "environ", S_IFREG|S_IRUSR), 2051da177e4SLinus Torvalds E(PROC_TGID_AUXV, "auxv", S_IFREG|S_IRUSR), 2061da177e4SLinus Torvalds E(PROC_TGID_STATUS, "status", S_IFREG|S_IRUGO), 2071da177e4SLinus Torvalds E(PROC_TGID_CMDLINE, "cmdline", S_IFREG|S_IRUGO), 2081da177e4SLinus Torvalds E(PROC_TGID_STAT, "stat", S_IFREG|S_IRUGO), 2091da177e4SLinus Torvalds E(PROC_TGID_STATM, "statm", S_IFREG|S_IRUGO), 2101da177e4SLinus Torvalds E(PROC_TGID_MAPS, "maps", S_IFREG|S_IRUGO), 2116e21c8f1SChristoph Lameter #ifdef CONFIG_NUMA 2126e21c8f1SChristoph Lameter E(PROC_TGID_NUMA_MAPS, "numa_maps", S_IFREG|S_IRUGO), 2136e21c8f1SChristoph Lameter #endif 2141da177e4SLinus Torvalds E(PROC_TGID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR), 2151da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 2161da177e4SLinus Torvalds E(PROC_TGID_SECCOMP, "seccomp", S_IFREG|S_IRUSR|S_IWUSR), 2171da177e4SLinus Torvalds #endif 2181da177e4SLinus Torvalds E(PROC_TGID_CWD, "cwd", S_IFLNK|S_IRWXUGO), 2191da177e4SLinus Torvalds E(PROC_TGID_ROOT, "root", S_IFLNK|S_IRWXUGO), 2201da177e4SLinus Torvalds E(PROC_TGID_EXE, "exe", S_IFLNK|S_IRWXUGO), 2211da177e4SLinus Torvalds E(PROC_TGID_MOUNTS, "mounts", S_IFREG|S_IRUGO), 222b4629fe2SChuck Lever E(PROC_TGID_MOUNTSTATS, "mountstats", S_IFREG|S_IRUSR), 22363c6764cSYoshinori Sato #ifdef CONFIG_MMU 224e070ad49SMauricio Lin E(PROC_TGID_SMAPS, "smaps", S_IFREG|S_IRUGO), 22563c6764cSYoshinori Sato #endif 2261da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 2271da177e4SLinus Torvalds E(PROC_TGID_ATTR, "attr", S_IFDIR|S_IRUGO|S_IXUGO), 2281da177e4SLinus Torvalds #endif 2291da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 2301da177e4SLinus Torvalds E(PROC_TGID_WCHAN, "wchan", S_IFREG|S_IRUGO), 2311da177e4SLinus Torvalds #endif 2321da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 2331da177e4SLinus Torvalds E(PROC_TGID_SCHEDSTAT, "schedstat", S_IFREG|S_IRUGO), 2341da177e4SLinus Torvalds #endif 2351da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 2361da177e4SLinus Torvalds E(PROC_TGID_CPUSET, "cpuset", S_IFREG|S_IRUGO), 2371da177e4SLinus Torvalds #endif 2381da177e4SLinus Torvalds E(PROC_TGID_OOM_SCORE, "oom_score",S_IFREG|S_IRUGO), 2391da177e4SLinus Torvalds E(PROC_TGID_OOM_ADJUST,"oom_adj", S_IFREG|S_IRUGO|S_IWUSR), 2401da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 2411da177e4SLinus Torvalds E(PROC_TGID_LOGINUID, "loginuid", S_IFREG|S_IWUSR|S_IRUGO), 2421da177e4SLinus Torvalds #endif 2431da177e4SLinus Torvalds {0,0,NULL,0} 2441da177e4SLinus Torvalds }; 2451da177e4SLinus Torvalds static struct pid_entry tid_base_stuff[] = { 2461da177e4SLinus Torvalds E(PROC_TID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR), 2471da177e4SLinus Torvalds E(PROC_TID_ENVIRON, "environ", S_IFREG|S_IRUSR), 2481da177e4SLinus Torvalds E(PROC_TID_AUXV, "auxv", S_IFREG|S_IRUSR), 2491da177e4SLinus Torvalds E(PROC_TID_STATUS, "status", S_IFREG|S_IRUGO), 2501da177e4SLinus Torvalds E(PROC_TID_CMDLINE, "cmdline", S_IFREG|S_IRUGO), 2511da177e4SLinus Torvalds E(PROC_TID_STAT, "stat", S_IFREG|S_IRUGO), 2521da177e4SLinus Torvalds E(PROC_TID_STATM, "statm", S_IFREG|S_IRUGO), 2531da177e4SLinus Torvalds E(PROC_TID_MAPS, "maps", S_IFREG|S_IRUGO), 2546e21c8f1SChristoph Lameter #ifdef CONFIG_NUMA 2556e21c8f1SChristoph Lameter E(PROC_TID_NUMA_MAPS, "numa_maps", S_IFREG|S_IRUGO), 2566e21c8f1SChristoph Lameter #endif 2571da177e4SLinus Torvalds E(PROC_TID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR), 2581da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 2591da177e4SLinus Torvalds E(PROC_TID_SECCOMP, "seccomp", S_IFREG|S_IRUSR|S_IWUSR), 2601da177e4SLinus Torvalds #endif 2611da177e4SLinus Torvalds E(PROC_TID_CWD, "cwd", S_IFLNK|S_IRWXUGO), 2621da177e4SLinus Torvalds E(PROC_TID_ROOT, "root", S_IFLNK|S_IRWXUGO), 2631da177e4SLinus Torvalds E(PROC_TID_EXE, "exe", S_IFLNK|S_IRWXUGO), 2641da177e4SLinus Torvalds E(PROC_TID_MOUNTS, "mounts", S_IFREG|S_IRUGO), 26563c6764cSYoshinori Sato #ifdef CONFIG_MMU 266e070ad49SMauricio Lin E(PROC_TID_SMAPS, "smaps", S_IFREG|S_IRUGO), 26763c6764cSYoshinori Sato #endif 2681da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 2691da177e4SLinus Torvalds E(PROC_TID_ATTR, "attr", S_IFDIR|S_IRUGO|S_IXUGO), 2701da177e4SLinus Torvalds #endif 2711da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 2721da177e4SLinus Torvalds E(PROC_TID_WCHAN, "wchan", S_IFREG|S_IRUGO), 2731da177e4SLinus Torvalds #endif 2741da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 2751da177e4SLinus Torvalds E(PROC_TID_SCHEDSTAT, "schedstat",S_IFREG|S_IRUGO), 2761da177e4SLinus Torvalds #endif 2771da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 2781da177e4SLinus Torvalds E(PROC_TID_CPUSET, "cpuset", S_IFREG|S_IRUGO), 2791da177e4SLinus Torvalds #endif 2801da177e4SLinus Torvalds E(PROC_TID_OOM_SCORE, "oom_score",S_IFREG|S_IRUGO), 2811da177e4SLinus Torvalds E(PROC_TID_OOM_ADJUST, "oom_adj", S_IFREG|S_IRUGO|S_IWUSR), 2821da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 2831da177e4SLinus Torvalds E(PROC_TID_LOGINUID, "loginuid", S_IFREG|S_IWUSR|S_IRUGO), 2841da177e4SLinus Torvalds #endif 2851da177e4SLinus Torvalds {0,0,NULL,0} 2861da177e4SLinus Torvalds }; 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 2891da177e4SLinus Torvalds static struct pid_entry tgid_attr_stuff[] = { 2901da177e4SLinus Torvalds E(PROC_TGID_ATTR_CURRENT, "current", S_IFREG|S_IRUGO|S_IWUGO), 2911da177e4SLinus Torvalds E(PROC_TGID_ATTR_PREV, "prev", S_IFREG|S_IRUGO), 2921da177e4SLinus Torvalds E(PROC_TGID_ATTR_EXEC, "exec", S_IFREG|S_IRUGO|S_IWUGO), 2931da177e4SLinus Torvalds E(PROC_TGID_ATTR_FSCREATE, "fscreate", S_IFREG|S_IRUGO|S_IWUGO), 2944eb582cfSMichael LeMay E(PROC_TGID_ATTR_KEYCREATE, "keycreate", S_IFREG|S_IRUGO|S_IWUGO), 29542c3e03eSEric Paris E(PROC_TGID_ATTR_SOCKCREATE, "sockcreate", S_IFREG|S_IRUGO|S_IWUGO), 2961da177e4SLinus Torvalds {0,0,NULL,0} 2971da177e4SLinus Torvalds }; 2981da177e4SLinus Torvalds static struct pid_entry tid_attr_stuff[] = { 2991da177e4SLinus Torvalds E(PROC_TID_ATTR_CURRENT, "current", S_IFREG|S_IRUGO|S_IWUGO), 3001da177e4SLinus Torvalds E(PROC_TID_ATTR_PREV, "prev", S_IFREG|S_IRUGO), 3011da177e4SLinus Torvalds E(PROC_TID_ATTR_EXEC, "exec", S_IFREG|S_IRUGO|S_IWUGO), 3021da177e4SLinus Torvalds E(PROC_TID_ATTR_FSCREATE, "fscreate", S_IFREG|S_IRUGO|S_IWUGO), 3034eb582cfSMichael LeMay E(PROC_TID_ATTR_KEYCREATE, "keycreate", S_IFREG|S_IRUGO|S_IWUGO), 30442c3e03eSEric Paris E(PROC_TID_ATTR_SOCKCREATE, "sockcreate", S_IFREG|S_IRUGO|S_IWUGO), 3051da177e4SLinus Torvalds {0,0,NULL,0} 3061da177e4SLinus Torvalds }; 3071da177e4SLinus Torvalds #endif 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds #undef E 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt) 3121da177e4SLinus Torvalds { 31399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 31499f89551SEric W. Biederman struct files_struct *files = NULL; 3151da177e4SLinus Torvalds struct file *file; 316aed7a6c4SEric W. Biederman int fd = proc_fd(inode); 3171da177e4SLinus Torvalds 31899f89551SEric W. Biederman if (task) { 3191da177e4SLinus Torvalds files = get_files_struct(task); 32099f89551SEric W. Biederman put_task_struct(task); 32199f89551SEric W. Biederman } 3221da177e4SLinus Torvalds if (files) { 323ca99c1daSDipankar Sarma /* 324ca99c1daSDipankar Sarma * We are not taking a ref to the file structure, so we must 325ca99c1daSDipankar Sarma * hold ->file_lock. 326ca99c1daSDipankar Sarma */ 327ca99c1daSDipankar Sarma spin_lock(&files->file_lock); 3281da177e4SLinus Torvalds file = fcheck_files(files, fd); 3291da177e4SLinus Torvalds if (file) { 3301da177e4SLinus Torvalds *mnt = mntget(file->f_vfsmnt); 3311da177e4SLinus Torvalds *dentry = dget(file->f_dentry); 332ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 3331da177e4SLinus Torvalds put_files_struct(files); 3341da177e4SLinus Torvalds return 0; 3351da177e4SLinus Torvalds } 336ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 3371da177e4SLinus Torvalds put_files_struct(files); 3381da177e4SLinus Torvalds } 3391da177e4SLinus Torvalds return -ENOENT; 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 3420494f6ecSMiklos Szeredi static struct fs_struct *get_fs_struct(struct task_struct *task) 3431da177e4SLinus Torvalds { 3441da177e4SLinus Torvalds struct fs_struct *fs; 3450494f6ecSMiklos Szeredi task_lock(task); 3460494f6ecSMiklos Szeredi fs = task->fs; 3471da177e4SLinus Torvalds if(fs) 3481da177e4SLinus Torvalds atomic_inc(&fs->count); 3490494f6ecSMiklos Szeredi task_unlock(task); 3500494f6ecSMiklos Szeredi return fs; 3510494f6ecSMiklos Szeredi } 3520494f6ecSMiklos Szeredi 35399f89551SEric W. Biederman static int get_nr_threads(struct task_struct *tsk) 35499f89551SEric W. Biederman { 35599f89551SEric W. Biederman /* Must be called with the rcu_read_lock held */ 35699f89551SEric W. Biederman unsigned long flags; 35799f89551SEric W. Biederman int count = 0; 35899f89551SEric W. Biederman 35999f89551SEric W. Biederman if (lock_task_sighand(tsk, &flags)) { 36099f89551SEric W. Biederman count = atomic_read(&tsk->signal->count); 36199f89551SEric W. Biederman unlock_task_sighand(tsk, &flags); 36299f89551SEric W. Biederman } 36399f89551SEric W. Biederman return count; 36499f89551SEric W. Biederman } 36599f89551SEric W. Biederman 3660494f6ecSMiklos Szeredi static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt) 3670494f6ecSMiklos Szeredi { 36899f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 36999f89551SEric W. Biederman struct fs_struct *fs = NULL; 3700494f6ecSMiklos Szeredi int result = -ENOENT; 37199f89551SEric W. Biederman 37299f89551SEric W. Biederman if (task) { 37399f89551SEric W. Biederman fs = get_fs_struct(task); 37499f89551SEric W. Biederman put_task_struct(task); 37599f89551SEric W. Biederman } 3761da177e4SLinus Torvalds if (fs) { 3771da177e4SLinus Torvalds read_lock(&fs->lock); 3781da177e4SLinus Torvalds *mnt = mntget(fs->pwdmnt); 3791da177e4SLinus Torvalds *dentry = dget(fs->pwd); 3801da177e4SLinus Torvalds read_unlock(&fs->lock); 3811da177e4SLinus Torvalds result = 0; 3821da177e4SLinus Torvalds put_fs_struct(fs); 3831da177e4SLinus Torvalds } 3841da177e4SLinus Torvalds return result; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt) 3881da177e4SLinus Torvalds { 38999f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 39099f89551SEric W. Biederman struct fs_struct *fs = NULL; 3911da177e4SLinus Torvalds int result = -ENOENT; 39299f89551SEric W. Biederman 39399f89551SEric W. Biederman if (task) { 39499f89551SEric W. Biederman fs = get_fs_struct(task); 39599f89551SEric W. Biederman put_task_struct(task); 39699f89551SEric W. Biederman } 3971da177e4SLinus Torvalds if (fs) { 3981da177e4SLinus Torvalds read_lock(&fs->lock); 3991da177e4SLinus Torvalds *mnt = mntget(fs->rootmnt); 4001da177e4SLinus Torvalds *dentry = dget(fs->root); 4011da177e4SLinus Torvalds read_unlock(&fs->lock); 4021da177e4SLinus Torvalds result = 0; 4031da177e4SLinus Torvalds put_fs_struct(fs); 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds return result; 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds #define MAY_PTRACE(task) \ 4091da177e4SLinus Torvalds (task == current || \ 4101da177e4SLinus Torvalds (task->parent == current && \ 4111da177e4SLinus Torvalds (task->ptrace & PT_PTRACED) && \ 4121da177e4SLinus Torvalds (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \ 4131da177e4SLinus Torvalds security_ptrace(current,task) == 0)) 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds static int proc_pid_environ(struct task_struct *task, char * buffer) 4161da177e4SLinus Torvalds { 4171da177e4SLinus Torvalds int res = 0; 4181da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 4191da177e4SLinus Torvalds if (mm) { 4201da177e4SLinus Torvalds unsigned int len = mm->env_end - mm->env_start; 4211da177e4SLinus Torvalds if (len > PAGE_SIZE) 4221da177e4SLinus Torvalds len = PAGE_SIZE; 4231da177e4SLinus Torvalds res = access_process_vm(task, mm->env_start, buffer, len, 0); 424ab8d11beSMiklos Szeredi if (!ptrace_may_attach(task)) 4251da177e4SLinus Torvalds res = -ESRCH; 4261da177e4SLinus Torvalds mmput(mm); 4271da177e4SLinus Torvalds } 4281da177e4SLinus Torvalds return res; 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds static int proc_pid_cmdline(struct task_struct *task, char * buffer) 4321da177e4SLinus Torvalds { 4331da177e4SLinus Torvalds int res = 0; 4341da177e4SLinus Torvalds unsigned int len; 4351da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 4361da177e4SLinus Torvalds if (!mm) 4371da177e4SLinus Torvalds goto out; 4381da177e4SLinus Torvalds if (!mm->arg_end) 4391da177e4SLinus Torvalds goto out_mm; /* Shh! No looking before we're done */ 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds len = mm->arg_end - mm->arg_start; 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds if (len > PAGE_SIZE) 4441da177e4SLinus Torvalds len = PAGE_SIZE; 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds res = access_process_vm(task, mm->arg_start, buffer, len, 0); 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds // If the nul at the end of args has been overwritten, then 4491da177e4SLinus Torvalds // assume application is using setproctitle(3). 4501da177e4SLinus Torvalds if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) { 4511da177e4SLinus Torvalds len = strnlen(buffer, res); 4521da177e4SLinus Torvalds if (len < res) { 4531da177e4SLinus Torvalds res = len; 4541da177e4SLinus Torvalds } else { 4551da177e4SLinus Torvalds len = mm->env_end - mm->env_start; 4561da177e4SLinus Torvalds if (len > PAGE_SIZE - res) 4571da177e4SLinus Torvalds len = PAGE_SIZE - res; 4581da177e4SLinus Torvalds res += access_process_vm(task, mm->env_start, buffer+res, len, 0); 4591da177e4SLinus Torvalds res = strnlen(buffer, res); 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds out_mm: 4631da177e4SLinus Torvalds mmput(mm); 4641da177e4SLinus Torvalds out: 4651da177e4SLinus Torvalds return res; 4661da177e4SLinus Torvalds } 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds static int proc_pid_auxv(struct task_struct *task, char *buffer) 4691da177e4SLinus Torvalds { 4701da177e4SLinus Torvalds int res = 0; 4711da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 4721da177e4SLinus Torvalds if (mm) { 4731da177e4SLinus Torvalds unsigned int nwords = 0; 4741da177e4SLinus Torvalds do 4751da177e4SLinus Torvalds nwords += 2; 4761da177e4SLinus Torvalds while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 4771da177e4SLinus Torvalds res = nwords * sizeof(mm->saved_auxv[0]); 4781da177e4SLinus Torvalds if (res > PAGE_SIZE) 4791da177e4SLinus Torvalds res = PAGE_SIZE; 4801da177e4SLinus Torvalds memcpy(buffer, mm->saved_auxv, res); 4811da177e4SLinus Torvalds mmput(mm); 4821da177e4SLinus Torvalds } 4831da177e4SLinus Torvalds return res; 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 4881da177e4SLinus Torvalds /* 4891da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 4901da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 4911da177e4SLinus Torvalds */ 4921da177e4SLinus Torvalds static int proc_pid_wchan(struct task_struct *task, char *buffer) 4931da177e4SLinus Torvalds { 4941da177e4SLinus Torvalds char *modname; 4951da177e4SLinus Torvalds const char *sym_name; 4961da177e4SLinus Torvalds unsigned long wchan, size, offset; 4971da177e4SLinus Torvalds char namebuf[KSYM_NAME_LEN+1]; 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds wchan = get_wchan(task); 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds sym_name = kallsyms_lookup(wchan, &size, &offset, &modname, namebuf); 5021da177e4SLinus Torvalds if (sym_name) 5031da177e4SLinus Torvalds return sprintf(buffer, "%s", sym_name); 5041da177e4SLinus Torvalds return sprintf(buffer, "%lu", wchan); 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 5091da177e4SLinus Torvalds /* 5101da177e4SLinus Torvalds * Provides /proc/PID/schedstat 5111da177e4SLinus Torvalds */ 5121da177e4SLinus Torvalds static int proc_pid_schedstat(struct task_struct *task, char *buffer) 5131da177e4SLinus Torvalds { 5141da177e4SLinus Torvalds return sprintf(buffer, "%lu %lu %lu\n", 5151da177e4SLinus Torvalds task->sched_info.cpu_time, 5161da177e4SLinus Torvalds task->sched_info.run_delay, 5171da177e4SLinus Torvalds task->sched_info.pcnt); 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds #endif 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds /* The badness from the OOM killer */ 5221da177e4SLinus Torvalds unsigned long badness(struct task_struct *p, unsigned long uptime); 5231da177e4SLinus Torvalds static int proc_oom_score(struct task_struct *task, char *buffer) 5241da177e4SLinus Torvalds { 5251da177e4SLinus Torvalds unsigned long points; 5261da177e4SLinus Torvalds struct timespec uptime; 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds do_posix_clock_monotonic_gettime(&uptime); 5291da177e4SLinus Torvalds points = badness(task, uptime.tv_sec); 5301da177e4SLinus Torvalds return sprintf(buffer, "%lu\n", points); 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds /************************************************************************/ 5341da177e4SLinus Torvalds /* Here the fs part begins */ 5351da177e4SLinus Torvalds /************************************************************************/ 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds /* permission checks */ 538778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 5391da177e4SLinus Torvalds { 540778c1144SEric W. Biederman struct task_struct *task; 541778c1144SEric W. Biederman int allowed = 0; 542df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 543df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 544df26c40eSEric W. Biederman * information. 545778c1144SEric W. Biederman */ 546778c1144SEric W. Biederman task = get_proc_task(inode); 547df26c40eSEric W. Biederman if (task) { 548778c1144SEric W. Biederman allowed = ptrace_may_attach(task); 549778c1144SEric W. Biederman put_task_struct(task); 550df26c40eSEric W. Biederman } 551778c1144SEric W. Biederman return allowed; 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 554*6d76fa58SLinus Torvalds static int proc_setattr(struct dentry *dentry, struct iattr *attr) 555*6d76fa58SLinus Torvalds { 556*6d76fa58SLinus Torvalds int error; 557*6d76fa58SLinus Torvalds struct inode *inode = dentry->d_inode; 558*6d76fa58SLinus Torvalds 559*6d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 560*6d76fa58SLinus Torvalds return -EPERM; 561*6d76fa58SLinus Torvalds 562*6d76fa58SLinus Torvalds error = inode_change_ok(inode, attr); 563*6d76fa58SLinus Torvalds if (!error) { 564*6d76fa58SLinus Torvalds error = security_inode_setattr(dentry, attr); 565*6d76fa58SLinus Torvalds if (!error) 566*6d76fa58SLinus Torvalds error = inode_setattr(inode, attr); 567*6d76fa58SLinus Torvalds } 568*6d76fa58SLinus Torvalds return error; 569*6d76fa58SLinus Torvalds } 570*6d76fa58SLinus Torvalds 571*6d76fa58SLinus Torvalds static struct inode_operations proc_def_inode_operations = { 572*6d76fa58SLinus Torvalds .setattr = proc_setattr, 573*6d76fa58SLinus Torvalds }; 574*6d76fa58SLinus Torvalds 5751da177e4SLinus Torvalds extern struct seq_operations mounts_op; 5765addc5ddSAl Viro struct proc_mounts { 5775addc5ddSAl Viro struct seq_file m; 5785addc5ddSAl Viro int event; 5795addc5ddSAl Viro }; 5805addc5ddSAl Viro 5811da177e4SLinus Torvalds static int mounts_open(struct inode *inode, struct file *file) 5821da177e4SLinus Torvalds { 58399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 58499f89551SEric W. Biederman struct namespace *namespace = NULL; 5855addc5ddSAl Viro struct proc_mounts *p; 5865addc5ddSAl Viro int ret = -EINVAL; 5875addc5ddSAl Viro 58899f89551SEric W. Biederman if (task) { 5891da177e4SLinus Torvalds task_lock(task); 5901da177e4SLinus Torvalds namespace = task->namespace; 5911da177e4SLinus Torvalds if (namespace) 5921da177e4SLinus Torvalds get_namespace(namespace); 5931da177e4SLinus Torvalds task_unlock(task); 59499f89551SEric W. Biederman put_task_struct(task); 59599f89551SEric W. Biederman } 5961da177e4SLinus Torvalds 5975addc5ddSAl Viro if (namespace) { 5985addc5ddSAl Viro ret = -ENOMEM; 5995addc5ddSAl Viro p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); 6005addc5ddSAl Viro if (p) { 6015addc5ddSAl Viro file->private_data = &p->m; 6025addc5ddSAl Viro ret = seq_open(file, &mounts_op); 6035addc5ddSAl Viro if (!ret) { 6045addc5ddSAl Viro p->m.private = namespace; 6055addc5ddSAl Viro p->event = namespace->event; 6065addc5ddSAl Viro return 0; 6071da177e4SLinus Torvalds } 6085addc5ddSAl Viro kfree(p); 6095addc5ddSAl Viro } 6105addc5ddSAl Viro put_namespace(namespace); 6111da177e4SLinus Torvalds } 6121da177e4SLinus Torvalds return ret; 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds static int mounts_release(struct inode *inode, struct file *file) 6161da177e4SLinus Torvalds { 6171da177e4SLinus Torvalds struct seq_file *m = file->private_data; 6181da177e4SLinus Torvalds struct namespace *namespace = m->private; 6191da177e4SLinus Torvalds put_namespace(namespace); 6201da177e4SLinus Torvalds return seq_release(inode, file); 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds 6235addc5ddSAl Viro static unsigned mounts_poll(struct file *file, poll_table *wait) 6245addc5ddSAl Viro { 6255addc5ddSAl Viro struct proc_mounts *p = file->private_data; 6265addc5ddSAl Viro struct namespace *ns = p->m.private; 6275addc5ddSAl Viro unsigned res = 0; 6285addc5ddSAl Viro 6295addc5ddSAl Viro poll_wait(file, &ns->poll, wait); 6305addc5ddSAl Viro 6315addc5ddSAl Viro spin_lock(&vfsmount_lock); 6325addc5ddSAl Viro if (p->event != ns->event) { 6335addc5ddSAl Viro p->event = ns->event; 6345addc5ddSAl Viro res = POLLERR; 6355addc5ddSAl Viro } 6365addc5ddSAl Viro spin_unlock(&vfsmount_lock); 6375addc5ddSAl Viro 6385addc5ddSAl Viro return res; 6395addc5ddSAl Viro } 6405addc5ddSAl Viro 6411da177e4SLinus Torvalds static struct file_operations proc_mounts_operations = { 6421da177e4SLinus Torvalds .open = mounts_open, 6431da177e4SLinus Torvalds .read = seq_read, 6441da177e4SLinus Torvalds .llseek = seq_lseek, 6451da177e4SLinus Torvalds .release = mounts_release, 6465addc5ddSAl Viro .poll = mounts_poll, 6471da177e4SLinus Torvalds }; 6481da177e4SLinus Torvalds 649b4629fe2SChuck Lever extern struct seq_operations mountstats_op; 650b4629fe2SChuck Lever static int mountstats_open(struct inode *inode, struct file *file) 651b4629fe2SChuck Lever { 652b4629fe2SChuck Lever int ret = seq_open(file, &mountstats_op); 653b4629fe2SChuck Lever 654b4629fe2SChuck Lever if (!ret) { 655b4629fe2SChuck Lever struct seq_file *m = file->private_data; 65699f89551SEric W. Biederman struct namespace *namespace = NULL; 65799f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 65899f89551SEric W. Biederman 65999f89551SEric W. Biederman if (task) { 660b4629fe2SChuck Lever task_lock(task); 661b4629fe2SChuck Lever namespace = task->namespace; 662b4629fe2SChuck Lever if (namespace) 663b4629fe2SChuck Lever get_namespace(namespace); 664b4629fe2SChuck Lever task_unlock(task); 66599f89551SEric W. Biederman put_task_struct(task); 66699f89551SEric W. Biederman } 667b4629fe2SChuck Lever 668b4629fe2SChuck Lever if (namespace) 669b4629fe2SChuck Lever m->private = namespace; 670b4629fe2SChuck Lever else { 671b4629fe2SChuck Lever seq_release(inode, file); 672b4629fe2SChuck Lever ret = -EINVAL; 673b4629fe2SChuck Lever } 674b4629fe2SChuck Lever } 675b4629fe2SChuck Lever return ret; 676b4629fe2SChuck Lever } 677b4629fe2SChuck Lever 678b4629fe2SChuck Lever static struct file_operations proc_mountstats_operations = { 679b4629fe2SChuck Lever .open = mountstats_open, 680b4629fe2SChuck Lever .read = seq_read, 681b4629fe2SChuck Lever .llseek = seq_lseek, 682b4629fe2SChuck Lever .release = mounts_release, 683b4629fe2SChuck Lever }; 684b4629fe2SChuck Lever 6851da177e4SLinus Torvalds #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */ 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds static ssize_t proc_info_read(struct file * file, char __user * buf, 6881da177e4SLinus Torvalds size_t count, loff_t *ppos) 6891da177e4SLinus Torvalds { 6901da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 6911da177e4SLinus Torvalds unsigned long page; 6921da177e4SLinus Torvalds ssize_t length; 69399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 69499f89551SEric W. Biederman 69599f89551SEric W. Biederman length = -ESRCH; 69699f89551SEric W. Biederman if (!task) 69799f89551SEric W. Biederman goto out_no_task; 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds if (count > PROC_BLOCK_SIZE) 7001da177e4SLinus Torvalds count = PROC_BLOCK_SIZE; 70199f89551SEric W. Biederman 70299f89551SEric W. Biederman length = -ENOMEM; 7031da177e4SLinus Torvalds if (!(page = __get_free_page(GFP_KERNEL))) 70499f89551SEric W. Biederman goto out; 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds length = PROC_I(inode)->op.proc_read(task, (char*)page); 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds if (length >= 0) 7091da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 7101da177e4SLinus Torvalds free_page(page); 71199f89551SEric W. Biederman out: 71299f89551SEric W. Biederman put_task_struct(task); 71399f89551SEric W. Biederman out_no_task: 7141da177e4SLinus Torvalds return length; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds static struct file_operations proc_info_file_operations = { 7181da177e4SLinus Torvalds .read = proc_info_read, 7191da177e4SLinus Torvalds }; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds static int mem_open(struct inode* inode, struct file* file) 7221da177e4SLinus Torvalds { 7231da177e4SLinus Torvalds file->private_data = (void*)((long)current->self_exec_id); 7241da177e4SLinus Torvalds return 0; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds static ssize_t mem_read(struct file * file, char __user * buf, 7281da177e4SLinus Torvalds size_t count, loff_t *ppos) 7291da177e4SLinus Torvalds { 73099f89551SEric W. Biederman struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 7311da177e4SLinus Torvalds char *page; 7321da177e4SLinus Torvalds unsigned long src = *ppos; 7331da177e4SLinus Torvalds int ret = -ESRCH; 7341da177e4SLinus Torvalds struct mm_struct *mm; 7351da177e4SLinus Torvalds 73699f89551SEric W. Biederman if (!task) 73799f89551SEric W. Biederman goto out_no_task; 73899f89551SEric W. Biederman 739ab8d11beSMiklos Szeredi if (!MAY_PTRACE(task) || !ptrace_may_attach(task)) 7401da177e4SLinus Torvalds goto out; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds ret = -ENOMEM; 7431da177e4SLinus Torvalds page = (char *)__get_free_page(GFP_USER); 7441da177e4SLinus Torvalds if (!page) 7451da177e4SLinus Torvalds goto out; 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds ret = 0; 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds mm = get_task_mm(task); 7501da177e4SLinus Torvalds if (!mm) 7511da177e4SLinus Torvalds goto out_free; 7521da177e4SLinus Torvalds 7531da177e4SLinus Torvalds ret = -EIO; 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds if (file->private_data != (void*)((long)current->self_exec_id)) 7561da177e4SLinus Torvalds goto out_put; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds ret = 0; 7591da177e4SLinus Torvalds 7601da177e4SLinus Torvalds while (count > 0) { 7611da177e4SLinus Torvalds int this_len, retval; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 7641da177e4SLinus Torvalds retval = access_process_vm(task, src, page, this_len, 0); 765ab8d11beSMiklos Szeredi if (!retval || !MAY_PTRACE(task) || !ptrace_may_attach(task)) { 7661da177e4SLinus Torvalds if (!ret) 7671da177e4SLinus Torvalds ret = -EIO; 7681da177e4SLinus Torvalds break; 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds if (copy_to_user(buf, page, retval)) { 7721da177e4SLinus Torvalds ret = -EFAULT; 7731da177e4SLinus Torvalds break; 7741da177e4SLinus Torvalds } 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds ret += retval; 7771da177e4SLinus Torvalds src += retval; 7781da177e4SLinus Torvalds buf += retval; 7791da177e4SLinus Torvalds count -= retval; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds *ppos = src; 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds out_put: 7841da177e4SLinus Torvalds mmput(mm); 7851da177e4SLinus Torvalds out_free: 7861da177e4SLinus Torvalds free_page((unsigned long) page); 7871da177e4SLinus Torvalds out: 78899f89551SEric W. Biederman put_task_struct(task); 78999f89551SEric W. Biederman out_no_task: 7901da177e4SLinus Torvalds return ret; 7911da177e4SLinus Torvalds } 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds #define mem_write NULL 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds #ifndef mem_write 7961da177e4SLinus Torvalds /* This is a security hazard */ 7971da177e4SLinus Torvalds static ssize_t mem_write(struct file * file, const char * buf, 7981da177e4SLinus Torvalds size_t count, loff_t *ppos) 7991da177e4SLinus Torvalds { 8001da177e4SLinus Torvalds int copied = 0; 8011da177e4SLinus Torvalds char *page; 80299f89551SEric W. Biederman struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 8031da177e4SLinus Torvalds unsigned long dst = *ppos; 8041da177e4SLinus Torvalds 80599f89551SEric W. Biederman copied = -ESRCH; 80699f89551SEric W. Biederman if (!task) 80799f89551SEric W. Biederman goto out_no_task; 8081da177e4SLinus Torvalds 80999f89551SEric W. Biederman if (!MAY_PTRACE(task) || !ptrace_may_attach(task)) 81099f89551SEric W. Biederman goto out; 81199f89551SEric W. Biederman 81299f89551SEric W. Biederman copied = -ENOMEM; 8131da177e4SLinus Torvalds page = (char *)__get_free_page(GFP_USER); 8141da177e4SLinus Torvalds if (!page) 81599f89551SEric W. Biederman goto out; 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds while (count > 0) { 8181da177e4SLinus Torvalds int this_len, retval; 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 8211da177e4SLinus Torvalds if (copy_from_user(page, buf, this_len)) { 8221da177e4SLinus Torvalds copied = -EFAULT; 8231da177e4SLinus Torvalds break; 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds retval = access_process_vm(task, dst, page, this_len, 1); 8261da177e4SLinus Torvalds if (!retval) { 8271da177e4SLinus Torvalds if (!copied) 8281da177e4SLinus Torvalds copied = -EIO; 8291da177e4SLinus Torvalds break; 8301da177e4SLinus Torvalds } 8311da177e4SLinus Torvalds copied += retval; 8321da177e4SLinus Torvalds buf += retval; 8331da177e4SLinus Torvalds dst += retval; 8341da177e4SLinus Torvalds count -= retval; 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds *ppos = dst; 8371da177e4SLinus Torvalds free_page((unsigned long) page); 83899f89551SEric W. Biederman out: 83999f89551SEric W. Biederman put_task_struct(task); 84099f89551SEric W. Biederman out_no_task: 8411da177e4SLinus Torvalds return copied; 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds #endif 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds static loff_t mem_lseek(struct file * file, loff_t offset, int orig) 8461da177e4SLinus Torvalds { 8471da177e4SLinus Torvalds switch (orig) { 8481da177e4SLinus Torvalds case 0: 8491da177e4SLinus Torvalds file->f_pos = offset; 8501da177e4SLinus Torvalds break; 8511da177e4SLinus Torvalds case 1: 8521da177e4SLinus Torvalds file->f_pos += offset; 8531da177e4SLinus Torvalds break; 8541da177e4SLinus Torvalds default: 8551da177e4SLinus Torvalds return -EINVAL; 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds force_successful_syscall_return(); 8581da177e4SLinus Torvalds return file->f_pos; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds static struct file_operations proc_mem_operations = { 8621da177e4SLinus Torvalds .llseek = mem_lseek, 8631da177e4SLinus Torvalds .read = mem_read, 8641da177e4SLinus Torvalds .write = mem_write, 8651da177e4SLinus Torvalds .open = mem_open, 8661da177e4SLinus Torvalds }; 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds static ssize_t oom_adjust_read(struct file *file, char __user *buf, 8691da177e4SLinus Torvalds size_t count, loff_t *ppos) 8701da177e4SLinus Torvalds { 87199f89551SEric W. Biederman struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 8728578cea7SEric W. Biederman char buffer[PROC_NUMBUF]; 8731da177e4SLinus Torvalds size_t len; 87499f89551SEric W. Biederman int oom_adjust; 8751da177e4SLinus Torvalds loff_t __ppos = *ppos; 8761da177e4SLinus Torvalds 87799f89551SEric W. Biederman if (!task) 87899f89551SEric W. Biederman return -ESRCH; 87999f89551SEric W. Biederman oom_adjust = task->oomkilladj; 88099f89551SEric W. Biederman put_task_struct(task); 88199f89551SEric W. Biederman 8828578cea7SEric W. Biederman len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust); 8831da177e4SLinus Torvalds if (__ppos >= len) 8841da177e4SLinus Torvalds return 0; 8851da177e4SLinus Torvalds if (count > len-__ppos) 8861da177e4SLinus Torvalds count = len-__ppos; 8871da177e4SLinus Torvalds if (copy_to_user(buf, buffer + __ppos, count)) 8881da177e4SLinus Torvalds return -EFAULT; 8891da177e4SLinus Torvalds *ppos = __ppos + count; 8901da177e4SLinus Torvalds return count; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds static ssize_t oom_adjust_write(struct file *file, const char __user *buf, 8941da177e4SLinus Torvalds size_t count, loff_t *ppos) 8951da177e4SLinus Torvalds { 89699f89551SEric W. Biederman struct task_struct *task; 8978578cea7SEric W. Biederman char buffer[PROC_NUMBUF], *end; 8981da177e4SLinus Torvalds int oom_adjust; 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds if (!capable(CAP_SYS_RESOURCE)) 9011da177e4SLinus Torvalds return -EPERM; 9028578cea7SEric W. Biederman memset(buffer, 0, sizeof(buffer)); 9038578cea7SEric W. Biederman if (count > sizeof(buffer) - 1) 9048578cea7SEric W. Biederman count = sizeof(buffer) - 1; 9051da177e4SLinus Torvalds if (copy_from_user(buffer, buf, count)) 9061da177e4SLinus Torvalds return -EFAULT; 9071da177e4SLinus Torvalds oom_adjust = simple_strtol(buffer, &end, 0); 90879befd0cSAndrea Arcangeli if ((oom_adjust < -16 || oom_adjust > 15) && oom_adjust != OOM_DISABLE) 9091da177e4SLinus Torvalds return -EINVAL; 9101da177e4SLinus Torvalds if (*end == '\n') 9111da177e4SLinus Torvalds end++; 91299f89551SEric W. Biederman task = get_proc_task(file->f_dentry->d_inode); 91399f89551SEric W. Biederman if (!task) 91499f89551SEric W. Biederman return -ESRCH; 9151da177e4SLinus Torvalds task->oomkilladj = oom_adjust; 91699f89551SEric W. Biederman put_task_struct(task); 9171da177e4SLinus Torvalds if (end - buffer == 0) 9181da177e4SLinus Torvalds return -EIO; 9191da177e4SLinus Torvalds return end - buffer; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds static struct file_operations proc_oom_adjust_operations = { 9231da177e4SLinus Torvalds .read = oom_adjust_read, 9241da177e4SLinus Torvalds .write = oom_adjust_write, 9251da177e4SLinus Torvalds }; 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 9281da177e4SLinus Torvalds #define TMPBUFLEN 21 9291da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 9301da177e4SLinus Torvalds size_t count, loff_t *ppos) 9311da177e4SLinus Torvalds { 9321da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 93399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 9341da177e4SLinus Torvalds ssize_t length; 9351da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 9361da177e4SLinus Torvalds 93799f89551SEric W. Biederman if (!task) 93899f89551SEric W. Biederman return -ESRCH; 9391da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 9401da177e4SLinus Torvalds audit_get_loginuid(task->audit_context)); 94199f89551SEric W. Biederman put_task_struct(task); 9421da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 9461da177e4SLinus Torvalds size_t count, loff_t *ppos) 9471da177e4SLinus Torvalds { 9481da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 9491da177e4SLinus Torvalds char *page, *tmp; 9501da177e4SLinus Torvalds ssize_t length; 9511da177e4SLinus Torvalds uid_t loginuid; 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds if (!capable(CAP_AUDIT_CONTROL)) 9541da177e4SLinus Torvalds return -EPERM; 9551da177e4SLinus Torvalds 95613b41b09SEric W. Biederman if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) 9571da177e4SLinus Torvalds return -EPERM; 9581da177e4SLinus Torvalds 959e0182909SAl Viro if (count >= PAGE_SIZE) 960e0182909SAl Viro count = PAGE_SIZE - 1; 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds if (*ppos != 0) { 9631da177e4SLinus Torvalds /* No partial writes. */ 9641da177e4SLinus Torvalds return -EINVAL; 9651da177e4SLinus Torvalds } 9661da177e4SLinus Torvalds page = (char*)__get_free_page(GFP_USER); 9671da177e4SLinus Torvalds if (!page) 9681da177e4SLinus Torvalds return -ENOMEM; 9691da177e4SLinus Torvalds length = -EFAULT; 9701da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 9711da177e4SLinus Torvalds goto out_free_page; 9721da177e4SLinus Torvalds 973e0182909SAl Viro page[count] = '\0'; 9741da177e4SLinus Torvalds loginuid = simple_strtoul(page, &tmp, 10); 9751da177e4SLinus Torvalds if (tmp == page) { 9761da177e4SLinus Torvalds length = -EINVAL; 9771da177e4SLinus Torvalds goto out_free_page; 9781da177e4SLinus Torvalds 9791da177e4SLinus Torvalds } 98099f89551SEric W. Biederman length = audit_set_loginuid(current, loginuid); 9811da177e4SLinus Torvalds if (likely(length == 0)) 9821da177e4SLinus Torvalds length = count; 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds out_free_page: 9851da177e4SLinus Torvalds free_page((unsigned long) page); 9861da177e4SLinus Torvalds return length; 9871da177e4SLinus Torvalds } 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds static struct file_operations proc_loginuid_operations = { 9901da177e4SLinus Torvalds .read = proc_loginuid_read, 9911da177e4SLinus Torvalds .write = proc_loginuid_write, 9921da177e4SLinus Torvalds }; 9931da177e4SLinus Torvalds #endif 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 9961da177e4SLinus Torvalds static ssize_t seccomp_read(struct file *file, char __user *buf, 9971da177e4SLinus Torvalds size_t count, loff_t *ppos) 9981da177e4SLinus Torvalds { 99999f89551SEric W. Biederman struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode); 10001da177e4SLinus Torvalds char __buf[20]; 10011da177e4SLinus Torvalds loff_t __ppos = *ppos; 10021da177e4SLinus Torvalds size_t len; 10031da177e4SLinus Torvalds 100499f89551SEric W. Biederman if (!tsk) 100599f89551SEric W. Biederman return -ESRCH; 10061da177e4SLinus Torvalds /* no need to print the trailing zero, so use only len */ 10071da177e4SLinus Torvalds len = sprintf(__buf, "%u\n", tsk->seccomp.mode); 100899f89551SEric W. Biederman put_task_struct(tsk); 10091da177e4SLinus Torvalds if (__ppos >= len) 10101da177e4SLinus Torvalds return 0; 10111da177e4SLinus Torvalds if (count > len - __ppos) 10121da177e4SLinus Torvalds count = len - __ppos; 10131da177e4SLinus Torvalds if (copy_to_user(buf, __buf + __ppos, count)) 10141da177e4SLinus Torvalds return -EFAULT; 10151da177e4SLinus Torvalds *ppos = __ppos + count; 10161da177e4SLinus Torvalds return count; 10171da177e4SLinus Torvalds } 10181da177e4SLinus Torvalds 10191da177e4SLinus Torvalds static ssize_t seccomp_write(struct file *file, const char __user *buf, 10201da177e4SLinus Torvalds size_t count, loff_t *ppos) 10211da177e4SLinus Torvalds { 102299f89551SEric W. Biederman struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode); 10231da177e4SLinus Torvalds char __buf[20], *end; 10241da177e4SLinus Torvalds unsigned int seccomp_mode; 102599f89551SEric W. Biederman ssize_t result; 102699f89551SEric W. Biederman 102799f89551SEric W. Biederman result = -ESRCH; 102899f89551SEric W. Biederman if (!tsk) 102999f89551SEric W. Biederman goto out_no_task; 10301da177e4SLinus Torvalds 10311da177e4SLinus Torvalds /* can set it only once to be even more secure */ 103299f89551SEric W. Biederman result = -EPERM; 10331da177e4SLinus Torvalds if (unlikely(tsk->seccomp.mode)) 103499f89551SEric W. Biederman goto out; 10351da177e4SLinus Torvalds 103699f89551SEric W. Biederman result = -EFAULT; 10371da177e4SLinus Torvalds memset(__buf, 0, sizeof(__buf)); 10381da177e4SLinus Torvalds count = min(count, sizeof(__buf) - 1); 10391da177e4SLinus Torvalds if (copy_from_user(__buf, buf, count)) 104099f89551SEric W. Biederman goto out; 104199f89551SEric W. Biederman 10421da177e4SLinus Torvalds seccomp_mode = simple_strtoul(__buf, &end, 0); 10431da177e4SLinus Torvalds if (*end == '\n') 10441da177e4SLinus Torvalds end++; 104599f89551SEric W. Biederman result = -EINVAL; 10461da177e4SLinus Torvalds if (seccomp_mode && seccomp_mode <= NR_SECCOMP_MODES) { 10471da177e4SLinus Torvalds tsk->seccomp.mode = seccomp_mode; 10481da177e4SLinus Torvalds set_tsk_thread_flag(tsk, TIF_SECCOMP); 10491da177e4SLinus Torvalds } else 105099f89551SEric W. Biederman goto out; 105199f89551SEric W. Biederman result = -EIO; 10521da177e4SLinus Torvalds if (unlikely(!(end - __buf))) 105399f89551SEric W. Biederman goto out; 105499f89551SEric W. Biederman result = end - __buf; 105599f89551SEric W. Biederman out: 105699f89551SEric W. Biederman put_task_struct(tsk); 105799f89551SEric W. Biederman out_no_task: 105899f89551SEric W. Biederman return result; 10591da177e4SLinus Torvalds } 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds static struct file_operations proc_seccomp_operations = { 10621da177e4SLinus Torvalds .read = seccomp_read, 10631da177e4SLinus Torvalds .write = seccomp_write, 10641da177e4SLinus Torvalds }; 10651da177e4SLinus Torvalds #endif /* CONFIG_SECCOMP */ 10661da177e4SLinus Torvalds 1067008b150aSAl Viro static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) 10681da177e4SLinus Torvalds { 10691da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 10701da177e4SLinus Torvalds int error = -EACCES; 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds /* We don't need a base pointer in the /proc filesystem */ 10731da177e4SLinus Torvalds path_release(nd); 10741da177e4SLinus Torvalds 1075778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1076778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 10771da177e4SLinus Torvalds goto out; 10781da177e4SLinus Torvalds 10791da177e4SLinus Torvalds error = PROC_I(inode)->op.proc_get_link(inode, &nd->dentry, &nd->mnt); 10801da177e4SLinus Torvalds nd->last_type = LAST_BIND; 10811da177e4SLinus Torvalds out: 1082008b150aSAl Viro return ERR_PTR(error); 10831da177e4SLinus Torvalds } 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt, 10861da177e4SLinus Torvalds char __user *buffer, int buflen) 10871da177e4SLinus Torvalds { 10881da177e4SLinus Torvalds struct inode * inode; 10891da177e4SLinus Torvalds char *tmp = (char*)__get_free_page(GFP_KERNEL), *path; 10901da177e4SLinus Torvalds int len; 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds if (!tmp) 10931da177e4SLinus Torvalds return -ENOMEM; 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds inode = dentry->d_inode; 10961da177e4SLinus Torvalds path = d_path(dentry, mnt, tmp, PAGE_SIZE); 10971da177e4SLinus Torvalds len = PTR_ERR(path); 10981da177e4SLinus Torvalds if (IS_ERR(path)) 10991da177e4SLinus Torvalds goto out; 11001da177e4SLinus Torvalds len = tmp + PAGE_SIZE - 1 - path; 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds if (len > buflen) 11031da177e4SLinus Torvalds len = buflen; 11041da177e4SLinus Torvalds if (copy_to_user(buffer, path, len)) 11051da177e4SLinus Torvalds len = -EFAULT; 11061da177e4SLinus Torvalds out: 11071da177e4SLinus Torvalds free_page((unsigned long)tmp); 11081da177e4SLinus Torvalds return len; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 11121da177e4SLinus Torvalds { 11131da177e4SLinus Torvalds int error = -EACCES; 11141da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 11151da177e4SLinus Torvalds struct dentry *de; 11161da177e4SLinus Torvalds struct vfsmount *mnt = NULL; 11171da177e4SLinus Torvalds 1118778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1119778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 11201da177e4SLinus Torvalds goto out; 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds error = PROC_I(inode)->op.proc_get_link(inode, &de, &mnt); 11231da177e4SLinus Torvalds if (error) 11241da177e4SLinus Torvalds goto out; 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds error = do_proc_readlink(de, mnt, buffer, buflen); 11271da177e4SLinus Torvalds dput(de); 11281da177e4SLinus Torvalds mntput(mnt); 11291da177e4SLinus Torvalds out: 11301da177e4SLinus Torvalds return error; 11311da177e4SLinus Torvalds } 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds static struct inode_operations proc_pid_link_inode_operations = { 11341da177e4SLinus Torvalds .readlink = proc_pid_readlink, 1135*6d76fa58SLinus Torvalds .follow_link = proc_pid_follow_link, 1136*6d76fa58SLinus Torvalds .setattr = proc_setattr, 11371da177e4SLinus Torvalds }; 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir) 11401da177e4SLinus Torvalds { 11415634708bSEric W. Biederman struct dentry *dentry = filp->f_dentry; 11425634708bSEric W. Biederman struct inode *inode = dentry->d_inode; 114399f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 11441da177e4SLinus Torvalds unsigned int fd, tid, ino; 11451da177e4SLinus Torvalds int retval; 11468578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 11471da177e4SLinus Torvalds struct files_struct * files; 1148badf1662SDipankar Sarma struct fdtable *fdt; 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds retval = -ENOENT; 115199f89551SEric W. Biederman if (!p) 115299f89551SEric W. Biederman goto out_no_task; 11531da177e4SLinus Torvalds retval = 0; 11541da177e4SLinus Torvalds tid = p->pid; 11551da177e4SLinus Torvalds 11561da177e4SLinus Torvalds fd = filp->f_pos; 11571da177e4SLinus Torvalds switch (fd) { 11581da177e4SLinus Torvalds case 0: 11591da177e4SLinus Torvalds if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 11601da177e4SLinus Torvalds goto out; 11611da177e4SLinus Torvalds filp->f_pos++; 11621da177e4SLinus Torvalds case 1: 11635634708bSEric W. Biederman ino = parent_ino(dentry); 11641da177e4SLinus Torvalds if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0) 11651da177e4SLinus Torvalds goto out; 11661da177e4SLinus Torvalds filp->f_pos++; 11671da177e4SLinus Torvalds default: 11681da177e4SLinus Torvalds files = get_files_struct(p); 11691da177e4SLinus Torvalds if (!files) 11701da177e4SLinus Torvalds goto out; 1171b835996fSDipankar Sarma rcu_read_lock(); 1172badf1662SDipankar Sarma fdt = files_fdtable(files); 11731da177e4SLinus Torvalds for (fd = filp->f_pos-2; 1174badf1662SDipankar Sarma fd < fdt->max_fds; 11751da177e4SLinus Torvalds fd++, filp->f_pos++) { 11761da177e4SLinus Torvalds unsigned int i,j; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds if (!fcheck_files(files, fd)) 11791da177e4SLinus Torvalds continue; 1180b835996fSDipankar Sarma rcu_read_unlock(); 11811da177e4SLinus Torvalds 11828578cea7SEric W. Biederman j = PROC_NUMBUF; 11831da177e4SLinus Torvalds i = fd; 11841da177e4SLinus Torvalds do { 11851da177e4SLinus Torvalds j--; 11861da177e4SLinus Torvalds buf[j] = '0' + (i % 10); 11871da177e4SLinus Torvalds i /= 10; 11881da177e4SLinus Torvalds } while (i); 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds ino = fake_ino(tid, PROC_TID_FD_DIR + fd); 11918578cea7SEric W. Biederman if (filldir(dirent, buf+j, PROC_NUMBUF-j, fd+2, ino, DT_LNK) < 0) { 1192b835996fSDipankar Sarma rcu_read_lock(); 11931da177e4SLinus Torvalds break; 11941da177e4SLinus Torvalds } 1195b835996fSDipankar Sarma rcu_read_lock(); 11961da177e4SLinus Torvalds } 1197b835996fSDipankar Sarma rcu_read_unlock(); 11981da177e4SLinus Torvalds put_files_struct(files); 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds out: 120199f89551SEric W. Biederman put_task_struct(p); 120299f89551SEric W. Biederman out_no_task: 12031da177e4SLinus Torvalds return retval; 12041da177e4SLinus Torvalds } 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds static int proc_pident_readdir(struct file *filp, 12071da177e4SLinus Torvalds void *dirent, filldir_t filldir, 12081da177e4SLinus Torvalds struct pid_entry *ents, unsigned int nents) 12091da177e4SLinus Torvalds { 12101da177e4SLinus Torvalds int i; 12111da177e4SLinus Torvalds int pid; 12121da177e4SLinus Torvalds struct dentry *dentry = filp->f_dentry; 12131da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 121499f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 12151da177e4SLinus Torvalds struct pid_entry *p; 12161da177e4SLinus Torvalds ino_t ino; 12171da177e4SLinus Torvalds int ret; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds ret = -ENOENT; 122099f89551SEric W. Biederman if (!task) 12211da177e4SLinus Torvalds goto out; 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds ret = 0; 122499f89551SEric W. Biederman pid = task->pid; 122599f89551SEric W. Biederman put_task_struct(task); 12261da177e4SLinus Torvalds i = filp->f_pos; 12271da177e4SLinus Torvalds switch (i) { 12281da177e4SLinus Torvalds case 0: 12291da177e4SLinus Torvalds ino = inode->i_ino; 12301da177e4SLinus Torvalds if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 12311da177e4SLinus Torvalds goto out; 12321da177e4SLinus Torvalds i++; 12331da177e4SLinus Torvalds filp->f_pos++; 12341da177e4SLinus Torvalds /* fall through */ 12351da177e4SLinus Torvalds case 1: 12361da177e4SLinus Torvalds ino = parent_ino(dentry); 12371da177e4SLinus Torvalds if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 12381da177e4SLinus Torvalds goto out; 12391da177e4SLinus Torvalds i++; 12401da177e4SLinus Torvalds filp->f_pos++; 12411da177e4SLinus Torvalds /* fall through */ 12421da177e4SLinus Torvalds default: 12431da177e4SLinus Torvalds i -= 2; 12441da177e4SLinus Torvalds if (i >= nents) { 12451da177e4SLinus Torvalds ret = 1; 12461da177e4SLinus Torvalds goto out; 12471da177e4SLinus Torvalds } 12481da177e4SLinus Torvalds p = ents + i; 12491da177e4SLinus Torvalds while (p->name) { 12501da177e4SLinus Torvalds if (filldir(dirent, p->name, p->len, filp->f_pos, 12511da177e4SLinus Torvalds fake_ino(pid, p->type), p->mode >> 12) < 0) 12521da177e4SLinus Torvalds goto out; 12531da177e4SLinus Torvalds filp->f_pos++; 12541da177e4SLinus Torvalds p++; 12551da177e4SLinus Torvalds } 12561da177e4SLinus Torvalds } 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds ret = 1; 12591da177e4SLinus Torvalds out: 12601da177e4SLinus Torvalds return ret; 12611da177e4SLinus Torvalds } 12621da177e4SLinus Torvalds 12631da177e4SLinus Torvalds static int proc_tgid_base_readdir(struct file * filp, 12641da177e4SLinus Torvalds void * dirent, filldir_t filldir) 12651da177e4SLinus Torvalds { 12661da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 12671da177e4SLinus Torvalds tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff)); 12681da177e4SLinus Torvalds } 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds static int proc_tid_base_readdir(struct file * filp, 12711da177e4SLinus Torvalds void * dirent, filldir_t filldir) 12721da177e4SLinus Torvalds { 12731da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 12741da177e4SLinus Torvalds tid_base_stuff,ARRAY_SIZE(tid_base_stuff)); 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds /* building an inode */ 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds static int task_dumpable(struct task_struct *task) 12801da177e4SLinus Torvalds { 12811da177e4SLinus Torvalds int dumpable = 0; 12821da177e4SLinus Torvalds struct mm_struct *mm; 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds task_lock(task); 12851da177e4SLinus Torvalds mm = task->mm; 12861da177e4SLinus Torvalds if (mm) 12871da177e4SLinus Torvalds dumpable = mm->dumpable; 12881da177e4SLinus Torvalds task_unlock(task); 1289d6e71144SAlan Cox if(dumpable == 1) 1290d6e71144SAlan Cox return 1; 1291d6e71144SAlan Cox return 0; 12921da177e4SLinus Torvalds } 12931da177e4SLinus Torvalds 12941da177e4SLinus Torvalds 12951da177e4SLinus Torvalds static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task, int ino) 12961da177e4SLinus Torvalds { 12971da177e4SLinus Torvalds struct inode * inode; 12981da177e4SLinus Torvalds struct proc_inode *ei; 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds /* We need a new inode */ 13011da177e4SLinus Torvalds 13021da177e4SLinus Torvalds inode = new_inode(sb); 13031da177e4SLinus Torvalds if (!inode) 13041da177e4SLinus Torvalds goto out; 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds /* Common stuff */ 13071da177e4SLinus Torvalds ei = PROC_I(inode); 13081da177e4SLinus Torvalds inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 13091da177e4SLinus Torvalds inode->i_ino = fake_ino(task->pid, ino); 1310*6d76fa58SLinus Torvalds inode->i_op = &proc_def_inode_operations; 13111da177e4SLinus Torvalds 13121da177e4SLinus Torvalds /* 13131da177e4SLinus Torvalds * grab the reference to task. 13141da177e4SLinus Torvalds */ 131513b41b09SEric W. Biederman ei->pid = get_pid(task->pids[PIDTYPE_PID].pid); 131613b41b09SEric W. Biederman if (!ei->pid) 131799f89551SEric W. Biederman goto out_unlock; 131899f89551SEric W. Biederman 13191da177e4SLinus Torvalds inode->i_uid = 0; 13201da177e4SLinus Torvalds inode->i_gid = 0; 132187bfbf67SEric W. Biederman if (task_dumpable(task)) { 13221da177e4SLinus Torvalds inode->i_uid = task->euid; 13231da177e4SLinus Torvalds inode->i_gid = task->egid; 13241da177e4SLinus Torvalds } 13251da177e4SLinus Torvalds security_task_to_inode(task, inode); 13261da177e4SLinus Torvalds 13271da177e4SLinus Torvalds out: 13281da177e4SLinus Torvalds return inode; 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds out_unlock: 13311da177e4SLinus Torvalds iput(inode); 13321da177e4SLinus Torvalds return NULL; 13331da177e4SLinus Torvalds } 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds /* dentry stuff */ 13361da177e4SLinus Torvalds 13371da177e4SLinus Torvalds /* 13381da177e4SLinus Torvalds * Exceptional case: normally we are not allowed to unhash a busy 13391da177e4SLinus Torvalds * directory. In this case, however, we can do it - no aliasing problems 13401da177e4SLinus Torvalds * due to the way we treat inodes. 13411da177e4SLinus Torvalds * 13421da177e4SLinus Torvalds * Rewrite the inode's ownerships here because the owning task may have 13431da177e4SLinus Torvalds * performed a setuid(), etc. 134499f89551SEric W. Biederman * 134599f89551SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 134699f89551SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 134799f89551SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 134899f89551SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 134999f89551SEric W. Biederman * made this apply to all per process world readable and executable 135099f89551SEric W. Biederman * directories. 13511da177e4SLinus Torvalds */ 13521da177e4SLinus Torvalds static int pid_revalidate(struct dentry *dentry, struct nameidata *nd) 13531da177e4SLinus Torvalds { 13541da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 135599f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 135699f89551SEric W. Biederman if (task) { 135799f89551SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 135899f89551SEric W. Biederman task_dumpable(task)) { 13591da177e4SLinus Torvalds inode->i_uid = task->euid; 13601da177e4SLinus Torvalds inode->i_gid = task->egid; 13611da177e4SLinus Torvalds } else { 13621da177e4SLinus Torvalds inode->i_uid = 0; 13631da177e4SLinus Torvalds inode->i_gid = 0; 13641da177e4SLinus Torvalds } 13659ee8ab9fSLinus Torvalds inode->i_mode &= ~(S_ISUID | S_ISGID); 13661da177e4SLinus Torvalds security_task_to_inode(task, inode); 136799f89551SEric W. Biederman put_task_struct(task); 13681da177e4SLinus Torvalds return 1; 13691da177e4SLinus Torvalds } 13701da177e4SLinus Torvalds d_drop(dentry); 13711da177e4SLinus Torvalds return 0; 13721da177e4SLinus Torvalds } 13731da177e4SLinus Torvalds 137499f89551SEric W. Biederman static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 137599f89551SEric W. Biederman { 137699f89551SEric W. Biederman struct inode *inode = dentry->d_inode; 137799f89551SEric W. Biederman struct task_struct *task; 137899f89551SEric W. Biederman generic_fillattr(inode, stat); 137999f89551SEric W. Biederman 138099f89551SEric W. Biederman rcu_read_lock(); 138199f89551SEric W. Biederman stat->uid = 0; 138299f89551SEric W. Biederman stat->gid = 0; 138399f89551SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 138499f89551SEric W. Biederman if (task) { 138599f89551SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 138699f89551SEric W. Biederman task_dumpable(task)) { 138799f89551SEric W. Biederman stat->uid = task->euid; 138899f89551SEric W. Biederman stat->gid = task->egid; 138999f89551SEric W. Biederman } 139099f89551SEric W. Biederman } 139199f89551SEric W. Biederman rcu_read_unlock(); 139299f89551SEric W. Biederman return 0; 139399f89551SEric W. Biederman } 139499f89551SEric W. Biederman 13951da177e4SLinus Torvalds static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd) 13961da177e4SLinus Torvalds { 13971da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 139899f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1399aed7a6c4SEric W. Biederman int fd = proc_fd(inode); 14001da177e4SLinus Torvalds struct files_struct *files; 14011da177e4SLinus Torvalds 140299f89551SEric W. Biederman if (task) { 14031da177e4SLinus Torvalds files = get_files_struct(task); 14041da177e4SLinus Torvalds if (files) { 1405b835996fSDipankar Sarma rcu_read_lock(); 14061da177e4SLinus Torvalds if (fcheck_files(files, fd)) { 1407b835996fSDipankar Sarma rcu_read_unlock(); 14081da177e4SLinus Torvalds put_files_struct(files); 14091da177e4SLinus Torvalds if (task_dumpable(task)) { 14101da177e4SLinus Torvalds inode->i_uid = task->euid; 14111da177e4SLinus Torvalds inode->i_gid = task->egid; 14121da177e4SLinus Torvalds } else { 14131da177e4SLinus Torvalds inode->i_uid = 0; 14141da177e4SLinus Torvalds inode->i_gid = 0; 14151da177e4SLinus Torvalds } 14169ee8ab9fSLinus Torvalds inode->i_mode &= ~(S_ISUID | S_ISGID); 14171da177e4SLinus Torvalds security_task_to_inode(task, inode); 141899f89551SEric W. Biederman put_task_struct(task); 14191da177e4SLinus Torvalds return 1; 14201da177e4SLinus Torvalds } 1421b835996fSDipankar Sarma rcu_read_unlock(); 14221da177e4SLinus Torvalds put_files_struct(files); 14231da177e4SLinus Torvalds } 142499f89551SEric W. Biederman put_task_struct(task); 142599f89551SEric W. Biederman } 14261da177e4SLinus Torvalds d_drop(dentry); 14271da177e4SLinus Torvalds return 0; 14281da177e4SLinus Torvalds } 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds static int pid_delete_dentry(struct dentry * dentry) 14311da177e4SLinus Torvalds { 14321da177e4SLinus Torvalds /* Is the task we represent dead? 14331da177e4SLinus Torvalds * If so, then don't put the dentry on the lru list, 14341da177e4SLinus Torvalds * kill it immediately. 14351da177e4SLinus Torvalds */ 143613b41b09SEric W. Biederman return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first; 14371da177e4SLinus Torvalds } 14381da177e4SLinus Torvalds 14391da177e4SLinus Torvalds static struct dentry_operations tid_fd_dentry_operations = 14401da177e4SLinus Torvalds { 14411da177e4SLinus Torvalds .d_revalidate = tid_fd_revalidate, 14421da177e4SLinus Torvalds .d_delete = pid_delete_dentry, 14431da177e4SLinus Torvalds }; 14441da177e4SLinus Torvalds 14451da177e4SLinus Torvalds static struct dentry_operations pid_dentry_operations = 14461da177e4SLinus Torvalds { 14471da177e4SLinus Torvalds .d_revalidate = pid_revalidate, 14481da177e4SLinus Torvalds .d_delete = pid_delete_dentry, 14491da177e4SLinus Torvalds }; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds /* Lookups */ 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds static unsigned name_to_int(struct dentry *dentry) 14541da177e4SLinus Torvalds { 14551da177e4SLinus Torvalds const char *name = dentry->d_name.name; 14561da177e4SLinus Torvalds int len = dentry->d_name.len; 14571da177e4SLinus Torvalds unsigned n = 0; 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds if (len > 1 && *name == '0') 14601da177e4SLinus Torvalds goto out; 14611da177e4SLinus Torvalds while (len-- > 0) { 14621da177e4SLinus Torvalds unsigned c = *name++ - '0'; 14631da177e4SLinus Torvalds if (c > 9) 14641da177e4SLinus Torvalds goto out; 14651da177e4SLinus Torvalds if (n >= (~0U-9)/10) 14661da177e4SLinus Torvalds goto out; 14671da177e4SLinus Torvalds n *= 10; 14681da177e4SLinus Torvalds n += c; 14691da177e4SLinus Torvalds } 14701da177e4SLinus Torvalds return n; 14711da177e4SLinus Torvalds out: 14721da177e4SLinus Torvalds return ~0U; 14731da177e4SLinus Torvalds } 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds /* SMP-safe */ 14761da177e4SLinus Torvalds static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry, struct nameidata *nd) 14771da177e4SLinus Torvalds { 147899f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 14791da177e4SLinus Torvalds unsigned fd = name_to_int(dentry); 1480cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 14811da177e4SLinus Torvalds struct file * file; 14821da177e4SLinus Torvalds struct files_struct * files; 14831da177e4SLinus Torvalds struct inode *inode; 14841da177e4SLinus Torvalds struct proc_inode *ei; 14851da177e4SLinus Torvalds 148699f89551SEric W. Biederman if (!task) 148799f89551SEric W. Biederman goto out_no_task; 14881da177e4SLinus Torvalds if (fd == ~0U) 14891da177e4SLinus Torvalds goto out; 14901da177e4SLinus Torvalds 14911da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_FD_DIR+fd); 14921da177e4SLinus Torvalds if (!inode) 14931da177e4SLinus Torvalds goto out; 14941da177e4SLinus Torvalds ei = PROC_I(inode); 1495aed7a6c4SEric W. Biederman ei->fd = fd; 14961da177e4SLinus Torvalds files = get_files_struct(task); 14971da177e4SLinus Torvalds if (!files) 14981da177e4SLinus Torvalds goto out_unlock; 14991da177e4SLinus Torvalds inode->i_mode = S_IFLNK; 1500ca99c1daSDipankar Sarma 1501ca99c1daSDipankar Sarma /* 1502ca99c1daSDipankar Sarma * We are not taking a ref to the file structure, so we must 1503ca99c1daSDipankar Sarma * hold ->file_lock. 1504ca99c1daSDipankar Sarma */ 1505ca99c1daSDipankar Sarma spin_lock(&files->file_lock); 15061da177e4SLinus Torvalds file = fcheck_files(files, fd); 15071da177e4SLinus Torvalds if (!file) 15081da177e4SLinus Torvalds goto out_unlock2; 15091da177e4SLinus Torvalds if (file->f_mode & 1) 15101da177e4SLinus Torvalds inode->i_mode |= S_IRUSR | S_IXUSR; 15111da177e4SLinus Torvalds if (file->f_mode & 2) 15121da177e4SLinus Torvalds inode->i_mode |= S_IWUSR | S_IXUSR; 1513ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 15141da177e4SLinus Torvalds put_files_struct(files); 15151da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 15161da177e4SLinus Torvalds inode->i_size = 64; 15171da177e4SLinus Torvalds ei->op.proc_get_link = proc_fd_link; 15181da177e4SLinus Torvalds dentry->d_op = &tid_fd_dentry_operations; 15191da177e4SLinus Torvalds d_add(dentry, inode); 1520cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 1521cd6a3ce9SEric W. Biederman if (tid_fd_revalidate(dentry, NULL)) 1522cd6a3ce9SEric W. Biederman result = NULL; 1523cd6a3ce9SEric W. Biederman out: 152499f89551SEric W. Biederman put_task_struct(task); 152599f89551SEric W. Biederman out_no_task: 1526cd6a3ce9SEric W. Biederman return result; 15271da177e4SLinus Torvalds 15281da177e4SLinus Torvalds out_unlock2: 1529ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 15301da177e4SLinus Torvalds put_files_struct(files); 15311da177e4SLinus Torvalds out_unlock: 15321da177e4SLinus Torvalds iput(inode); 1533cd6a3ce9SEric W. Biederman goto out; 15341da177e4SLinus Torvalds } 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir); 15371da177e4SLinus Torvalds static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd); 15386e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat); 15391da177e4SLinus Torvalds 15401da177e4SLinus Torvalds static struct file_operations proc_fd_operations = { 15411da177e4SLinus Torvalds .read = generic_read_dir, 15421da177e4SLinus Torvalds .readdir = proc_readfd, 15431da177e4SLinus Torvalds }; 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds static struct file_operations proc_task_operations = { 15461da177e4SLinus Torvalds .read = generic_read_dir, 15471da177e4SLinus Torvalds .readdir = proc_task_readdir, 15481da177e4SLinus Torvalds }; 15491da177e4SLinus Torvalds 15501da177e4SLinus Torvalds /* 15511da177e4SLinus Torvalds * proc directories can do almost nothing.. 15521da177e4SLinus Torvalds */ 15531da177e4SLinus Torvalds static struct inode_operations proc_fd_inode_operations = { 15541da177e4SLinus Torvalds .lookup = proc_lookupfd, 1555*6d76fa58SLinus Torvalds .setattr = proc_setattr, 15561da177e4SLinus Torvalds }; 15571da177e4SLinus Torvalds 15581da177e4SLinus Torvalds static struct inode_operations proc_task_inode_operations = { 15591da177e4SLinus Torvalds .lookup = proc_task_lookup, 15606e66b52bSEric W. Biederman .getattr = proc_task_getattr, 1561*6d76fa58SLinus Torvalds .setattr = proc_setattr, 15621da177e4SLinus Torvalds }; 15631da177e4SLinus Torvalds 15641da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 15651da177e4SLinus Torvalds static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 15661da177e4SLinus Torvalds size_t count, loff_t *ppos) 15671da177e4SLinus Torvalds { 15681da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 15691da177e4SLinus Torvalds unsigned long page; 15701da177e4SLinus Torvalds ssize_t length; 157199f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 157299f89551SEric W. Biederman 157399f89551SEric W. Biederman length = -ESRCH; 157499f89551SEric W. Biederman if (!task) 157599f89551SEric W. Biederman goto out_no_task; 15761da177e4SLinus Torvalds 15771da177e4SLinus Torvalds if (count > PAGE_SIZE) 15781da177e4SLinus Torvalds count = PAGE_SIZE; 157999f89551SEric W. Biederman length = -ENOMEM; 15801da177e4SLinus Torvalds if (!(page = __get_free_page(GFP_KERNEL))) 158199f89551SEric W. Biederman goto out; 15821da177e4SLinus Torvalds 15831da177e4SLinus Torvalds length = security_getprocattr(task, 15841da177e4SLinus Torvalds (char*)file->f_dentry->d_name.name, 15851da177e4SLinus Torvalds (void*)page, count); 15861da177e4SLinus Torvalds if (length >= 0) 15871da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 15881da177e4SLinus Torvalds free_page(page); 158999f89551SEric W. Biederman out: 159099f89551SEric W. Biederman put_task_struct(task); 159199f89551SEric W. Biederman out_no_task: 15921da177e4SLinus Torvalds return length; 15931da177e4SLinus Torvalds } 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 15961da177e4SLinus Torvalds size_t count, loff_t *ppos) 15971da177e4SLinus Torvalds { 15981da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 15991da177e4SLinus Torvalds char *page; 16001da177e4SLinus Torvalds ssize_t length; 160199f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 16021da177e4SLinus Torvalds 160399f89551SEric W. Biederman length = -ESRCH; 160499f89551SEric W. Biederman if (!task) 160599f89551SEric W. Biederman goto out_no_task; 16061da177e4SLinus Torvalds if (count > PAGE_SIZE) 16071da177e4SLinus Torvalds count = PAGE_SIZE; 160899f89551SEric W. Biederman 16091da177e4SLinus Torvalds /* No partial writes. */ 161099f89551SEric W. Biederman length = -EINVAL; 161199f89551SEric W. Biederman if (*ppos != 0) 161299f89551SEric W. Biederman goto out; 161399f89551SEric W. Biederman 161499f89551SEric W. Biederman length = -ENOMEM; 16151da177e4SLinus Torvalds page = (char*)__get_free_page(GFP_USER); 16161da177e4SLinus Torvalds if (!page) 161799f89551SEric W. Biederman goto out; 161899f89551SEric W. Biederman 16191da177e4SLinus Torvalds length = -EFAULT; 16201da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 162199f89551SEric W. Biederman goto out_free; 16221da177e4SLinus Torvalds 16231da177e4SLinus Torvalds length = security_setprocattr(task, 16241da177e4SLinus Torvalds (char*)file->f_dentry->d_name.name, 16251da177e4SLinus Torvalds (void*)page, count); 162699f89551SEric W. Biederman out_free: 16271da177e4SLinus Torvalds free_page((unsigned long) page); 162899f89551SEric W. Biederman out: 162999f89551SEric W. Biederman put_task_struct(task); 163099f89551SEric W. Biederman out_no_task: 16311da177e4SLinus Torvalds return length; 16321da177e4SLinus Torvalds } 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds static struct file_operations proc_pid_attr_operations = { 16351da177e4SLinus Torvalds .read = proc_pid_attr_read, 16361da177e4SLinus Torvalds .write = proc_pid_attr_write, 16371da177e4SLinus Torvalds }; 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds static struct file_operations proc_tid_attr_operations; 16401da177e4SLinus Torvalds static struct inode_operations proc_tid_attr_inode_operations; 16411da177e4SLinus Torvalds static struct file_operations proc_tgid_attr_operations; 16421da177e4SLinus Torvalds static struct inode_operations proc_tgid_attr_inode_operations; 16431da177e4SLinus Torvalds #endif 16441da177e4SLinus Torvalds 16451da177e4SLinus Torvalds /* SMP-safe */ 16461da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 16471da177e4SLinus Torvalds struct dentry *dentry, 16481da177e4SLinus Torvalds struct pid_entry *ents) 16491da177e4SLinus Torvalds { 16501da177e4SLinus Torvalds struct inode *inode; 1651cd6a3ce9SEric W. Biederman struct dentry *error; 165299f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 16531da177e4SLinus Torvalds struct pid_entry *p; 16541da177e4SLinus Torvalds struct proc_inode *ei; 16551da177e4SLinus Torvalds 1656cd6a3ce9SEric W. Biederman error = ERR_PTR(-ENOENT); 16571da177e4SLinus Torvalds inode = NULL; 16581da177e4SLinus Torvalds 165999f89551SEric W. Biederman if (!task) 166099f89551SEric W. Biederman goto out_no_task; 16611da177e4SLinus Torvalds 16621da177e4SLinus Torvalds for (p = ents; p->name; p++) { 16631da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 16641da177e4SLinus Torvalds continue; 16651da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 16661da177e4SLinus Torvalds break; 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds if (!p->name) 16691da177e4SLinus Torvalds goto out; 16701da177e4SLinus Torvalds 1671cd6a3ce9SEric W. Biederman error = ERR_PTR(-EINVAL); 16721da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, p->type); 16731da177e4SLinus Torvalds if (!inode) 16741da177e4SLinus Torvalds goto out; 16751da177e4SLinus Torvalds 16761da177e4SLinus Torvalds ei = PROC_I(inode); 16771da177e4SLinus Torvalds inode->i_mode = p->mode; 16781da177e4SLinus Torvalds /* 16791da177e4SLinus Torvalds * Yes, it does not scale. And it should not. Don't add 16801da177e4SLinus Torvalds * new entries into /proc/<tgid>/ without very good reasons. 16811da177e4SLinus Torvalds */ 16821da177e4SLinus Torvalds switch(p->type) { 16831da177e4SLinus Torvalds case PROC_TGID_TASK: 16846e66b52bSEric W. Biederman inode->i_nlink = 2; 16851da177e4SLinus Torvalds inode->i_op = &proc_task_inode_operations; 16861da177e4SLinus Torvalds inode->i_fop = &proc_task_operations; 16871da177e4SLinus Torvalds break; 16881da177e4SLinus Torvalds case PROC_TID_FD: 16891da177e4SLinus Torvalds case PROC_TGID_FD: 16901da177e4SLinus Torvalds inode->i_nlink = 2; 16911da177e4SLinus Torvalds inode->i_op = &proc_fd_inode_operations; 16921da177e4SLinus Torvalds inode->i_fop = &proc_fd_operations; 16931da177e4SLinus Torvalds break; 16941da177e4SLinus Torvalds case PROC_TID_EXE: 16951da177e4SLinus Torvalds case PROC_TGID_EXE: 16961da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 16971da177e4SLinus Torvalds ei->op.proc_get_link = proc_exe_link; 16981da177e4SLinus Torvalds break; 16991da177e4SLinus Torvalds case PROC_TID_CWD: 17001da177e4SLinus Torvalds case PROC_TGID_CWD: 17011da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 17021da177e4SLinus Torvalds ei->op.proc_get_link = proc_cwd_link; 17031da177e4SLinus Torvalds break; 17041da177e4SLinus Torvalds case PROC_TID_ROOT: 17051da177e4SLinus Torvalds case PROC_TGID_ROOT: 17061da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 17071da177e4SLinus Torvalds ei->op.proc_get_link = proc_root_link; 17081da177e4SLinus Torvalds break; 17091da177e4SLinus Torvalds case PROC_TID_ENVIRON: 17101da177e4SLinus Torvalds case PROC_TGID_ENVIRON: 17111da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17121da177e4SLinus Torvalds ei->op.proc_read = proc_pid_environ; 17131da177e4SLinus Torvalds break; 17141da177e4SLinus Torvalds case PROC_TID_AUXV: 17151da177e4SLinus Torvalds case PROC_TGID_AUXV: 17161da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17171da177e4SLinus Torvalds ei->op.proc_read = proc_pid_auxv; 17181da177e4SLinus Torvalds break; 17191da177e4SLinus Torvalds case PROC_TID_STATUS: 17201da177e4SLinus Torvalds case PROC_TGID_STATUS: 17211da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17221da177e4SLinus Torvalds ei->op.proc_read = proc_pid_status; 17231da177e4SLinus Torvalds break; 17241da177e4SLinus Torvalds case PROC_TID_STAT: 17251da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17261da177e4SLinus Torvalds ei->op.proc_read = proc_tid_stat; 17271da177e4SLinus Torvalds break; 17281da177e4SLinus Torvalds case PROC_TGID_STAT: 17291da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17301da177e4SLinus Torvalds ei->op.proc_read = proc_tgid_stat; 17311da177e4SLinus Torvalds break; 17321da177e4SLinus Torvalds case PROC_TID_CMDLINE: 17331da177e4SLinus Torvalds case PROC_TGID_CMDLINE: 17341da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17351da177e4SLinus Torvalds ei->op.proc_read = proc_pid_cmdline; 17361da177e4SLinus Torvalds break; 17371da177e4SLinus Torvalds case PROC_TID_STATM: 17381da177e4SLinus Torvalds case PROC_TGID_STATM: 17391da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17401da177e4SLinus Torvalds ei->op.proc_read = proc_pid_statm; 17411da177e4SLinus Torvalds break; 17421da177e4SLinus Torvalds case PROC_TID_MAPS: 17431da177e4SLinus Torvalds case PROC_TGID_MAPS: 17441da177e4SLinus Torvalds inode->i_fop = &proc_maps_operations; 17451da177e4SLinus Torvalds break; 17466e21c8f1SChristoph Lameter #ifdef CONFIG_NUMA 17476e21c8f1SChristoph Lameter case PROC_TID_NUMA_MAPS: 17486e21c8f1SChristoph Lameter case PROC_TGID_NUMA_MAPS: 17496e21c8f1SChristoph Lameter inode->i_fop = &proc_numa_maps_operations; 17506e21c8f1SChristoph Lameter break; 17516e21c8f1SChristoph Lameter #endif 17521da177e4SLinus Torvalds case PROC_TID_MEM: 17531da177e4SLinus Torvalds case PROC_TGID_MEM: 17541da177e4SLinus Torvalds inode->i_fop = &proc_mem_operations; 17551da177e4SLinus Torvalds break; 17561da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 17571da177e4SLinus Torvalds case PROC_TID_SECCOMP: 17581da177e4SLinus Torvalds case PROC_TGID_SECCOMP: 17591da177e4SLinus Torvalds inode->i_fop = &proc_seccomp_operations; 17601da177e4SLinus Torvalds break; 17611da177e4SLinus Torvalds #endif /* CONFIG_SECCOMP */ 17621da177e4SLinus Torvalds case PROC_TID_MOUNTS: 17631da177e4SLinus Torvalds case PROC_TGID_MOUNTS: 17641da177e4SLinus Torvalds inode->i_fop = &proc_mounts_operations; 17651da177e4SLinus Torvalds break; 176663c6764cSYoshinori Sato #ifdef CONFIG_MMU 1767e070ad49SMauricio Lin case PROC_TID_SMAPS: 1768e070ad49SMauricio Lin case PROC_TGID_SMAPS: 1769e070ad49SMauricio Lin inode->i_fop = &proc_smaps_operations; 1770e070ad49SMauricio Lin break; 177163c6764cSYoshinori Sato #endif 1772b4629fe2SChuck Lever case PROC_TID_MOUNTSTATS: 1773b4629fe2SChuck Lever case PROC_TGID_MOUNTSTATS: 1774b4629fe2SChuck Lever inode->i_fop = &proc_mountstats_operations; 1775b4629fe2SChuck Lever break; 17761da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 17771da177e4SLinus Torvalds case PROC_TID_ATTR: 17781da177e4SLinus Torvalds inode->i_nlink = 2; 17791da177e4SLinus Torvalds inode->i_op = &proc_tid_attr_inode_operations; 17801da177e4SLinus Torvalds inode->i_fop = &proc_tid_attr_operations; 17811da177e4SLinus Torvalds break; 17821da177e4SLinus Torvalds case PROC_TGID_ATTR: 17831da177e4SLinus Torvalds inode->i_nlink = 2; 17841da177e4SLinus Torvalds inode->i_op = &proc_tgid_attr_inode_operations; 17851da177e4SLinus Torvalds inode->i_fop = &proc_tgid_attr_operations; 17861da177e4SLinus Torvalds break; 17871da177e4SLinus Torvalds case PROC_TID_ATTR_CURRENT: 17881da177e4SLinus Torvalds case PROC_TGID_ATTR_CURRENT: 17891da177e4SLinus Torvalds case PROC_TID_ATTR_PREV: 17901da177e4SLinus Torvalds case PROC_TGID_ATTR_PREV: 17911da177e4SLinus Torvalds case PROC_TID_ATTR_EXEC: 17921da177e4SLinus Torvalds case PROC_TGID_ATTR_EXEC: 17931da177e4SLinus Torvalds case PROC_TID_ATTR_FSCREATE: 17941da177e4SLinus Torvalds case PROC_TGID_ATTR_FSCREATE: 17954eb582cfSMichael LeMay case PROC_TID_ATTR_KEYCREATE: 17964eb582cfSMichael LeMay case PROC_TGID_ATTR_KEYCREATE: 179742c3e03eSEric Paris case PROC_TID_ATTR_SOCKCREATE: 179842c3e03eSEric Paris case PROC_TGID_ATTR_SOCKCREATE: 17991da177e4SLinus Torvalds inode->i_fop = &proc_pid_attr_operations; 18001da177e4SLinus Torvalds break; 18011da177e4SLinus Torvalds #endif 18021da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 18031da177e4SLinus Torvalds case PROC_TID_WCHAN: 18041da177e4SLinus Torvalds case PROC_TGID_WCHAN: 18051da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 18061da177e4SLinus Torvalds ei->op.proc_read = proc_pid_wchan; 18071da177e4SLinus Torvalds break; 18081da177e4SLinus Torvalds #endif 18091da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 18101da177e4SLinus Torvalds case PROC_TID_SCHEDSTAT: 18111da177e4SLinus Torvalds case PROC_TGID_SCHEDSTAT: 18121da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 18131da177e4SLinus Torvalds ei->op.proc_read = proc_pid_schedstat; 18141da177e4SLinus Torvalds break; 18151da177e4SLinus Torvalds #endif 18161da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 18171da177e4SLinus Torvalds case PROC_TID_CPUSET: 18181da177e4SLinus Torvalds case PROC_TGID_CPUSET: 18191da177e4SLinus Torvalds inode->i_fop = &proc_cpuset_operations; 18201da177e4SLinus Torvalds break; 18211da177e4SLinus Torvalds #endif 18221da177e4SLinus Torvalds case PROC_TID_OOM_SCORE: 18231da177e4SLinus Torvalds case PROC_TGID_OOM_SCORE: 18241da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 18251da177e4SLinus Torvalds ei->op.proc_read = proc_oom_score; 18261da177e4SLinus Torvalds break; 18271da177e4SLinus Torvalds case PROC_TID_OOM_ADJUST: 18281da177e4SLinus Torvalds case PROC_TGID_OOM_ADJUST: 18291da177e4SLinus Torvalds inode->i_fop = &proc_oom_adjust_operations; 18301da177e4SLinus Torvalds break; 18311da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 18321da177e4SLinus Torvalds case PROC_TID_LOGINUID: 18331da177e4SLinus Torvalds case PROC_TGID_LOGINUID: 18341da177e4SLinus Torvalds inode->i_fop = &proc_loginuid_operations; 18351da177e4SLinus Torvalds break; 18361da177e4SLinus Torvalds #endif 18371da177e4SLinus Torvalds default: 18381da177e4SLinus Torvalds printk("procfs: impossible type (%d)",p->type); 18391da177e4SLinus Torvalds iput(inode); 1840cd6a3ce9SEric W. Biederman error = ERR_PTR(-EINVAL); 1841cd6a3ce9SEric W. Biederman goto out; 18421da177e4SLinus Torvalds } 18431da177e4SLinus Torvalds dentry->d_op = &pid_dentry_operations; 18441da177e4SLinus Torvalds d_add(dentry, inode); 1845cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 1846cd6a3ce9SEric W. Biederman if (pid_revalidate(dentry, NULL)) 1847cd6a3ce9SEric W. Biederman error = NULL; 18481da177e4SLinus Torvalds out: 184999f89551SEric W. Biederman put_task_struct(task); 185099f89551SEric W. Biederman out_no_task: 1851cd6a3ce9SEric W. Biederman return error; 18521da177e4SLinus Torvalds } 18531da177e4SLinus Torvalds 18541da177e4SLinus Torvalds static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 18551da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tgid_base_stuff); 18561da177e4SLinus Torvalds } 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 18591da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tid_base_stuff); 18601da177e4SLinus Torvalds } 18611da177e4SLinus Torvalds 18621da177e4SLinus Torvalds static struct file_operations proc_tgid_base_operations = { 18631da177e4SLinus Torvalds .read = generic_read_dir, 18641da177e4SLinus Torvalds .readdir = proc_tgid_base_readdir, 18651da177e4SLinus Torvalds }; 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds static struct file_operations proc_tid_base_operations = { 18681da177e4SLinus Torvalds .read = generic_read_dir, 18691da177e4SLinus Torvalds .readdir = proc_tid_base_readdir, 18701da177e4SLinus Torvalds }; 18711da177e4SLinus Torvalds 18721da177e4SLinus Torvalds static struct inode_operations proc_tgid_base_inode_operations = { 18731da177e4SLinus Torvalds .lookup = proc_tgid_base_lookup, 187499f89551SEric W. Biederman .getattr = pid_getattr, 1875*6d76fa58SLinus Torvalds .setattr = proc_setattr, 18761da177e4SLinus Torvalds }; 18771da177e4SLinus Torvalds 18781da177e4SLinus Torvalds static struct inode_operations proc_tid_base_inode_operations = { 18791da177e4SLinus Torvalds .lookup = proc_tid_base_lookup, 188099f89551SEric W. Biederman .getattr = pid_getattr, 1881*6d76fa58SLinus Torvalds .setattr = proc_setattr, 18821da177e4SLinus Torvalds }; 18831da177e4SLinus Torvalds 18841da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 18851da177e4SLinus Torvalds static int proc_tgid_attr_readdir(struct file * filp, 18861da177e4SLinus Torvalds void * dirent, filldir_t filldir) 18871da177e4SLinus Torvalds { 18881da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 18891da177e4SLinus Torvalds tgid_attr_stuff,ARRAY_SIZE(tgid_attr_stuff)); 18901da177e4SLinus Torvalds } 18911da177e4SLinus Torvalds 18921da177e4SLinus Torvalds static int proc_tid_attr_readdir(struct file * filp, 18931da177e4SLinus Torvalds void * dirent, filldir_t filldir) 18941da177e4SLinus Torvalds { 18951da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 18961da177e4SLinus Torvalds tid_attr_stuff,ARRAY_SIZE(tid_attr_stuff)); 18971da177e4SLinus Torvalds } 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds static struct file_operations proc_tgid_attr_operations = { 19001da177e4SLinus Torvalds .read = generic_read_dir, 19011da177e4SLinus Torvalds .readdir = proc_tgid_attr_readdir, 19021da177e4SLinus Torvalds }; 19031da177e4SLinus Torvalds 19041da177e4SLinus Torvalds static struct file_operations proc_tid_attr_operations = { 19051da177e4SLinus Torvalds .read = generic_read_dir, 19061da177e4SLinus Torvalds .readdir = proc_tid_attr_readdir, 19071da177e4SLinus Torvalds }; 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds static struct dentry *proc_tgid_attr_lookup(struct inode *dir, 19101da177e4SLinus Torvalds struct dentry *dentry, struct nameidata *nd) 19111da177e4SLinus Torvalds { 19121da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tgid_attr_stuff); 19131da177e4SLinus Torvalds } 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds static struct dentry *proc_tid_attr_lookup(struct inode *dir, 19161da177e4SLinus Torvalds struct dentry *dentry, struct nameidata *nd) 19171da177e4SLinus Torvalds { 19181da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tid_attr_stuff); 19191da177e4SLinus Torvalds } 19201da177e4SLinus Torvalds 19211da177e4SLinus Torvalds static struct inode_operations proc_tgid_attr_inode_operations = { 19221da177e4SLinus Torvalds .lookup = proc_tgid_attr_lookup, 192399f89551SEric W. Biederman .getattr = pid_getattr, 1924*6d76fa58SLinus Torvalds .setattr = proc_setattr, 19251da177e4SLinus Torvalds }; 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds static struct inode_operations proc_tid_attr_inode_operations = { 19281da177e4SLinus Torvalds .lookup = proc_tid_attr_lookup, 192999f89551SEric W. Biederman .getattr = pid_getattr, 1930*6d76fa58SLinus Torvalds .setattr = proc_setattr, 19311da177e4SLinus Torvalds }; 19321da177e4SLinus Torvalds #endif 19331da177e4SLinus Torvalds 19341da177e4SLinus Torvalds /* 19351da177e4SLinus Torvalds * /proc/self: 19361da177e4SLinus Torvalds */ 19371da177e4SLinus Torvalds static int proc_self_readlink(struct dentry *dentry, char __user *buffer, 19381da177e4SLinus Torvalds int buflen) 19391da177e4SLinus Torvalds { 19408578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 19411da177e4SLinus Torvalds sprintf(tmp, "%d", current->tgid); 19421da177e4SLinus Torvalds return vfs_readlink(dentry,buffer,buflen,tmp); 19431da177e4SLinus Torvalds } 19441da177e4SLinus Torvalds 1945008b150aSAl Viro static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd) 19461da177e4SLinus Torvalds { 19478578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 19481da177e4SLinus Torvalds sprintf(tmp, "%d", current->tgid); 1949008b150aSAl Viro return ERR_PTR(vfs_follow_link(nd,tmp)); 19501da177e4SLinus Torvalds } 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds static struct inode_operations proc_self_inode_operations = { 19531da177e4SLinus Torvalds .readlink = proc_self_readlink, 19541da177e4SLinus Torvalds .follow_link = proc_self_follow_link, 19551da177e4SLinus Torvalds }; 19561da177e4SLinus Torvalds 19571da177e4SLinus Torvalds /** 195848e6484dSEric W. Biederman * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 19591da177e4SLinus Torvalds * 196048e6484dSEric W. Biederman * @task: task that should be flushed. 19611da177e4SLinus Torvalds * 196248e6484dSEric W. Biederman * Looks in the dcache for 196348e6484dSEric W. Biederman * /proc/@pid 196448e6484dSEric W. Biederman * /proc/@tgid/task/@pid 196548e6484dSEric W. Biederman * if either directory is present flushes it and all of it'ts children 196648e6484dSEric W. Biederman * from the dcache. 196748e6484dSEric W. Biederman * 196848e6484dSEric W. Biederman * It is safe and reasonable to cache /proc entries for a task until 196948e6484dSEric W. Biederman * that task exits. After that they just clog up the dcache with 197048e6484dSEric W. Biederman * useless entries, possibly causing useful dcache entries to be 197148e6484dSEric W. Biederman * flushed instead. This routine is proved to flush those useless 197248e6484dSEric W. Biederman * dcache entries at process exit time. 197348e6484dSEric W. Biederman * 197448e6484dSEric W. Biederman * NOTE: This routine is just an optimization so it does not guarantee 197548e6484dSEric W. Biederman * that no dcache entries will exist at process exit time it 197648e6484dSEric W. Biederman * just makes it very unlikely that any will persist. 19771da177e4SLinus Torvalds */ 197848e6484dSEric W. Biederman void proc_flush_task(struct task_struct *task) 19791da177e4SLinus Torvalds { 198048e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 19818578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 198248e6484dSEric W. Biederman struct qstr name; 19831da177e4SLinus Torvalds 198448e6484dSEric W. Biederman name.name = buf; 198548e6484dSEric W. Biederman name.len = snprintf(buf, sizeof(buf), "%d", task->pid); 198648e6484dSEric W. Biederman dentry = d_hash_and_lookup(proc_mnt->mnt_root, &name); 198748e6484dSEric W. Biederman if (dentry) { 198848e6484dSEric W. Biederman shrink_dcache_parent(dentry); 198948e6484dSEric W. Biederman d_drop(dentry); 199048e6484dSEric W. Biederman dput(dentry); 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds 199348e6484dSEric W. Biederman if (thread_group_leader(task)) 199448e6484dSEric W. Biederman goto out; 19951da177e4SLinus Torvalds 199648e6484dSEric W. Biederman name.name = buf; 199748e6484dSEric W. Biederman name.len = snprintf(buf, sizeof(buf), "%d", task->tgid); 199848e6484dSEric W. Biederman leader = d_hash_and_lookup(proc_mnt->mnt_root, &name); 199948e6484dSEric W. Biederman if (!leader) 200048e6484dSEric W. Biederman goto out; 200148e6484dSEric W. Biederman 200248e6484dSEric W. Biederman name.name = "task"; 200348e6484dSEric W. Biederman name.len = strlen(name.name); 200448e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 200548e6484dSEric W. Biederman if (!dir) 200648e6484dSEric W. Biederman goto out_put_leader; 200748e6484dSEric W. Biederman 200848e6484dSEric W. Biederman name.name = buf; 200948e6484dSEric W. Biederman name.len = snprintf(buf, sizeof(buf), "%d", task->pid); 201048e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 201148e6484dSEric W. Biederman if (dentry) { 201248e6484dSEric W. Biederman shrink_dcache_parent(dentry); 201348e6484dSEric W. Biederman d_drop(dentry); 201448e6484dSEric W. Biederman dput(dentry); 20151da177e4SLinus Torvalds } 201648e6484dSEric W. Biederman 201748e6484dSEric W. Biederman dput(dir); 201848e6484dSEric W. Biederman out_put_leader: 201948e6484dSEric W. Biederman dput(leader); 202048e6484dSEric W. Biederman out: 202148e6484dSEric W. Biederman return; 20221da177e4SLinus Torvalds } 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds /* SMP-safe */ 20251da177e4SLinus Torvalds struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 20261da177e4SLinus Torvalds { 2027cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 20281da177e4SLinus Torvalds struct task_struct *task; 20291da177e4SLinus Torvalds struct inode *inode; 20301da177e4SLinus Torvalds struct proc_inode *ei; 20311da177e4SLinus Torvalds unsigned tgid; 20321da177e4SLinus Torvalds 20331da177e4SLinus Torvalds if (dentry->d_name.len == 4 && !memcmp(dentry->d_name.name,"self",4)) { 20341da177e4SLinus Torvalds inode = new_inode(dir->i_sb); 20351da177e4SLinus Torvalds if (!inode) 20361da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 20371da177e4SLinus Torvalds ei = PROC_I(inode); 20381da177e4SLinus Torvalds inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 20391da177e4SLinus Torvalds inode->i_ino = fake_ino(0, PROC_TGID_INO); 20401da177e4SLinus Torvalds ei->pde = NULL; 20411da177e4SLinus Torvalds inode->i_mode = S_IFLNK|S_IRWXUGO; 20421da177e4SLinus Torvalds inode->i_uid = inode->i_gid = 0; 20431da177e4SLinus Torvalds inode->i_size = 64; 20441da177e4SLinus Torvalds inode->i_op = &proc_self_inode_operations; 20451da177e4SLinus Torvalds d_add(dentry, inode); 20461da177e4SLinus Torvalds return NULL; 20471da177e4SLinus Torvalds } 20481da177e4SLinus Torvalds tgid = name_to_int(dentry); 20491da177e4SLinus Torvalds if (tgid == ~0U) 20501da177e4SLinus Torvalds goto out; 20511da177e4SLinus Torvalds 2052de758734SEric W. Biederman rcu_read_lock(); 20531da177e4SLinus Torvalds task = find_task_by_pid(tgid); 20541da177e4SLinus Torvalds if (task) 20551da177e4SLinus Torvalds get_task_struct(task); 2056de758734SEric W. Biederman rcu_read_unlock(); 20571da177e4SLinus Torvalds if (!task) 20581da177e4SLinus Torvalds goto out; 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, PROC_TGID_INO); 2061cd6a3ce9SEric W. Biederman if (!inode) 2062cd6a3ce9SEric W. Biederman goto out_put_task; 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 20651da177e4SLinus Torvalds inode->i_op = &proc_tgid_base_inode_operations; 20661da177e4SLinus Torvalds inode->i_fop = &proc_tgid_base_operations; 20671da177e4SLinus Torvalds inode->i_flags|=S_IMMUTABLE; 2068bcf88e11SDaniel Drake #ifdef CONFIG_SECURITY 2069bcf88e11SDaniel Drake inode->i_nlink = 5; 2070bcf88e11SDaniel Drake #else 2071bcf88e11SDaniel Drake inode->i_nlink = 4; 2072bcf88e11SDaniel Drake #endif 20731da177e4SLinus Torvalds 207448e6484dSEric W. Biederman dentry->d_op = &pid_dentry_operations; 20751da177e4SLinus Torvalds 20761da177e4SLinus Torvalds d_add(dentry, inode); 2077cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2078cd6a3ce9SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2079cd6a3ce9SEric W. Biederman result = NULL; 208048e6484dSEric W. Biederman 2081cd6a3ce9SEric W. Biederman out_put_task: 208248e6484dSEric W. Biederman put_task_struct(task); 20831da177e4SLinus Torvalds out: 2084cd6a3ce9SEric W. Biederman return result; 20851da177e4SLinus Torvalds } 20861da177e4SLinus Torvalds 20871da177e4SLinus Torvalds /* SMP-safe */ 20881da177e4SLinus Torvalds static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 20891da177e4SLinus Torvalds { 2090cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 20911da177e4SLinus Torvalds struct task_struct *task; 209299f89551SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 20931da177e4SLinus Torvalds struct inode *inode; 20941da177e4SLinus Torvalds unsigned tid; 20951da177e4SLinus Torvalds 209699f89551SEric W. Biederman if (!leader) 209799f89551SEric W. Biederman goto out_no_task; 209899f89551SEric W. Biederman 20991da177e4SLinus Torvalds tid = name_to_int(dentry); 21001da177e4SLinus Torvalds if (tid == ~0U) 21011da177e4SLinus Torvalds goto out; 21021da177e4SLinus Torvalds 2103de758734SEric W. Biederman rcu_read_lock(); 21041da177e4SLinus Torvalds task = find_task_by_pid(tid); 21051da177e4SLinus Torvalds if (task) 21061da177e4SLinus Torvalds get_task_struct(task); 2107de758734SEric W. Biederman rcu_read_unlock(); 21081da177e4SLinus Torvalds if (!task) 21091da177e4SLinus Torvalds goto out; 21101da177e4SLinus Torvalds if (leader->tgid != task->tgid) 21111da177e4SLinus Torvalds goto out_drop_task; 21121da177e4SLinus Torvalds 21131da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_INO); 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds if (!inode) 21171da177e4SLinus Torvalds goto out_drop_task; 21181da177e4SLinus Torvalds inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 21191da177e4SLinus Torvalds inode->i_op = &proc_tid_base_inode_operations; 21201da177e4SLinus Torvalds inode->i_fop = &proc_tid_base_operations; 21211da177e4SLinus Torvalds inode->i_flags|=S_IMMUTABLE; 2122bcf88e11SDaniel Drake #ifdef CONFIG_SECURITY 2123bcf88e11SDaniel Drake inode->i_nlink = 4; 2124bcf88e11SDaniel Drake #else 2125bcf88e11SDaniel Drake inode->i_nlink = 3; 2126bcf88e11SDaniel Drake #endif 21271da177e4SLinus Torvalds 212848e6484dSEric W. Biederman dentry->d_op = &pid_dentry_operations; 21291da177e4SLinus Torvalds 21301da177e4SLinus Torvalds d_add(dentry, inode); 2131cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2132cd6a3ce9SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2133cd6a3ce9SEric W. Biederman result = NULL; 21341da177e4SLinus Torvalds 21351da177e4SLinus Torvalds out_drop_task: 21361da177e4SLinus Torvalds put_task_struct(task); 21371da177e4SLinus Torvalds out: 213899f89551SEric W. Biederman put_task_struct(leader); 213999f89551SEric W. Biederman out_no_task: 2140cd6a3ce9SEric W. Biederman return result; 21411da177e4SLinus Torvalds } 21421da177e4SLinus Torvalds 21431da177e4SLinus Torvalds /* 21440bc58a91SEric W. Biederman * Find the first tgid to return to user space. 21450bc58a91SEric W. Biederman * 21460bc58a91SEric W. Biederman * Usually this is just whatever follows &init_task, but if the users 21470bc58a91SEric W. Biederman * buffer was too small to hold the full list or there was a seek into 21480bc58a91SEric W. Biederman * the middle of the directory we have more work to do. 21490bc58a91SEric W. Biederman * 21500bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 21510bc58a91SEric W. Biederman * 21520bc58a91SEric W. Biederman * In the case of a seek we start with &init_task and walk nr 21530bc58a91SEric W. Biederman * threads past it. 21541da177e4SLinus Torvalds */ 21559cc8cbc7SEric W. Biederman static struct task_struct *first_tgid(int tgid, unsigned int nr) 21561da177e4SLinus Torvalds { 21579cc8cbc7SEric W. Biederman struct task_struct *pos; 2158454cc105SEric W. Biederman rcu_read_lock(); 21590bc58a91SEric W. Biederman if (tgid && nr) { 21600bc58a91SEric W. Biederman pos = find_task_by_pid(tgid); 21619cc8cbc7SEric W. Biederman if (pos && thread_group_leader(pos)) 21629cc8cbc7SEric W. Biederman goto found; 21631da177e4SLinus Torvalds } 21640bc58a91SEric W. Biederman /* If nr exceeds the number of processes get out quickly */ 21659cc8cbc7SEric W. Biederman pos = NULL; 21660bc58a91SEric W. Biederman if (nr && nr >= nr_processes()) 21670bc58a91SEric W. Biederman goto done; 21681da177e4SLinus Torvalds 21690bc58a91SEric W. Biederman /* If we haven't found our starting place yet start with 21700bc58a91SEric W. Biederman * the init_task and walk nr tasks forward. 21710bc58a91SEric W. Biederman */ 21729cc8cbc7SEric W. Biederman for (pos = next_task(&init_task); nr > 0; --nr) { 21739cc8cbc7SEric W. Biederman pos = next_task(pos); 21749cc8cbc7SEric W. Biederman if (pos == &init_task) { 21759cc8cbc7SEric W. Biederman pos = NULL; 21760bc58a91SEric W. Biederman goto done; 21771da177e4SLinus Torvalds } 21789cc8cbc7SEric W. Biederman } 21799cc8cbc7SEric W. Biederman found: 21809cc8cbc7SEric W. Biederman get_task_struct(pos); 21810bc58a91SEric W. Biederman done: 2182454cc105SEric W. Biederman rcu_read_unlock(); 21830bc58a91SEric W. Biederman return pos; 21841da177e4SLinus Torvalds } 21851da177e4SLinus Torvalds 21861da177e4SLinus Torvalds /* 21870bc58a91SEric W. Biederman * Find the next task in the task list. 21880bc58a91SEric W. Biederman * Return NULL if we loop or there is any error. 21890bc58a91SEric W. Biederman * 21900bc58a91SEric W. Biederman * The reference to the input task_struct is released. 21911da177e4SLinus Torvalds */ 21920bc58a91SEric W. Biederman static struct task_struct *next_tgid(struct task_struct *start) 21931da177e4SLinus Torvalds { 21940bc58a91SEric W. Biederman struct task_struct *pos; 2195454cc105SEric W. Biederman rcu_read_lock(); 21960bc58a91SEric W. Biederman pos = start; 21970bc58a91SEric W. Biederman if (pid_alive(start)) 21980bc58a91SEric W. Biederman pos = next_task(start); 21990bc58a91SEric W. Biederman if (pid_alive(pos) && (pos != &init_task)) { 22000bc58a91SEric W. Biederman get_task_struct(pos); 22010bc58a91SEric W. Biederman goto done; 22020bc58a91SEric W. Biederman } 22030bc58a91SEric W. Biederman pos = NULL; 22040bc58a91SEric W. Biederman done: 2205454cc105SEric W. Biederman rcu_read_unlock(); 22060bc58a91SEric W. Biederman put_task_struct(start); 22070bc58a91SEric W. Biederman return pos; 22081da177e4SLinus Torvalds } 22091da177e4SLinus Torvalds 22101da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 22111da177e4SLinus Torvalds int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir) 22121da177e4SLinus Torvalds { 22131da177e4SLinus Torvalds char buf[PROC_NUMBUF]; 22141da177e4SLinus Torvalds unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY; 22150bc58a91SEric W. Biederman struct task_struct *task; 22160bc58a91SEric W. Biederman int tgid; 22171da177e4SLinus Torvalds 22181da177e4SLinus Torvalds if (!nr) { 22191da177e4SLinus Torvalds ino_t ino = fake_ino(0,PROC_TGID_INO); 22201da177e4SLinus Torvalds if (filldir(dirent, "self", 4, filp->f_pos, ino, DT_LNK) < 0) 22211da177e4SLinus Torvalds return 0; 22221da177e4SLinus Torvalds filp->f_pos++; 22231da177e4SLinus Torvalds nr++; 22241da177e4SLinus Torvalds } 22250bc58a91SEric W. Biederman nr -= 1; 22261da177e4SLinus Torvalds 22271da177e4SLinus Torvalds /* f_version caches the tgid value that the last readdir call couldn't 22281da177e4SLinus Torvalds * return. lseek aka telldir automagically resets f_version to 0. 22291da177e4SLinus Torvalds */ 22300bc58a91SEric W. Biederman tgid = filp->f_version; 22311da177e4SLinus Torvalds filp->f_version = 0; 22320bc58a91SEric W. Biederman for (task = first_tgid(tgid, nr); 22330bc58a91SEric W. Biederman task; 22340bc58a91SEric W. Biederman task = next_tgid(task), filp->f_pos++) { 22350bc58a91SEric W. Biederman int len; 22360bc58a91SEric W. Biederman ino_t ino; 22370bc58a91SEric W. Biederman tgid = task->pid; 22380bc58a91SEric W. Biederman len = snprintf(buf, sizeof(buf), "%d", tgid); 22390bc58a91SEric W. Biederman ino = fake_ino(tgid, PROC_TGID_INO); 22400bc58a91SEric W. Biederman if (filldir(dirent, buf, len, filp->f_pos, ino, DT_DIR) < 0) { 22411da177e4SLinus Torvalds /* returning this tgid failed, save it as the first 22421da177e4SLinus Torvalds * pid for the next readir call */ 22430bc58a91SEric W. Biederman filp->f_version = tgid; 22440bc58a91SEric W. Biederman put_task_struct(task); 22450bc58a91SEric W. Biederman break; 22461da177e4SLinus Torvalds } 22471da177e4SLinus Torvalds } 22481da177e4SLinus Torvalds return 0; 22491da177e4SLinus Torvalds } 22501da177e4SLinus Torvalds 22510bc58a91SEric W. Biederman /* 22520bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 22530bc58a91SEric W. Biederman * 22540bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 22550bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 22560bc58a91SEric W. Biederman * directory we have more work todo. 22570bc58a91SEric W. Biederman * 22580bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 22590bc58a91SEric W. Biederman * 22600bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 22610bc58a91SEric W. Biederman * threads past it. 22620bc58a91SEric W. Biederman */ 2263cc288738SEric W. Biederman static struct task_struct *first_tid(struct task_struct *leader, 2264cc288738SEric W. Biederman int tid, int nr) 22650bc58a91SEric W. Biederman { 2266a872ff0cSOleg Nesterov struct task_struct *pos; 22670bc58a91SEric W. Biederman 2268cc288738SEric W. Biederman rcu_read_lock(); 22690bc58a91SEric W. Biederman /* Attempt to start with the pid of a thread */ 22700bc58a91SEric W. Biederman if (tid && (nr > 0)) { 22710bc58a91SEric W. Biederman pos = find_task_by_pid(tid); 2272a872ff0cSOleg Nesterov if (pos && (pos->group_leader == leader)) 2273a872ff0cSOleg Nesterov goto found; 22740bc58a91SEric W. Biederman } 22750bc58a91SEric W. Biederman 22760bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 22770bc58a91SEric W. Biederman pos = NULL; 2278a872ff0cSOleg Nesterov if (nr && nr >= get_nr_threads(leader)) 2279a872ff0cSOleg Nesterov goto out; 2280a872ff0cSOleg Nesterov 2281a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 2282a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 2283a872ff0cSOleg Nesterov */ 2284a872ff0cSOleg Nesterov for (pos = leader; nr > 0; --nr) { 2285a872ff0cSOleg Nesterov pos = next_thread(pos); 2286a872ff0cSOleg Nesterov if (pos == leader) { 2287a872ff0cSOleg Nesterov pos = NULL; 2288a872ff0cSOleg Nesterov goto out; 2289a872ff0cSOleg Nesterov } 2290a872ff0cSOleg Nesterov } 2291a872ff0cSOleg Nesterov found: 2292a872ff0cSOleg Nesterov get_task_struct(pos); 2293a872ff0cSOleg Nesterov out: 2294cc288738SEric W. Biederman rcu_read_unlock(); 22950bc58a91SEric W. Biederman return pos; 22960bc58a91SEric W. Biederman } 22970bc58a91SEric W. Biederman 22980bc58a91SEric W. Biederman /* 22990bc58a91SEric W. Biederman * Find the next thread in the thread list. 23000bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 23010bc58a91SEric W. Biederman * 23020bc58a91SEric W. Biederman * The reference to the input task_struct is released. 23030bc58a91SEric W. Biederman */ 23040bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 23050bc58a91SEric W. Biederman { 2306c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 2307cc288738SEric W. Biederman rcu_read_lock(); 2308c1df7fb8SOleg Nesterov if (pid_alive(start)) { 23090bc58a91SEric W. Biederman pos = next_thread(start); 2310c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 23110bc58a91SEric W. Biederman pos = NULL; 2312c1df7fb8SOleg Nesterov else 2313c1df7fb8SOleg Nesterov get_task_struct(pos); 2314c1df7fb8SOleg Nesterov } 2315cc288738SEric W. Biederman rcu_read_unlock(); 23160bc58a91SEric W. Biederman put_task_struct(start); 23170bc58a91SEric W. Biederman return pos; 23180bc58a91SEric W. Biederman } 23190bc58a91SEric W. Biederman 23201da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 23211da177e4SLinus Torvalds static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir) 23221da177e4SLinus Torvalds { 23231da177e4SLinus Torvalds char buf[PROC_NUMBUF]; 23241da177e4SLinus Torvalds struct dentry *dentry = filp->f_dentry; 23251da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 232699f89551SEric W. Biederman struct task_struct *leader = get_proc_task(inode); 23270bc58a91SEric W. Biederman struct task_struct *task; 23281da177e4SLinus Torvalds int retval = -ENOENT; 23291da177e4SLinus Torvalds ino_t ino; 23300bc58a91SEric W. Biederman int tid; 23311da177e4SLinus Torvalds unsigned long pos = filp->f_pos; /* avoiding "long long" filp->f_pos */ 23321da177e4SLinus Torvalds 233399f89551SEric W. Biederman if (!leader) 233499f89551SEric W. Biederman goto out_no_task; 23351da177e4SLinus Torvalds retval = 0; 23361da177e4SLinus Torvalds 23371da177e4SLinus Torvalds switch (pos) { 23381da177e4SLinus Torvalds case 0: 23391da177e4SLinus Torvalds ino = inode->i_ino; 23401da177e4SLinus Torvalds if (filldir(dirent, ".", 1, pos, ino, DT_DIR) < 0) 23411da177e4SLinus Torvalds goto out; 23421da177e4SLinus Torvalds pos++; 23431da177e4SLinus Torvalds /* fall through */ 23441da177e4SLinus Torvalds case 1: 23451da177e4SLinus Torvalds ino = parent_ino(dentry); 23461da177e4SLinus Torvalds if (filldir(dirent, "..", 2, pos, ino, DT_DIR) < 0) 23471da177e4SLinus Torvalds goto out; 23481da177e4SLinus Torvalds pos++; 23491da177e4SLinus Torvalds /* fall through */ 23501da177e4SLinus Torvalds } 23511da177e4SLinus Torvalds 23520bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 23530bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 23540bc58a91SEric W. Biederman */ 23550bc58a91SEric W. Biederman tid = filp->f_version; 23560bc58a91SEric W. Biederman filp->f_version = 0; 23570bc58a91SEric W. Biederman for (task = first_tid(leader, tid, pos - 2); 23580bc58a91SEric W. Biederman task; 23590bc58a91SEric W. Biederman task = next_tid(task), pos++) { 23600bc58a91SEric W. Biederman int len; 23610bc58a91SEric W. Biederman tid = task->pid; 23620bc58a91SEric W. Biederman len = snprintf(buf, sizeof(buf), "%d", tid); 23631da177e4SLinus Torvalds ino = fake_ino(tid, PROC_TID_INO); 23640bc58a91SEric W. Biederman if (filldir(dirent, buf, len, pos, ino, DT_DIR < 0)) { 23650bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 23660bc58a91SEric W. Biederman * pid for the next readir call */ 23670bc58a91SEric W. Biederman filp->f_version = tid; 23680bc58a91SEric W. Biederman put_task_struct(task); 23691da177e4SLinus Torvalds break; 23700bc58a91SEric W. Biederman } 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds out: 23731da177e4SLinus Torvalds filp->f_pos = pos; 237499f89551SEric W. Biederman put_task_struct(leader); 237599f89551SEric W. Biederman out_no_task: 23761da177e4SLinus Torvalds return retval; 23771da177e4SLinus Torvalds } 23786e66b52bSEric W. Biederman 23796e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 23806e66b52bSEric W. Biederman { 23816e66b52bSEric W. Biederman struct inode *inode = dentry->d_inode; 238299f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 23836e66b52bSEric W. Biederman generic_fillattr(inode, stat); 23846e66b52bSEric W. Biederman 238599f89551SEric W. Biederman if (p) { 238699f89551SEric W. Biederman rcu_read_lock(); 238799f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 238899f89551SEric W. Biederman rcu_read_unlock(); 238999f89551SEric W. Biederman put_task_struct(p); 23906e66b52bSEric W. Biederman } 23916e66b52bSEric W. Biederman 23926e66b52bSEric W. Biederman return 0; 23936e66b52bSEric W. Biederman } 2394