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/config.h> 531da177e4SLinus Torvalds #include <linux/errno.h> 541da177e4SLinus Torvalds #include <linux/time.h> 551da177e4SLinus Torvalds #include <linux/proc_fs.h> 561da177e4SLinus Torvalds #include <linux/stat.h> 571da177e4SLinus Torvalds #include <linux/init.h> 5816f7e0feSRandy Dunlap #include <linux/capability.h> 591da177e4SLinus Torvalds #include <linux/file.h> 601da177e4SLinus Torvalds #include <linux/string.h> 611da177e4SLinus Torvalds #include <linux/seq_file.h> 621da177e4SLinus Torvalds #include <linux/namei.h> 631da177e4SLinus Torvalds #include <linux/namespace.h> 641da177e4SLinus Torvalds #include <linux/mm.h> 651da177e4SLinus Torvalds #include <linux/smp_lock.h> 66b835996fSDipankar Sarma #include <linux/rcupdate.h> 671da177e4SLinus Torvalds #include <linux/kallsyms.h> 681da177e4SLinus Torvalds #include <linux/mount.h> 691da177e4SLinus Torvalds #include <linux/security.h> 701da177e4SLinus Torvalds #include <linux/ptrace.h> 711da177e4SLinus Torvalds #include <linux/seccomp.h> 721da177e4SLinus Torvalds #include <linux/cpuset.h> 731da177e4SLinus Torvalds #include <linux/audit.h> 745addc5ddSAl Viro #include <linux/poll.h> 751da177e4SLinus Torvalds #include "internal.h" 761da177e4SLinus Torvalds 770f2fe20fSEric W. Biederman /* NOTE: 780f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 790f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 800f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 810f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 820f2fe20fSEric W. Biederman * 830f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 840f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 850f2fe20fSEric W. Biederman */ 860f2fe20fSEric W. Biederman 871da177e4SLinus Torvalds /* 881da177e4SLinus Torvalds * For hysterical raisins we keep the same inumbers as in the old procfs. 891da177e4SLinus Torvalds * Feel free to change the macro below - just keep the range distinct from 901da177e4SLinus Torvalds * inumbers of the rest of procfs (currently those are in 0x0000--0xffff). 911da177e4SLinus Torvalds * As soon as we'll get a separate superblock we will be able to forget 921da177e4SLinus Torvalds * about magical ranges too. 931da177e4SLinus Torvalds */ 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds #define fake_ino(pid,ino) (((pid)<<16)|(ino)) 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds enum pid_directory_inos { 981da177e4SLinus Torvalds PROC_TGID_INO = 2, 991da177e4SLinus Torvalds PROC_TGID_TASK, 1001da177e4SLinus Torvalds PROC_TGID_STATUS, 1011da177e4SLinus Torvalds PROC_TGID_MEM, 1021da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 1031da177e4SLinus Torvalds PROC_TGID_SECCOMP, 1041da177e4SLinus Torvalds #endif 1051da177e4SLinus Torvalds PROC_TGID_CWD, 1061da177e4SLinus Torvalds PROC_TGID_ROOT, 1071da177e4SLinus Torvalds PROC_TGID_EXE, 1081da177e4SLinus Torvalds PROC_TGID_FD, 1091da177e4SLinus Torvalds PROC_TGID_ENVIRON, 1101da177e4SLinus Torvalds PROC_TGID_AUXV, 1111da177e4SLinus Torvalds PROC_TGID_CMDLINE, 1121da177e4SLinus Torvalds PROC_TGID_STAT, 1131da177e4SLinus Torvalds PROC_TGID_STATM, 1141da177e4SLinus Torvalds PROC_TGID_MAPS, 1156e21c8f1SChristoph Lameter PROC_TGID_NUMA_MAPS, 1161da177e4SLinus Torvalds PROC_TGID_MOUNTS, 117b4629fe2SChuck Lever PROC_TGID_MOUNTSTATS, 1181da177e4SLinus Torvalds PROC_TGID_WCHAN, 11963c6764cSYoshinori Sato #ifdef CONFIG_MMU 120e070ad49SMauricio Lin PROC_TGID_SMAPS, 12163c6764cSYoshinori Sato #endif 1221da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 1231da177e4SLinus Torvalds PROC_TGID_SCHEDSTAT, 1241da177e4SLinus Torvalds #endif 1251da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 1261da177e4SLinus Torvalds PROC_TGID_CPUSET, 1271da177e4SLinus Torvalds #endif 1281da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 1291da177e4SLinus Torvalds PROC_TGID_ATTR, 1301da177e4SLinus Torvalds PROC_TGID_ATTR_CURRENT, 1311da177e4SLinus Torvalds PROC_TGID_ATTR_PREV, 1321da177e4SLinus Torvalds PROC_TGID_ATTR_EXEC, 1331da177e4SLinus Torvalds PROC_TGID_ATTR_FSCREATE, 1344eb582cfSMichael LeMay PROC_TGID_ATTR_KEYCREATE, 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, 1771da177e4SLinus Torvalds #endif 1781da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 1791da177e4SLinus Torvalds PROC_TID_LOGINUID, 1801da177e4SLinus Torvalds #endif 1811da177e4SLinus Torvalds PROC_TID_OOM_SCORE, 1821da177e4SLinus Torvalds PROC_TID_OOM_ADJUST, 1835e21ccb1SMiklos Szeredi 1845e21ccb1SMiklos Szeredi /* Add new entries before this */ 1855e21ccb1SMiklos Szeredi PROC_TID_FD_DIR = 0x8000, /* 0x8000-0xffff */ 1861da177e4SLinus Torvalds }; 1871da177e4SLinus Torvalds 1888578cea7SEric W. Biederman /* Worst case buffer size needed for holding an integer. */ 1898578cea7SEric W. Biederman #define PROC_NUMBUF 10 1908578cea7SEric W. Biederman 1911da177e4SLinus Torvalds struct pid_entry { 1921da177e4SLinus Torvalds int type; 1931da177e4SLinus Torvalds int len; 1941da177e4SLinus Torvalds char *name; 1951da177e4SLinus Torvalds mode_t mode; 1961da177e4SLinus Torvalds }; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds #define E(type,name,mode) {(type),sizeof(name)-1,(name),(mode)} 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds static struct pid_entry tgid_base_stuff[] = { 2011da177e4SLinus Torvalds E(PROC_TGID_TASK, "task", S_IFDIR|S_IRUGO|S_IXUGO), 2021da177e4SLinus Torvalds E(PROC_TGID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR), 2031da177e4SLinus Torvalds E(PROC_TGID_ENVIRON, "environ", S_IFREG|S_IRUSR), 2041da177e4SLinus Torvalds E(PROC_TGID_AUXV, "auxv", S_IFREG|S_IRUSR), 2051da177e4SLinus Torvalds E(PROC_TGID_STATUS, "status", S_IFREG|S_IRUGO), 2061da177e4SLinus Torvalds E(PROC_TGID_CMDLINE, "cmdline", S_IFREG|S_IRUGO), 2071da177e4SLinus Torvalds E(PROC_TGID_STAT, "stat", S_IFREG|S_IRUGO), 2081da177e4SLinus Torvalds E(PROC_TGID_STATM, "statm", S_IFREG|S_IRUGO), 2091da177e4SLinus Torvalds E(PROC_TGID_MAPS, "maps", S_IFREG|S_IRUGO), 2106e21c8f1SChristoph Lameter #ifdef CONFIG_NUMA 2116e21c8f1SChristoph Lameter E(PROC_TGID_NUMA_MAPS, "numa_maps", S_IFREG|S_IRUGO), 2126e21c8f1SChristoph Lameter #endif 2131da177e4SLinus Torvalds E(PROC_TGID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR), 2141da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 2151da177e4SLinus Torvalds E(PROC_TGID_SECCOMP, "seccomp", S_IFREG|S_IRUSR|S_IWUSR), 2161da177e4SLinus Torvalds #endif 2171da177e4SLinus Torvalds E(PROC_TGID_CWD, "cwd", S_IFLNK|S_IRWXUGO), 2181da177e4SLinus Torvalds E(PROC_TGID_ROOT, "root", S_IFLNK|S_IRWXUGO), 2191da177e4SLinus Torvalds E(PROC_TGID_EXE, "exe", S_IFLNK|S_IRWXUGO), 2201da177e4SLinus Torvalds E(PROC_TGID_MOUNTS, "mounts", S_IFREG|S_IRUGO), 221b4629fe2SChuck Lever E(PROC_TGID_MOUNTSTATS, "mountstats", S_IFREG|S_IRUSR), 22263c6764cSYoshinori Sato #ifdef CONFIG_MMU 223e070ad49SMauricio Lin E(PROC_TGID_SMAPS, "smaps", S_IFREG|S_IRUGO), 22463c6764cSYoshinori Sato #endif 2251da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 2261da177e4SLinus Torvalds E(PROC_TGID_ATTR, "attr", S_IFDIR|S_IRUGO|S_IXUGO), 2271da177e4SLinus Torvalds #endif 2281da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 2291da177e4SLinus Torvalds E(PROC_TGID_WCHAN, "wchan", S_IFREG|S_IRUGO), 2301da177e4SLinus Torvalds #endif 2311da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 2321da177e4SLinus Torvalds E(PROC_TGID_SCHEDSTAT, "schedstat", S_IFREG|S_IRUGO), 2331da177e4SLinus Torvalds #endif 2341da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 2351da177e4SLinus Torvalds E(PROC_TGID_CPUSET, "cpuset", S_IFREG|S_IRUGO), 2361da177e4SLinus Torvalds #endif 2371da177e4SLinus Torvalds E(PROC_TGID_OOM_SCORE, "oom_score",S_IFREG|S_IRUGO), 2381da177e4SLinus Torvalds E(PROC_TGID_OOM_ADJUST,"oom_adj", S_IFREG|S_IRUGO|S_IWUSR), 2391da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 2401da177e4SLinus Torvalds E(PROC_TGID_LOGINUID, "loginuid", S_IFREG|S_IWUSR|S_IRUGO), 2411da177e4SLinus Torvalds #endif 2421da177e4SLinus Torvalds {0,0,NULL,0} 2431da177e4SLinus Torvalds }; 2441da177e4SLinus Torvalds static struct pid_entry tid_base_stuff[] = { 2451da177e4SLinus Torvalds E(PROC_TID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR), 2461da177e4SLinus Torvalds E(PROC_TID_ENVIRON, "environ", S_IFREG|S_IRUSR), 2471da177e4SLinus Torvalds E(PROC_TID_AUXV, "auxv", S_IFREG|S_IRUSR), 2481da177e4SLinus Torvalds E(PROC_TID_STATUS, "status", S_IFREG|S_IRUGO), 2491da177e4SLinus Torvalds E(PROC_TID_CMDLINE, "cmdline", S_IFREG|S_IRUGO), 2501da177e4SLinus Torvalds E(PROC_TID_STAT, "stat", S_IFREG|S_IRUGO), 2511da177e4SLinus Torvalds E(PROC_TID_STATM, "statm", S_IFREG|S_IRUGO), 2521da177e4SLinus Torvalds E(PROC_TID_MAPS, "maps", S_IFREG|S_IRUGO), 2536e21c8f1SChristoph Lameter #ifdef CONFIG_NUMA 2546e21c8f1SChristoph Lameter E(PROC_TID_NUMA_MAPS, "numa_maps", S_IFREG|S_IRUGO), 2556e21c8f1SChristoph Lameter #endif 2561da177e4SLinus Torvalds E(PROC_TID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR), 2571da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 2581da177e4SLinus Torvalds E(PROC_TID_SECCOMP, "seccomp", S_IFREG|S_IRUSR|S_IWUSR), 2591da177e4SLinus Torvalds #endif 2601da177e4SLinus Torvalds E(PROC_TID_CWD, "cwd", S_IFLNK|S_IRWXUGO), 2611da177e4SLinus Torvalds E(PROC_TID_ROOT, "root", S_IFLNK|S_IRWXUGO), 2621da177e4SLinus Torvalds E(PROC_TID_EXE, "exe", S_IFLNK|S_IRWXUGO), 2631da177e4SLinus Torvalds E(PROC_TID_MOUNTS, "mounts", S_IFREG|S_IRUGO), 26463c6764cSYoshinori Sato #ifdef CONFIG_MMU 265e070ad49SMauricio Lin E(PROC_TID_SMAPS, "smaps", S_IFREG|S_IRUGO), 26663c6764cSYoshinori Sato #endif 2671da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 2681da177e4SLinus Torvalds E(PROC_TID_ATTR, "attr", S_IFDIR|S_IRUGO|S_IXUGO), 2691da177e4SLinus Torvalds #endif 2701da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 2711da177e4SLinus Torvalds E(PROC_TID_WCHAN, "wchan", S_IFREG|S_IRUGO), 2721da177e4SLinus Torvalds #endif 2731da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 2741da177e4SLinus Torvalds E(PROC_TID_SCHEDSTAT, "schedstat",S_IFREG|S_IRUGO), 2751da177e4SLinus Torvalds #endif 2761da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 2771da177e4SLinus Torvalds E(PROC_TID_CPUSET, "cpuset", S_IFREG|S_IRUGO), 2781da177e4SLinus Torvalds #endif 2791da177e4SLinus Torvalds E(PROC_TID_OOM_SCORE, "oom_score",S_IFREG|S_IRUGO), 2801da177e4SLinus Torvalds E(PROC_TID_OOM_ADJUST, "oom_adj", S_IFREG|S_IRUGO|S_IWUSR), 2811da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 2821da177e4SLinus Torvalds E(PROC_TID_LOGINUID, "loginuid", S_IFREG|S_IWUSR|S_IRUGO), 2831da177e4SLinus Torvalds #endif 2841da177e4SLinus Torvalds {0,0,NULL,0} 2851da177e4SLinus Torvalds }; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 2881da177e4SLinus Torvalds static struct pid_entry tgid_attr_stuff[] = { 2891da177e4SLinus Torvalds E(PROC_TGID_ATTR_CURRENT, "current", S_IFREG|S_IRUGO|S_IWUGO), 2901da177e4SLinus Torvalds E(PROC_TGID_ATTR_PREV, "prev", S_IFREG|S_IRUGO), 2911da177e4SLinus Torvalds E(PROC_TGID_ATTR_EXEC, "exec", S_IFREG|S_IRUGO|S_IWUGO), 2921da177e4SLinus Torvalds E(PROC_TGID_ATTR_FSCREATE, "fscreate", S_IFREG|S_IRUGO|S_IWUGO), 2934eb582cfSMichael LeMay E(PROC_TGID_ATTR_KEYCREATE, "keycreate", S_IFREG|S_IRUGO|S_IWUGO), 2941da177e4SLinus Torvalds {0,0,NULL,0} 2951da177e4SLinus Torvalds }; 2961da177e4SLinus Torvalds static struct pid_entry tid_attr_stuff[] = { 2971da177e4SLinus Torvalds E(PROC_TID_ATTR_CURRENT, "current", S_IFREG|S_IRUGO|S_IWUGO), 2981da177e4SLinus Torvalds E(PROC_TID_ATTR_PREV, "prev", S_IFREG|S_IRUGO), 2991da177e4SLinus Torvalds E(PROC_TID_ATTR_EXEC, "exec", S_IFREG|S_IRUGO|S_IWUGO), 3001da177e4SLinus Torvalds E(PROC_TID_ATTR_FSCREATE, "fscreate", S_IFREG|S_IRUGO|S_IWUGO), 3014eb582cfSMichael LeMay E(PROC_TID_ATTR_KEYCREATE, "keycreate", S_IFREG|S_IRUGO|S_IWUGO), 3021da177e4SLinus Torvalds {0,0,NULL,0} 3031da177e4SLinus Torvalds }; 3041da177e4SLinus Torvalds #endif 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds #undef E 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt) 3091da177e4SLinus Torvalds { 310*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 311*99f89551SEric W. Biederman struct files_struct *files = NULL; 3121da177e4SLinus Torvalds struct file *file; 313aed7a6c4SEric W. Biederman int fd = proc_fd(inode); 3141da177e4SLinus Torvalds 315*99f89551SEric W. Biederman if (task) { 3161da177e4SLinus Torvalds files = get_files_struct(task); 317*99f89551SEric W. Biederman put_task_struct(task); 318*99f89551SEric W. Biederman } 3191da177e4SLinus Torvalds if (files) { 320ca99c1daSDipankar Sarma /* 321ca99c1daSDipankar Sarma * We are not taking a ref to the file structure, so we must 322ca99c1daSDipankar Sarma * hold ->file_lock. 323ca99c1daSDipankar Sarma */ 324ca99c1daSDipankar Sarma spin_lock(&files->file_lock); 3251da177e4SLinus Torvalds file = fcheck_files(files, fd); 3261da177e4SLinus Torvalds if (file) { 3271da177e4SLinus Torvalds *mnt = mntget(file->f_vfsmnt); 3281da177e4SLinus Torvalds *dentry = dget(file->f_dentry); 329ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 3301da177e4SLinus Torvalds put_files_struct(files); 3311da177e4SLinus Torvalds return 0; 3321da177e4SLinus Torvalds } 333ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 3341da177e4SLinus Torvalds put_files_struct(files); 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds return -ENOENT; 3371da177e4SLinus Torvalds } 3381da177e4SLinus Torvalds 3390494f6ecSMiklos Szeredi static struct fs_struct *get_fs_struct(struct task_struct *task) 3401da177e4SLinus Torvalds { 3411da177e4SLinus Torvalds struct fs_struct *fs; 3420494f6ecSMiklos Szeredi task_lock(task); 3430494f6ecSMiklos Szeredi fs = task->fs; 3441da177e4SLinus Torvalds if(fs) 3451da177e4SLinus Torvalds atomic_inc(&fs->count); 3460494f6ecSMiklos Szeredi task_unlock(task); 3470494f6ecSMiklos Szeredi return fs; 3480494f6ecSMiklos Szeredi } 3490494f6ecSMiklos Szeredi 350*99f89551SEric W. Biederman static int get_nr_threads(struct task_struct *tsk) 351*99f89551SEric W. Biederman { 352*99f89551SEric W. Biederman /* Must be called with the rcu_read_lock held */ 353*99f89551SEric W. Biederman unsigned long flags; 354*99f89551SEric W. Biederman int count = 0; 355*99f89551SEric W. Biederman 356*99f89551SEric W. Biederman if (lock_task_sighand(tsk, &flags)) { 357*99f89551SEric W. Biederman count = atomic_read(&tsk->signal->count); 358*99f89551SEric W. Biederman unlock_task_sighand(tsk, &flags); 359*99f89551SEric W. Biederman } 360*99f89551SEric W. Biederman return count; 361*99f89551SEric W. Biederman } 362*99f89551SEric W. Biederman 3630494f6ecSMiklos Szeredi static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt) 3640494f6ecSMiklos Szeredi { 365*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 366*99f89551SEric W. Biederman struct fs_struct *fs = NULL; 3670494f6ecSMiklos Szeredi int result = -ENOENT; 368*99f89551SEric W. Biederman 369*99f89551SEric W. Biederman if (task) { 370*99f89551SEric W. Biederman fs = get_fs_struct(task); 371*99f89551SEric W. Biederman put_task_struct(task); 372*99f89551SEric W. Biederman } 3731da177e4SLinus Torvalds if (fs) { 3741da177e4SLinus Torvalds read_lock(&fs->lock); 3751da177e4SLinus Torvalds *mnt = mntget(fs->pwdmnt); 3761da177e4SLinus Torvalds *dentry = dget(fs->pwd); 3771da177e4SLinus Torvalds read_unlock(&fs->lock); 3781da177e4SLinus Torvalds result = 0; 3791da177e4SLinus Torvalds put_fs_struct(fs); 3801da177e4SLinus Torvalds } 3811da177e4SLinus Torvalds return result; 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt) 3851da177e4SLinus Torvalds { 386*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 387*99f89551SEric W. Biederman struct fs_struct *fs = NULL; 3881da177e4SLinus Torvalds int result = -ENOENT; 389*99f89551SEric W. Biederman 390*99f89551SEric W. Biederman if (task) { 391*99f89551SEric W. Biederman fs = get_fs_struct(task); 392*99f89551SEric W. Biederman put_task_struct(task); 393*99f89551SEric W. Biederman } 3941da177e4SLinus Torvalds if (fs) { 3951da177e4SLinus Torvalds read_lock(&fs->lock); 3961da177e4SLinus Torvalds *mnt = mntget(fs->rootmnt); 3971da177e4SLinus Torvalds *dentry = dget(fs->root); 3981da177e4SLinus Torvalds read_unlock(&fs->lock); 3991da177e4SLinus Torvalds result = 0; 4001da177e4SLinus Torvalds put_fs_struct(fs); 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds return result; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds #define MAY_PTRACE(task) \ 4061da177e4SLinus Torvalds (task == current || \ 4071da177e4SLinus Torvalds (task->parent == current && \ 4081da177e4SLinus Torvalds (task->ptrace & PT_PTRACED) && \ 4091da177e4SLinus Torvalds (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \ 4101da177e4SLinus Torvalds security_ptrace(current,task) == 0)) 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds static int proc_pid_environ(struct task_struct *task, char * buffer) 4131da177e4SLinus Torvalds { 4141da177e4SLinus Torvalds int res = 0; 4151da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 4161da177e4SLinus Torvalds if (mm) { 4171da177e4SLinus Torvalds unsigned int len = mm->env_end - mm->env_start; 4181da177e4SLinus Torvalds if (len > PAGE_SIZE) 4191da177e4SLinus Torvalds len = PAGE_SIZE; 4201da177e4SLinus Torvalds res = access_process_vm(task, mm->env_start, buffer, len, 0); 421ab8d11beSMiklos Szeredi if (!ptrace_may_attach(task)) 4221da177e4SLinus Torvalds res = -ESRCH; 4231da177e4SLinus Torvalds mmput(mm); 4241da177e4SLinus Torvalds } 4251da177e4SLinus Torvalds return res; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds static int proc_pid_cmdline(struct task_struct *task, char * buffer) 4291da177e4SLinus Torvalds { 4301da177e4SLinus Torvalds int res = 0; 4311da177e4SLinus Torvalds unsigned int len; 4321da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 4331da177e4SLinus Torvalds if (!mm) 4341da177e4SLinus Torvalds goto out; 4351da177e4SLinus Torvalds if (!mm->arg_end) 4361da177e4SLinus Torvalds goto out_mm; /* Shh! No looking before we're done */ 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds len = mm->arg_end - mm->arg_start; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds if (len > PAGE_SIZE) 4411da177e4SLinus Torvalds len = PAGE_SIZE; 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds res = access_process_vm(task, mm->arg_start, buffer, len, 0); 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds // If the nul at the end of args has been overwritten, then 4461da177e4SLinus Torvalds // assume application is using setproctitle(3). 4471da177e4SLinus Torvalds if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) { 4481da177e4SLinus Torvalds len = strnlen(buffer, res); 4491da177e4SLinus Torvalds if (len < res) { 4501da177e4SLinus Torvalds res = len; 4511da177e4SLinus Torvalds } else { 4521da177e4SLinus Torvalds len = mm->env_end - mm->env_start; 4531da177e4SLinus Torvalds if (len > PAGE_SIZE - res) 4541da177e4SLinus Torvalds len = PAGE_SIZE - res; 4551da177e4SLinus Torvalds res += access_process_vm(task, mm->env_start, buffer+res, len, 0); 4561da177e4SLinus Torvalds res = strnlen(buffer, res); 4571da177e4SLinus Torvalds } 4581da177e4SLinus Torvalds } 4591da177e4SLinus Torvalds out_mm: 4601da177e4SLinus Torvalds mmput(mm); 4611da177e4SLinus Torvalds out: 4621da177e4SLinus Torvalds return res; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds static int proc_pid_auxv(struct task_struct *task, char *buffer) 4661da177e4SLinus Torvalds { 4671da177e4SLinus Torvalds int res = 0; 4681da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 4691da177e4SLinus Torvalds if (mm) { 4701da177e4SLinus Torvalds unsigned int nwords = 0; 4711da177e4SLinus Torvalds do 4721da177e4SLinus Torvalds nwords += 2; 4731da177e4SLinus Torvalds while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 4741da177e4SLinus Torvalds res = nwords * sizeof(mm->saved_auxv[0]); 4751da177e4SLinus Torvalds if (res > PAGE_SIZE) 4761da177e4SLinus Torvalds res = PAGE_SIZE; 4771da177e4SLinus Torvalds memcpy(buffer, mm->saved_auxv, res); 4781da177e4SLinus Torvalds mmput(mm); 4791da177e4SLinus Torvalds } 4801da177e4SLinus Torvalds return res; 4811da177e4SLinus Torvalds } 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 4851da177e4SLinus Torvalds /* 4861da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 4871da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 4881da177e4SLinus Torvalds */ 4891da177e4SLinus Torvalds static int proc_pid_wchan(struct task_struct *task, char *buffer) 4901da177e4SLinus Torvalds { 4911da177e4SLinus Torvalds char *modname; 4921da177e4SLinus Torvalds const char *sym_name; 4931da177e4SLinus Torvalds unsigned long wchan, size, offset; 4941da177e4SLinus Torvalds char namebuf[KSYM_NAME_LEN+1]; 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds wchan = get_wchan(task); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds sym_name = kallsyms_lookup(wchan, &size, &offset, &modname, namebuf); 4991da177e4SLinus Torvalds if (sym_name) 5001da177e4SLinus Torvalds return sprintf(buffer, "%s", sym_name); 5011da177e4SLinus Torvalds return sprintf(buffer, "%lu", wchan); 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 5061da177e4SLinus Torvalds /* 5071da177e4SLinus Torvalds * Provides /proc/PID/schedstat 5081da177e4SLinus Torvalds */ 5091da177e4SLinus Torvalds static int proc_pid_schedstat(struct task_struct *task, char *buffer) 5101da177e4SLinus Torvalds { 5111da177e4SLinus Torvalds return sprintf(buffer, "%lu %lu %lu\n", 5121da177e4SLinus Torvalds task->sched_info.cpu_time, 5131da177e4SLinus Torvalds task->sched_info.run_delay, 5141da177e4SLinus Torvalds task->sched_info.pcnt); 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds #endif 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds /* The badness from the OOM killer */ 5191da177e4SLinus Torvalds unsigned long badness(struct task_struct *p, unsigned long uptime); 5201da177e4SLinus Torvalds static int proc_oom_score(struct task_struct *task, char *buffer) 5211da177e4SLinus Torvalds { 5221da177e4SLinus Torvalds unsigned long points; 5231da177e4SLinus Torvalds struct timespec uptime; 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds do_posix_clock_monotonic_gettime(&uptime); 5261da177e4SLinus Torvalds points = badness(task, uptime.tv_sec); 5271da177e4SLinus Torvalds return sprintf(buffer, "%lu\n", points); 5281da177e4SLinus Torvalds } 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds /************************************************************************/ 5311da177e4SLinus Torvalds /* Here the fs part begins */ 5321da177e4SLinus Torvalds /************************************************************************/ 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds /* permission checks */ 5351da177e4SLinus Torvalds 53666dcca06SSripathi Kodi /* If the process being read is separated by chroot from the reading process, 53766dcca06SSripathi Kodi * don't let the reader access the threads. 53866dcca06SSripathi Kodi */ 5390f2fe20fSEric W. Biederman static int proc_check_chroot(struct dentry *de, struct vfsmount *mnt) 5401da177e4SLinus Torvalds { 5410f2fe20fSEric W. Biederman struct dentry *base; 5420f2fe20fSEric W. Biederman struct vfsmount *our_vfsmnt; 5431da177e4SLinus Torvalds int res = 0; 544e4e5d3fcSHerbert Poetzl 5451da177e4SLinus Torvalds read_lock(¤t->fs->lock); 5461da177e4SLinus Torvalds our_vfsmnt = mntget(current->fs->rootmnt); 5471da177e4SLinus Torvalds base = dget(current->fs->root); 5481da177e4SLinus Torvalds read_unlock(¤t->fs->lock); 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds spin_lock(&vfsmount_lock); 5511da177e4SLinus Torvalds 552e4e5d3fcSHerbert Poetzl while (mnt != our_vfsmnt) { 553e4e5d3fcSHerbert Poetzl if (mnt == mnt->mnt_parent) 5541da177e4SLinus Torvalds goto out; 555e4e5d3fcSHerbert Poetzl de = mnt->mnt_mountpoint; 556e4e5d3fcSHerbert Poetzl mnt = mnt->mnt_parent; 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds if (!is_subdir(de, base)) 5601da177e4SLinus Torvalds goto out; 5611da177e4SLinus Torvalds spin_unlock(&vfsmount_lock); 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds exit: 5641da177e4SLinus Torvalds dput(base); 5651da177e4SLinus Torvalds mntput(our_vfsmnt); 5661da177e4SLinus Torvalds return res; 5671da177e4SLinus Torvalds out: 5681da177e4SLinus Torvalds spin_unlock(&vfsmount_lock); 5691da177e4SLinus Torvalds res = -EACCES; 5701da177e4SLinus Torvalds goto exit; 5711da177e4SLinus Torvalds } 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds extern struct seq_operations mounts_op; 5745addc5ddSAl Viro struct proc_mounts { 5755addc5ddSAl Viro struct seq_file m; 5765addc5ddSAl Viro int event; 5775addc5ddSAl Viro }; 5785addc5ddSAl Viro 5791da177e4SLinus Torvalds static int mounts_open(struct inode *inode, struct file *file) 5801da177e4SLinus Torvalds { 581*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 582*99f89551SEric W. Biederman struct namespace *namespace = NULL; 5835addc5ddSAl Viro struct proc_mounts *p; 5845addc5ddSAl Viro int ret = -EINVAL; 5855addc5ddSAl Viro 586*99f89551SEric W. Biederman if (task) { 5871da177e4SLinus Torvalds task_lock(task); 5881da177e4SLinus Torvalds namespace = task->namespace; 5891da177e4SLinus Torvalds if (namespace) 5901da177e4SLinus Torvalds get_namespace(namespace); 5911da177e4SLinus Torvalds task_unlock(task); 592*99f89551SEric W. Biederman put_task_struct(task); 593*99f89551SEric W. Biederman } 5941da177e4SLinus Torvalds 5955addc5ddSAl Viro if (namespace) { 5965addc5ddSAl Viro ret = -ENOMEM; 5975addc5ddSAl Viro p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); 5985addc5ddSAl Viro if (p) { 5995addc5ddSAl Viro file->private_data = &p->m; 6005addc5ddSAl Viro ret = seq_open(file, &mounts_op); 6015addc5ddSAl Viro if (!ret) { 6025addc5ddSAl Viro p->m.private = namespace; 6035addc5ddSAl Viro p->event = namespace->event; 6045addc5ddSAl Viro return 0; 6051da177e4SLinus Torvalds } 6065addc5ddSAl Viro kfree(p); 6075addc5ddSAl Viro } 6085addc5ddSAl Viro put_namespace(namespace); 6091da177e4SLinus Torvalds } 6101da177e4SLinus Torvalds return ret; 6111da177e4SLinus Torvalds } 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds static int mounts_release(struct inode *inode, struct file *file) 6141da177e4SLinus Torvalds { 6151da177e4SLinus Torvalds struct seq_file *m = file->private_data; 6161da177e4SLinus Torvalds struct namespace *namespace = m->private; 6171da177e4SLinus Torvalds put_namespace(namespace); 6181da177e4SLinus Torvalds return seq_release(inode, file); 6191da177e4SLinus Torvalds } 6201da177e4SLinus Torvalds 6215addc5ddSAl Viro static unsigned mounts_poll(struct file *file, poll_table *wait) 6225addc5ddSAl Viro { 6235addc5ddSAl Viro struct proc_mounts *p = file->private_data; 6245addc5ddSAl Viro struct namespace *ns = p->m.private; 6255addc5ddSAl Viro unsigned res = 0; 6265addc5ddSAl Viro 6275addc5ddSAl Viro poll_wait(file, &ns->poll, wait); 6285addc5ddSAl Viro 6295addc5ddSAl Viro spin_lock(&vfsmount_lock); 6305addc5ddSAl Viro if (p->event != ns->event) { 6315addc5ddSAl Viro p->event = ns->event; 6325addc5ddSAl Viro res = POLLERR; 6335addc5ddSAl Viro } 6345addc5ddSAl Viro spin_unlock(&vfsmount_lock); 6355addc5ddSAl Viro 6365addc5ddSAl Viro return res; 6375addc5ddSAl Viro } 6385addc5ddSAl Viro 6391da177e4SLinus Torvalds static struct file_operations proc_mounts_operations = { 6401da177e4SLinus Torvalds .open = mounts_open, 6411da177e4SLinus Torvalds .read = seq_read, 6421da177e4SLinus Torvalds .llseek = seq_lseek, 6431da177e4SLinus Torvalds .release = mounts_release, 6445addc5ddSAl Viro .poll = mounts_poll, 6451da177e4SLinus Torvalds }; 6461da177e4SLinus Torvalds 647b4629fe2SChuck Lever extern struct seq_operations mountstats_op; 648b4629fe2SChuck Lever static int mountstats_open(struct inode *inode, struct file *file) 649b4629fe2SChuck Lever { 650b4629fe2SChuck Lever int ret = seq_open(file, &mountstats_op); 651b4629fe2SChuck Lever 652b4629fe2SChuck Lever if (!ret) { 653b4629fe2SChuck Lever struct seq_file *m = file->private_data; 654*99f89551SEric W. Biederman struct namespace *namespace = NULL; 655*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 656*99f89551SEric W. Biederman 657*99f89551SEric W. Biederman if (task) { 658b4629fe2SChuck Lever task_lock(task); 659b4629fe2SChuck Lever namespace = task->namespace; 660b4629fe2SChuck Lever if (namespace) 661b4629fe2SChuck Lever get_namespace(namespace); 662b4629fe2SChuck Lever task_unlock(task); 663*99f89551SEric W. Biederman put_task_struct(task); 664*99f89551SEric W. Biederman } 665b4629fe2SChuck Lever 666b4629fe2SChuck Lever if (namespace) 667b4629fe2SChuck Lever m->private = namespace; 668b4629fe2SChuck Lever else { 669b4629fe2SChuck Lever seq_release(inode, file); 670b4629fe2SChuck Lever ret = -EINVAL; 671b4629fe2SChuck Lever } 672b4629fe2SChuck Lever } 673b4629fe2SChuck Lever return ret; 674b4629fe2SChuck Lever } 675b4629fe2SChuck Lever 676b4629fe2SChuck Lever static struct file_operations proc_mountstats_operations = { 677b4629fe2SChuck Lever .open = mountstats_open, 678b4629fe2SChuck Lever .read = seq_read, 679b4629fe2SChuck Lever .llseek = seq_lseek, 680b4629fe2SChuck Lever .release = mounts_release, 681b4629fe2SChuck Lever }; 682b4629fe2SChuck Lever 6831da177e4SLinus Torvalds #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */ 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds static ssize_t proc_info_read(struct file * file, char __user * buf, 6861da177e4SLinus Torvalds size_t count, loff_t *ppos) 6871da177e4SLinus Torvalds { 6881da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 6891da177e4SLinus Torvalds unsigned long page; 6901da177e4SLinus Torvalds ssize_t length; 691*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 692*99f89551SEric W. Biederman 693*99f89551SEric W. Biederman length = -ESRCH; 694*99f89551SEric W. Biederman if (!task) 695*99f89551SEric W. Biederman goto out_no_task; 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds if (count > PROC_BLOCK_SIZE) 6981da177e4SLinus Torvalds count = PROC_BLOCK_SIZE; 699*99f89551SEric W. Biederman 700*99f89551SEric W. Biederman length = -ENOMEM; 7011da177e4SLinus Torvalds if (!(page = __get_free_page(GFP_KERNEL))) 702*99f89551SEric W. Biederman goto out; 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds length = PROC_I(inode)->op.proc_read(task, (char*)page); 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds if (length >= 0) 7071da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 7081da177e4SLinus Torvalds free_page(page); 709*99f89551SEric W. Biederman out: 710*99f89551SEric W. Biederman put_task_struct(task); 711*99f89551SEric W. Biederman out_no_task: 7121da177e4SLinus Torvalds return length; 7131da177e4SLinus Torvalds } 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds static struct file_operations proc_info_file_operations = { 7161da177e4SLinus Torvalds .read = proc_info_read, 7171da177e4SLinus Torvalds }; 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds static int mem_open(struct inode* inode, struct file* file) 7201da177e4SLinus Torvalds { 7211da177e4SLinus Torvalds file->private_data = (void*)((long)current->self_exec_id); 7221da177e4SLinus Torvalds return 0; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds static ssize_t mem_read(struct file * file, char __user * buf, 7261da177e4SLinus Torvalds size_t count, loff_t *ppos) 7271da177e4SLinus Torvalds { 728*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 7291da177e4SLinus Torvalds char *page; 7301da177e4SLinus Torvalds unsigned long src = *ppos; 7311da177e4SLinus Torvalds int ret = -ESRCH; 7321da177e4SLinus Torvalds struct mm_struct *mm; 7331da177e4SLinus Torvalds 734*99f89551SEric W. Biederman if (!task) 735*99f89551SEric W. Biederman goto out_no_task; 736*99f89551SEric W. Biederman 737ab8d11beSMiklos Szeredi if (!MAY_PTRACE(task) || !ptrace_may_attach(task)) 7381da177e4SLinus Torvalds goto out; 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds ret = -ENOMEM; 7411da177e4SLinus Torvalds page = (char *)__get_free_page(GFP_USER); 7421da177e4SLinus Torvalds if (!page) 7431da177e4SLinus Torvalds goto out; 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds ret = 0; 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds mm = get_task_mm(task); 7481da177e4SLinus Torvalds if (!mm) 7491da177e4SLinus Torvalds goto out_free; 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds ret = -EIO; 7521da177e4SLinus Torvalds 7531da177e4SLinus Torvalds if (file->private_data != (void*)((long)current->self_exec_id)) 7541da177e4SLinus Torvalds goto out_put; 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds ret = 0; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds while (count > 0) { 7591da177e4SLinus Torvalds int this_len, retval; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 7621da177e4SLinus Torvalds retval = access_process_vm(task, src, page, this_len, 0); 763ab8d11beSMiklos Szeredi if (!retval || !MAY_PTRACE(task) || !ptrace_may_attach(task)) { 7641da177e4SLinus Torvalds if (!ret) 7651da177e4SLinus Torvalds ret = -EIO; 7661da177e4SLinus Torvalds break; 7671da177e4SLinus Torvalds } 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds if (copy_to_user(buf, page, retval)) { 7701da177e4SLinus Torvalds ret = -EFAULT; 7711da177e4SLinus Torvalds break; 7721da177e4SLinus Torvalds } 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds ret += retval; 7751da177e4SLinus Torvalds src += retval; 7761da177e4SLinus Torvalds buf += retval; 7771da177e4SLinus Torvalds count -= retval; 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds *ppos = src; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds out_put: 7821da177e4SLinus Torvalds mmput(mm); 7831da177e4SLinus Torvalds out_free: 7841da177e4SLinus Torvalds free_page((unsigned long) page); 7851da177e4SLinus Torvalds out: 786*99f89551SEric W. Biederman put_task_struct(task); 787*99f89551SEric W. Biederman out_no_task: 7881da177e4SLinus Torvalds return ret; 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds #define mem_write NULL 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds #ifndef mem_write 7941da177e4SLinus Torvalds /* This is a security hazard */ 7951da177e4SLinus Torvalds static ssize_t mem_write(struct file * file, const char * buf, 7961da177e4SLinus Torvalds size_t count, loff_t *ppos) 7971da177e4SLinus Torvalds { 7981da177e4SLinus Torvalds int copied = 0; 7991da177e4SLinus Torvalds char *page; 800*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 8011da177e4SLinus Torvalds unsigned long dst = *ppos; 8021da177e4SLinus Torvalds 803*99f89551SEric W. Biederman copied = -ESRCH; 804*99f89551SEric W. Biederman if (!task) 805*99f89551SEric W. Biederman goto out_no_task; 8061da177e4SLinus Torvalds 807*99f89551SEric W. Biederman if (!MAY_PTRACE(task) || !ptrace_may_attach(task)) 808*99f89551SEric W. Biederman goto out; 809*99f89551SEric W. Biederman 810*99f89551SEric W. Biederman copied = -ENOMEM; 8111da177e4SLinus Torvalds page = (char *)__get_free_page(GFP_USER); 8121da177e4SLinus Torvalds if (!page) 813*99f89551SEric W. Biederman goto out; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds while (count > 0) { 8161da177e4SLinus Torvalds int this_len, retval; 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 8191da177e4SLinus Torvalds if (copy_from_user(page, buf, this_len)) { 8201da177e4SLinus Torvalds copied = -EFAULT; 8211da177e4SLinus Torvalds break; 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds retval = access_process_vm(task, dst, page, this_len, 1); 8241da177e4SLinus Torvalds if (!retval) { 8251da177e4SLinus Torvalds if (!copied) 8261da177e4SLinus Torvalds copied = -EIO; 8271da177e4SLinus Torvalds break; 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds copied += retval; 8301da177e4SLinus Torvalds buf += retval; 8311da177e4SLinus Torvalds dst += retval; 8321da177e4SLinus Torvalds count -= retval; 8331da177e4SLinus Torvalds } 8341da177e4SLinus Torvalds *ppos = dst; 8351da177e4SLinus Torvalds free_page((unsigned long) page); 836*99f89551SEric W. Biederman out: 837*99f89551SEric W. Biederman put_task_struct(task); 838*99f89551SEric W. Biederman out_no_task: 8391da177e4SLinus Torvalds return copied; 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds #endif 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds static loff_t mem_lseek(struct file * file, loff_t offset, int orig) 8441da177e4SLinus Torvalds { 8451da177e4SLinus Torvalds switch (orig) { 8461da177e4SLinus Torvalds case 0: 8471da177e4SLinus Torvalds file->f_pos = offset; 8481da177e4SLinus Torvalds break; 8491da177e4SLinus Torvalds case 1: 8501da177e4SLinus Torvalds file->f_pos += offset; 8511da177e4SLinus Torvalds break; 8521da177e4SLinus Torvalds default: 8531da177e4SLinus Torvalds return -EINVAL; 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds force_successful_syscall_return(); 8561da177e4SLinus Torvalds return file->f_pos; 8571da177e4SLinus Torvalds } 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds static struct file_operations proc_mem_operations = { 8601da177e4SLinus Torvalds .llseek = mem_lseek, 8611da177e4SLinus Torvalds .read = mem_read, 8621da177e4SLinus Torvalds .write = mem_write, 8631da177e4SLinus Torvalds .open = mem_open, 8641da177e4SLinus Torvalds }; 8651da177e4SLinus Torvalds 8661da177e4SLinus Torvalds static ssize_t oom_adjust_read(struct file *file, char __user *buf, 8671da177e4SLinus Torvalds size_t count, loff_t *ppos) 8681da177e4SLinus Torvalds { 869*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 8708578cea7SEric W. Biederman char buffer[PROC_NUMBUF]; 8711da177e4SLinus Torvalds size_t len; 872*99f89551SEric W. Biederman int oom_adjust; 8731da177e4SLinus Torvalds loff_t __ppos = *ppos; 8741da177e4SLinus Torvalds 875*99f89551SEric W. Biederman if (!task) 876*99f89551SEric W. Biederman return -ESRCH; 877*99f89551SEric W. Biederman oom_adjust = task->oomkilladj; 878*99f89551SEric W. Biederman put_task_struct(task); 879*99f89551SEric W. Biederman 8808578cea7SEric W. Biederman len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust); 8811da177e4SLinus Torvalds if (__ppos >= len) 8821da177e4SLinus Torvalds return 0; 8831da177e4SLinus Torvalds if (count > len-__ppos) 8841da177e4SLinus Torvalds count = len-__ppos; 8851da177e4SLinus Torvalds if (copy_to_user(buf, buffer + __ppos, count)) 8861da177e4SLinus Torvalds return -EFAULT; 8871da177e4SLinus Torvalds *ppos = __ppos + count; 8881da177e4SLinus Torvalds return count; 8891da177e4SLinus Torvalds } 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds static ssize_t oom_adjust_write(struct file *file, const char __user *buf, 8921da177e4SLinus Torvalds size_t count, loff_t *ppos) 8931da177e4SLinus Torvalds { 894*99f89551SEric W. Biederman struct task_struct *task; 8958578cea7SEric W. Biederman char buffer[PROC_NUMBUF], *end; 8961da177e4SLinus Torvalds int oom_adjust; 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds if (!capable(CAP_SYS_RESOURCE)) 8991da177e4SLinus Torvalds return -EPERM; 9008578cea7SEric W. Biederman memset(buffer, 0, sizeof(buffer)); 9018578cea7SEric W. Biederman if (count > sizeof(buffer) - 1) 9028578cea7SEric W. Biederman count = sizeof(buffer) - 1; 9031da177e4SLinus Torvalds if (copy_from_user(buffer, buf, count)) 9041da177e4SLinus Torvalds return -EFAULT; 9051da177e4SLinus Torvalds oom_adjust = simple_strtol(buffer, &end, 0); 90679befd0cSAndrea Arcangeli if ((oom_adjust < -16 || oom_adjust > 15) && oom_adjust != OOM_DISABLE) 9071da177e4SLinus Torvalds return -EINVAL; 9081da177e4SLinus Torvalds if (*end == '\n') 9091da177e4SLinus Torvalds end++; 910*99f89551SEric W. Biederman task = get_proc_task(file->f_dentry->d_inode); 911*99f89551SEric W. Biederman if (!task) 912*99f89551SEric W. Biederman return -ESRCH; 9131da177e4SLinus Torvalds task->oomkilladj = oom_adjust; 914*99f89551SEric W. Biederman put_task_struct(task); 9151da177e4SLinus Torvalds if (end - buffer == 0) 9161da177e4SLinus Torvalds return -EIO; 9171da177e4SLinus Torvalds return end - buffer; 9181da177e4SLinus Torvalds } 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds static struct file_operations proc_oom_adjust_operations = { 9211da177e4SLinus Torvalds .read = oom_adjust_read, 9221da177e4SLinus Torvalds .write = oom_adjust_write, 9231da177e4SLinus Torvalds }; 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 9261da177e4SLinus Torvalds #define TMPBUFLEN 21 9271da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 9281da177e4SLinus Torvalds size_t count, loff_t *ppos) 9291da177e4SLinus Torvalds { 9301da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 931*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 9321da177e4SLinus Torvalds ssize_t length; 9331da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 9341da177e4SLinus Torvalds 935*99f89551SEric W. Biederman if (!task) 936*99f89551SEric W. Biederman return -ESRCH; 9371da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 9381da177e4SLinus Torvalds audit_get_loginuid(task->audit_context)); 939*99f89551SEric W. Biederman put_task_struct(task); 9401da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 9441da177e4SLinus Torvalds size_t count, loff_t *ppos) 9451da177e4SLinus Torvalds { 9461da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 9471da177e4SLinus Torvalds char *page, *tmp; 9481da177e4SLinus Torvalds ssize_t length; 9491da177e4SLinus Torvalds uid_t loginuid; 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds if (!capable(CAP_AUDIT_CONTROL)) 9521da177e4SLinus Torvalds return -EPERM; 9531da177e4SLinus Torvalds 954*99f89551SEric W. Biederman if (current != proc_tref(inode)->task) 9551da177e4SLinus Torvalds return -EPERM; 9561da177e4SLinus Torvalds 957e0182909SAl Viro if (count >= PAGE_SIZE) 958e0182909SAl Viro count = PAGE_SIZE - 1; 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds if (*ppos != 0) { 9611da177e4SLinus Torvalds /* No partial writes. */ 9621da177e4SLinus Torvalds return -EINVAL; 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds page = (char*)__get_free_page(GFP_USER); 9651da177e4SLinus Torvalds if (!page) 9661da177e4SLinus Torvalds return -ENOMEM; 9671da177e4SLinus Torvalds length = -EFAULT; 9681da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 9691da177e4SLinus Torvalds goto out_free_page; 9701da177e4SLinus Torvalds 971e0182909SAl Viro page[count] = '\0'; 9721da177e4SLinus Torvalds loginuid = simple_strtoul(page, &tmp, 10); 9731da177e4SLinus Torvalds if (tmp == page) { 9741da177e4SLinus Torvalds length = -EINVAL; 9751da177e4SLinus Torvalds goto out_free_page; 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds } 978*99f89551SEric W. Biederman length = audit_set_loginuid(current, loginuid); 9791da177e4SLinus Torvalds if (likely(length == 0)) 9801da177e4SLinus Torvalds length = count; 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds out_free_page: 9831da177e4SLinus Torvalds free_page((unsigned long) page); 9841da177e4SLinus Torvalds return length; 9851da177e4SLinus Torvalds } 9861da177e4SLinus Torvalds 9871da177e4SLinus Torvalds static struct file_operations proc_loginuid_operations = { 9881da177e4SLinus Torvalds .read = proc_loginuid_read, 9891da177e4SLinus Torvalds .write = proc_loginuid_write, 9901da177e4SLinus Torvalds }; 9911da177e4SLinus Torvalds #endif 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 9941da177e4SLinus Torvalds static ssize_t seccomp_read(struct file *file, char __user *buf, 9951da177e4SLinus Torvalds size_t count, loff_t *ppos) 9961da177e4SLinus Torvalds { 997*99f89551SEric W. Biederman struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode); 9981da177e4SLinus Torvalds char __buf[20]; 9991da177e4SLinus Torvalds loff_t __ppos = *ppos; 10001da177e4SLinus Torvalds size_t len; 10011da177e4SLinus Torvalds 1002*99f89551SEric W. Biederman if (!tsk) 1003*99f89551SEric W. Biederman return -ESRCH; 10041da177e4SLinus Torvalds /* no need to print the trailing zero, so use only len */ 10051da177e4SLinus Torvalds len = sprintf(__buf, "%u\n", tsk->seccomp.mode); 1006*99f89551SEric W. Biederman put_task_struct(tsk); 10071da177e4SLinus Torvalds if (__ppos >= len) 10081da177e4SLinus Torvalds return 0; 10091da177e4SLinus Torvalds if (count > len - __ppos) 10101da177e4SLinus Torvalds count = len - __ppos; 10111da177e4SLinus Torvalds if (copy_to_user(buf, __buf + __ppos, count)) 10121da177e4SLinus Torvalds return -EFAULT; 10131da177e4SLinus Torvalds *ppos = __ppos + count; 10141da177e4SLinus Torvalds return count; 10151da177e4SLinus Torvalds } 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds static ssize_t seccomp_write(struct file *file, const char __user *buf, 10181da177e4SLinus Torvalds size_t count, loff_t *ppos) 10191da177e4SLinus Torvalds { 1020*99f89551SEric W. Biederman struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode); 10211da177e4SLinus Torvalds char __buf[20], *end; 10221da177e4SLinus Torvalds unsigned int seccomp_mode; 1023*99f89551SEric W. Biederman ssize_t result; 1024*99f89551SEric W. Biederman 1025*99f89551SEric W. Biederman result = -ESRCH; 1026*99f89551SEric W. Biederman if (!tsk) 1027*99f89551SEric W. Biederman goto out_no_task; 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds /* can set it only once to be even more secure */ 1030*99f89551SEric W. Biederman result = -EPERM; 10311da177e4SLinus Torvalds if (unlikely(tsk->seccomp.mode)) 1032*99f89551SEric W. Biederman goto out; 10331da177e4SLinus Torvalds 1034*99f89551SEric W. Biederman result = -EFAULT; 10351da177e4SLinus Torvalds memset(__buf, 0, sizeof(__buf)); 10361da177e4SLinus Torvalds count = min(count, sizeof(__buf) - 1); 10371da177e4SLinus Torvalds if (copy_from_user(__buf, buf, count)) 1038*99f89551SEric W. Biederman goto out; 1039*99f89551SEric W. Biederman 10401da177e4SLinus Torvalds seccomp_mode = simple_strtoul(__buf, &end, 0); 10411da177e4SLinus Torvalds if (*end == '\n') 10421da177e4SLinus Torvalds end++; 1043*99f89551SEric W. Biederman result = -EINVAL; 10441da177e4SLinus Torvalds if (seccomp_mode && seccomp_mode <= NR_SECCOMP_MODES) { 10451da177e4SLinus Torvalds tsk->seccomp.mode = seccomp_mode; 10461da177e4SLinus Torvalds set_tsk_thread_flag(tsk, TIF_SECCOMP); 10471da177e4SLinus Torvalds } else 1048*99f89551SEric W. Biederman goto out; 1049*99f89551SEric W. Biederman result = -EIO; 10501da177e4SLinus Torvalds if (unlikely(!(end - __buf))) 1051*99f89551SEric W. Biederman goto out; 1052*99f89551SEric W. Biederman result = end - __buf; 1053*99f89551SEric W. Biederman out: 1054*99f89551SEric W. Biederman put_task_struct(tsk); 1055*99f89551SEric W. Biederman out_no_task: 1056*99f89551SEric W. Biederman return result; 10571da177e4SLinus Torvalds } 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds static struct file_operations proc_seccomp_operations = { 10601da177e4SLinus Torvalds .read = seccomp_read, 10611da177e4SLinus Torvalds .write = seccomp_write, 10621da177e4SLinus Torvalds }; 10631da177e4SLinus Torvalds #endif /* CONFIG_SECCOMP */ 10641da177e4SLinus Torvalds 10650f2fe20fSEric W. Biederman static int proc_check_dentry_visible(struct inode *inode, 10660f2fe20fSEric W. Biederman struct dentry *dentry, struct vfsmount *mnt) 10670f2fe20fSEric W. Biederman { 10680f2fe20fSEric W. Biederman /* Verify that the current process can already see the 10690f2fe20fSEric W. Biederman * file pointed at by the file descriptor. 10700f2fe20fSEric W. Biederman * This prevents /proc from being an accidental information leak. 10710f2fe20fSEric W. Biederman * 10720f2fe20fSEric W. Biederman * This prevents access to files that are not visible do to 10730f2fe20fSEric W. Biederman * being on the otherside of a chroot, in a different 10740f2fe20fSEric W. Biederman * namespace, or are simply process local (like pipes). 10750f2fe20fSEric W. Biederman */ 10760f2fe20fSEric W. Biederman struct task_struct *task; 10770f2fe20fSEric W. Biederman struct files_struct *task_files, *files; 10780f2fe20fSEric W. Biederman int error = -EACCES; 10790f2fe20fSEric W. Biederman 10800f2fe20fSEric W. Biederman /* See if the the two tasks share a commone set of 10810f2fe20fSEric W. Biederman * file descriptors. If so everything is visible. 10820f2fe20fSEric W. Biederman */ 1083*99f89551SEric W. Biederman task = get_proc_task(inode); 10840f2fe20fSEric W. Biederman if (!task) 10850f2fe20fSEric W. Biederman goto out; 10860f2fe20fSEric W. Biederman files = get_files_struct(current); 10870f2fe20fSEric W. Biederman task_files = get_files_struct(task); 10880f2fe20fSEric W. Biederman if (files && task_files && (files == task_files)) 10890f2fe20fSEric W. Biederman error = 0; 10900f2fe20fSEric W. Biederman if (task_files) 10910f2fe20fSEric W. Biederman put_files_struct(task_files); 10920f2fe20fSEric W. Biederman if (files) 10930f2fe20fSEric W. Biederman put_files_struct(files); 1094*99f89551SEric W. Biederman put_task_struct(task); 10950f2fe20fSEric W. Biederman if (!error) 10960f2fe20fSEric W. Biederman goto out; 10970f2fe20fSEric W. Biederman 10980f2fe20fSEric W. Biederman /* If the two tasks don't share a common set of file 10990f2fe20fSEric W. Biederman * descriptors see if the destination dentry is already 11000f2fe20fSEric W. Biederman * visible in the current tasks filesystem namespace. 11010f2fe20fSEric W. Biederman */ 11020f2fe20fSEric W. Biederman error = proc_check_chroot(dentry, mnt); 11030f2fe20fSEric W. Biederman out: 11040f2fe20fSEric W. Biederman return error; 11050f2fe20fSEric W. Biederman 11060f2fe20fSEric W. Biederman } 11070f2fe20fSEric W. Biederman 1108008b150aSAl Viro static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) 11091da177e4SLinus Torvalds { 11101da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 11111da177e4SLinus Torvalds int error = -EACCES; 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds /* We don't need a base pointer in the /proc filesystem */ 11141da177e4SLinus Torvalds path_release(nd); 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE)) 11171da177e4SLinus Torvalds goto out; 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds error = PROC_I(inode)->op.proc_get_link(inode, &nd->dentry, &nd->mnt); 11201da177e4SLinus Torvalds nd->last_type = LAST_BIND; 11210f2fe20fSEric W. Biederman if (error) 11220f2fe20fSEric W. Biederman goto out; 11230f2fe20fSEric W. Biederman 11240f2fe20fSEric W. Biederman /* Only return files this task can already see */ 11250f2fe20fSEric W. Biederman error = proc_check_dentry_visible(inode, nd->dentry, nd->mnt); 11260f2fe20fSEric W. Biederman if (error) 11270f2fe20fSEric W. Biederman path_release(nd); 11281da177e4SLinus Torvalds out: 1129008b150aSAl Viro return ERR_PTR(error); 11301da177e4SLinus Torvalds } 11311da177e4SLinus Torvalds 11321da177e4SLinus Torvalds static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt, 11331da177e4SLinus Torvalds char __user *buffer, int buflen) 11341da177e4SLinus Torvalds { 11351da177e4SLinus Torvalds struct inode * inode; 11361da177e4SLinus Torvalds char *tmp = (char*)__get_free_page(GFP_KERNEL), *path; 11371da177e4SLinus Torvalds int len; 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds if (!tmp) 11401da177e4SLinus Torvalds return -ENOMEM; 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds inode = dentry->d_inode; 11431da177e4SLinus Torvalds path = d_path(dentry, mnt, tmp, PAGE_SIZE); 11441da177e4SLinus Torvalds len = PTR_ERR(path); 11451da177e4SLinus Torvalds if (IS_ERR(path)) 11461da177e4SLinus Torvalds goto out; 11471da177e4SLinus Torvalds len = tmp + PAGE_SIZE - 1 - path; 11481da177e4SLinus Torvalds 11491da177e4SLinus Torvalds if (len > buflen) 11501da177e4SLinus Torvalds len = buflen; 11511da177e4SLinus Torvalds if (copy_to_user(buffer, path, len)) 11521da177e4SLinus Torvalds len = -EFAULT; 11531da177e4SLinus Torvalds out: 11541da177e4SLinus Torvalds free_page((unsigned long)tmp); 11551da177e4SLinus Torvalds return len; 11561da177e4SLinus Torvalds } 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 11591da177e4SLinus Torvalds { 11601da177e4SLinus Torvalds int error = -EACCES; 11611da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 11621da177e4SLinus Torvalds struct dentry *de; 11631da177e4SLinus Torvalds struct vfsmount *mnt = NULL; 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE)) 11671da177e4SLinus Torvalds goto out; 11681da177e4SLinus Torvalds 11691da177e4SLinus Torvalds error = PROC_I(inode)->op.proc_get_link(inode, &de, &mnt); 11701da177e4SLinus Torvalds if (error) 11711da177e4SLinus Torvalds goto out; 11721da177e4SLinus Torvalds 11730f2fe20fSEric W. Biederman /* Only return files this task can already see */ 11740f2fe20fSEric W. Biederman error = proc_check_dentry_visible(inode, de, mnt); 11750f2fe20fSEric W. Biederman if (error) 11760f2fe20fSEric W. Biederman goto out_put; 11770f2fe20fSEric W. Biederman 11781da177e4SLinus Torvalds error = do_proc_readlink(de, mnt, buffer, buflen); 11790f2fe20fSEric W. Biederman out_put: 11801da177e4SLinus Torvalds dput(de); 11811da177e4SLinus Torvalds mntput(mnt); 11821da177e4SLinus Torvalds out: 11831da177e4SLinus Torvalds return error; 11841da177e4SLinus Torvalds } 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds static struct inode_operations proc_pid_link_inode_operations = { 11871da177e4SLinus Torvalds .readlink = proc_pid_readlink, 11881da177e4SLinus Torvalds .follow_link = proc_pid_follow_link 11891da177e4SLinus Torvalds }; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir) 11921da177e4SLinus Torvalds { 11935634708bSEric W. Biederman struct dentry *dentry = filp->f_dentry; 11945634708bSEric W. Biederman struct inode *inode = dentry->d_inode; 1195*99f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 11961da177e4SLinus Torvalds unsigned int fd, tid, ino; 11971da177e4SLinus Torvalds int retval; 11988578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 11991da177e4SLinus Torvalds struct files_struct * files; 1200badf1662SDipankar Sarma struct fdtable *fdt; 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds retval = -ENOENT; 1203*99f89551SEric W. Biederman if (!p) 1204*99f89551SEric W. Biederman goto out_no_task; 12051da177e4SLinus Torvalds retval = 0; 12061da177e4SLinus Torvalds tid = p->pid; 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds fd = filp->f_pos; 12091da177e4SLinus Torvalds switch (fd) { 12101da177e4SLinus Torvalds case 0: 12111da177e4SLinus Torvalds if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 12121da177e4SLinus Torvalds goto out; 12131da177e4SLinus Torvalds filp->f_pos++; 12141da177e4SLinus Torvalds case 1: 12155634708bSEric W. Biederman ino = parent_ino(dentry); 12161da177e4SLinus Torvalds if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0) 12171da177e4SLinus Torvalds goto out; 12181da177e4SLinus Torvalds filp->f_pos++; 12191da177e4SLinus Torvalds default: 12201da177e4SLinus Torvalds files = get_files_struct(p); 12211da177e4SLinus Torvalds if (!files) 12221da177e4SLinus Torvalds goto out; 1223b835996fSDipankar Sarma rcu_read_lock(); 1224badf1662SDipankar Sarma fdt = files_fdtable(files); 12251da177e4SLinus Torvalds for (fd = filp->f_pos-2; 1226badf1662SDipankar Sarma fd < fdt->max_fds; 12271da177e4SLinus Torvalds fd++, filp->f_pos++) { 12281da177e4SLinus Torvalds unsigned int i,j; 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds if (!fcheck_files(files, fd)) 12311da177e4SLinus Torvalds continue; 1232b835996fSDipankar Sarma rcu_read_unlock(); 12331da177e4SLinus Torvalds 12348578cea7SEric W. Biederman j = PROC_NUMBUF; 12351da177e4SLinus Torvalds i = fd; 12361da177e4SLinus Torvalds do { 12371da177e4SLinus Torvalds j--; 12381da177e4SLinus Torvalds buf[j] = '0' + (i % 10); 12391da177e4SLinus Torvalds i /= 10; 12401da177e4SLinus Torvalds } while (i); 12411da177e4SLinus Torvalds 12421da177e4SLinus Torvalds ino = fake_ino(tid, PROC_TID_FD_DIR + fd); 12438578cea7SEric W. Biederman if (filldir(dirent, buf+j, PROC_NUMBUF-j, fd+2, ino, DT_LNK) < 0) { 1244b835996fSDipankar Sarma rcu_read_lock(); 12451da177e4SLinus Torvalds break; 12461da177e4SLinus Torvalds } 1247b835996fSDipankar Sarma rcu_read_lock(); 12481da177e4SLinus Torvalds } 1249b835996fSDipankar Sarma rcu_read_unlock(); 12501da177e4SLinus Torvalds put_files_struct(files); 12511da177e4SLinus Torvalds } 12521da177e4SLinus Torvalds out: 1253*99f89551SEric W. Biederman put_task_struct(p); 1254*99f89551SEric W. Biederman out_no_task: 12551da177e4SLinus Torvalds return retval; 12561da177e4SLinus Torvalds } 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds static int proc_pident_readdir(struct file *filp, 12591da177e4SLinus Torvalds void *dirent, filldir_t filldir, 12601da177e4SLinus Torvalds struct pid_entry *ents, unsigned int nents) 12611da177e4SLinus Torvalds { 12621da177e4SLinus Torvalds int i; 12631da177e4SLinus Torvalds int pid; 12641da177e4SLinus Torvalds struct dentry *dentry = filp->f_dentry; 12651da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1266*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 12671da177e4SLinus Torvalds struct pid_entry *p; 12681da177e4SLinus Torvalds ino_t ino; 12691da177e4SLinus Torvalds int ret; 12701da177e4SLinus Torvalds 12711da177e4SLinus Torvalds ret = -ENOENT; 1272*99f89551SEric W. Biederman if (!task) 12731da177e4SLinus Torvalds goto out; 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds ret = 0; 1276*99f89551SEric W. Biederman pid = task->pid; 1277*99f89551SEric W. Biederman put_task_struct(task); 12781da177e4SLinus Torvalds i = filp->f_pos; 12791da177e4SLinus Torvalds switch (i) { 12801da177e4SLinus Torvalds case 0: 12811da177e4SLinus Torvalds ino = inode->i_ino; 12821da177e4SLinus Torvalds if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 12831da177e4SLinus Torvalds goto out; 12841da177e4SLinus Torvalds i++; 12851da177e4SLinus Torvalds filp->f_pos++; 12861da177e4SLinus Torvalds /* fall through */ 12871da177e4SLinus Torvalds case 1: 12881da177e4SLinus Torvalds ino = parent_ino(dentry); 12891da177e4SLinus Torvalds if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 12901da177e4SLinus Torvalds goto out; 12911da177e4SLinus Torvalds i++; 12921da177e4SLinus Torvalds filp->f_pos++; 12931da177e4SLinus Torvalds /* fall through */ 12941da177e4SLinus Torvalds default: 12951da177e4SLinus Torvalds i -= 2; 12961da177e4SLinus Torvalds if (i >= nents) { 12971da177e4SLinus Torvalds ret = 1; 12981da177e4SLinus Torvalds goto out; 12991da177e4SLinus Torvalds } 13001da177e4SLinus Torvalds p = ents + i; 13011da177e4SLinus Torvalds while (p->name) { 13021da177e4SLinus Torvalds if (filldir(dirent, p->name, p->len, filp->f_pos, 13031da177e4SLinus Torvalds fake_ino(pid, p->type), p->mode >> 12) < 0) 13041da177e4SLinus Torvalds goto out; 13051da177e4SLinus Torvalds filp->f_pos++; 13061da177e4SLinus Torvalds p++; 13071da177e4SLinus Torvalds } 13081da177e4SLinus Torvalds } 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds ret = 1; 13111da177e4SLinus Torvalds out: 13121da177e4SLinus Torvalds return ret; 13131da177e4SLinus Torvalds } 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds static int proc_tgid_base_readdir(struct file * filp, 13161da177e4SLinus Torvalds void * dirent, filldir_t filldir) 13171da177e4SLinus Torvalds { 13181da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 13191da177e4SLinus Torvalds tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff)); 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds static int proc_tid_base_readdir(struct file * filp, 13231da177e4SLinus Torvalds void * dirent, filldir_t filldir) 13241da177e4SLinus Torvalds { 13251da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 13261da177e4SLinus Torvalds tid_base_stuff,ARRAY_SIZE(tid_base_stuff)); 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds /* building an inode */ 13301da177e4SLinus Torvalds 13311da177e4SLinus Torvalds static int task_dumpable(struct task_struct *task) 13321da177e4SLinus Torvalds { 13331da177e4SLinus Torvalds int dumpable = 0; 13341da177e4SLinus Torvalds struct mm_struct *mm; 13351da177e4SLinus Torvalds 13361da177e4SLinus Torvalds task_lock(task); 13371da177e4SLinus Torvalds mm = task->mm; 13381da177e4SLinus Torvalds if (mm) 13391da177e4SLinus Torvalds dumpable = mm->dumpable; 13401da177e4SLinus Torvalds task_unlock(task); 1341d6e71144SAlan Cox if(dumpable == 1) 1342d6e71144SAlan Cox return 1; 1343d6e71144SAlan Cox return 0; 13441da177e4SLinus Torvalds } 13451da177e4SLinus Torvalds 13461da177e4SLinus Torvalds 13471da177e4SLinus Torvalds static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task, int ino) 13481da177e4SLinus Torvalds { 13491da177e4SLinus Torvalds struct inode * inode; 13501da177e4SLinus Torvalds struct proc_inode *ei; 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds /* We need a new inode */ 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds inode = new_inode(sb); 13551da177e4SLinus Torvalds if (!inode) 13561da177e4SLinus Torvalds goto out; 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds /* Common stuff */ 13591da177e4SLinus Torvalds ei = PROC_I(inode); 13601da177e4SLinus Torvalds inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 13611da177e4SLinus Torvalds inode->i_ino = fake_ino(task->pid, ino); 13621da177e4SLinus Torvalds 13631da177e4SLinus Torvalds /* 13641da177e4SLinus Torvalds * grab the reference to task. 13651da177e4SLinus Torvalds */ 1366*99f89551SEric W. Biederman ei->tref = tref_get_by_task(task); 1367*99f89551SEric W. Biederman if (!tref_task(ei->tref)) 1368*99f89551SEric W. Biederman goto out_unlock; 1369*99f89551SEric W. Biederman 13701da177e4SLinus Torvalds inode->i_uid = 0; 13711da177e4SLinus Torvalds inode->i_gid = 0; 137287bfbf67SEric W. Biederman if (task_dumpable(task)) { 13731da177e4SLinus Torvalds inode->i_uid = task->euid; 13741da177e4SLinus Torvalds inode->i_gid = task->egid; 13751da177e4SLinus Torvalds } 13761da177e4SLinus Torvalds security_task_to_inode(task, inode); 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds out: 13791da177e4SLinus Torvalds return inode; 13801da177e4SLinus Torvalds 13811da177e4SLinus Torvalds out_unlock: 13821da177e4SLinus Torvalds iput(inode); 13831da177e4SLinus Torvalds return NULL; 13841da177e4SLinus Torvalds } 13851da177e4SLinus Torvalds 13861da177e4SLinus Torvalds /* dentry stuff */ 13871da177e4SLinus Torvalds 13881da177e4SLinus Torvalds /* 13891da177e4SLinus Torvalds * Exceptional case: normally we are not allowed to unhash a busy 13901da177e4SLinus Torvalds * directory. In this case, however, we can do it - no aliasing problems 13911da177e4SLinus Torvalds * due to the way we treat inodes. 13921da177e4SLinus Torvalds * 13931da177e4SLinus Torvalds * Rewrite the inode's ownerships here because the owning task may have 13941da177e4SLinus Torvalds * performed a setuid(), etc. 1395*99f89551SEric W. Biederman * 1396*99f89551SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 1397*99f89551SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 1398*99f89551SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 1399*99f89551SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 1400*99f89551SEric W. Biederman * made this apply to all per process world readable and executable 1401*99f89551SEric W. Biederman * directories. 14021da177e4SLinus Torvalds */ 14031da177e4SLinus Torvalds static int pid_revalidate(struct dentry *dentry, struct nameidata *nd) 14041da177e4SLinus Torvalds { 14051da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1406*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1407*99f89551SEric W. Biederman if (task) { 1408*99f89551SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 1409*99f89551SEric W. Biederman 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 } 14161da177e4SLinus Torvalds security_task_to_inode(task, inode); 1417*99f89551SEric W. Biederman put_task_struct(task); 14181da177e4SLinus Torvalds return 1; 14191da177e4SLinus Torvalds } 14201da177e4SLinus Torvalds d_drop(dentry); 14211da177e4SLinus Torvalds return 0; 14221da177e4SLinus Torvalds } 14231da177e4SLinus Torvalds 1424*99f89551SEric W. Biederman static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 1425*99f89551SEric W. Biederman { 1426*99f89551SEric W. Biederman struct inode *inode = dentry->d_inode; 1427*99f89551SEric W. Biederman struct task_struct *task; 1428*99f89551SEric W. Biederman generic_fillattr(inode, stat); 1429*99f89551SEric W. Biederman 1430*99f89551SEric W. Biederman rcu_read_lock(); 1431*99f89551SEric W. Biederman stat->uid = 0; 1432*99f89551SEric W. Biederman stat->gid = 0; 1433*99f89551SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 1434*99f89551SEric W. Biederman if (task) { 1435*99f89551SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 1436*99f89551SEric W. Biederman task_dumpable(task)) { 1437*99f89551SEric W. Biederman stat->uid = task->euid; 1438*99f89551SEric W. Biederman stat->gid = task->egid; 1439*99f89551SEric W. Biederman } 1440*99f89551SEric W. Biederman } 1441*99f89551SEric W. Biederman rcu_read_unlock(); 1442*99f89551SEric W. Biederman return 0; 1443*99f89551SEric W. Biederman } 1444*99f89551SEric W. Biederman 14451da177e4SLinus Torvalds static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd) 14461da177e4SLinus Torvalds { 14471da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1448*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1449aed7a6c4SEric W. Biederman int fd = proc_fd(inode); 14501da177e4SLinus Torvalds struct files_struct *files; 14511da177e4SLinus Torvalds 1452*99f89551SEric W. Biederman if (task) { 14531da177e4SLinus Torvalds files = get_files_struct(task); 14541da177e4SLinus Torvalds if (files) { 1455b835996fSDipankar Sarma rcu_read_lock(); 14561da177e4SLinus Torvalds if (fcheck_files(files, fd)) { 1457b835996fSDipankar Sarma rcu_read_unlock(); 14581da177e4SLinus Torvalds put_files_struct(files); 14591da177e4SLinus Torvalds if (task_dumpable(task)) { 14601da177e4SLinus Torvalds inode->i_uid = task->euid; 14611da177e4SLinus Torvalds inode->i_gid = task->egid; 14621da177e4SLinus Torvalds } else { 14631da177e4SLinus Torvalds inode->i_uid = 0; 14641da177e4SLinus Torvalds inode->i_gid = 0; 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds security_task_to_inode(task, inode); 1467*99f89551SEric W. Biederman put_task_struct(task); 14681da177e4SLinus Torvalds return 1; 14691da177e4SLinus Torvalds } 1470b835996fSDipankar Sarma rcu_read_unlock(); 14711da177e4SLinus Torvalds put_files_struct(files); 14721da177e4SLinus Torvalds } 1473*99f89551SEric W. Biederman put_task_struct(task); 1474*99f89551SEric W. Biederman } 14751da177e4SLinus Torvalds d_drop(dentry); 14761da177e4SLinus Torvalds return 0; 14771da177e4SLinus Torvalds } 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds static int pid_delete_dentry(struct dentry * dentry) 14801da177e4SLinus Torvalds { 14811da177e4SLinus Torvalds /* Is the task we represent dead? 14821da177e4SLinus Torvalds * If so, then don't put the dentry on the lru list, 14831da177e4SLinus Torvalds * kill it immediately. 14841da177e4SLinus Torvalds */ 1485*99f89551SEric W. Biederman return !proc_tref(dentry->d_inode)->task; 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds static struct dentry_operations tid_fd_dentry_operations = 14891da177e4SLinus Torvalds { 14901da177e4SLinus Torvalds .d_revalidate = tid_fd_revalidate, 14911da177e4SLinus Torvalds .d_delete = pid_delete_dentry, 14921da177e4SLinus Torvalds }; 14931da177e4SLinus Torvalds 14941da177e4SLinus Torvalds static struct dentry_operations pid_dentry_operations = 14951da177e4SLinus Torvalds { 14961da177e4SLinus Torvalds .d_revalidate = pid_revalidate, 14971da177e4SLinus Torvalds .d_delete = pid_delete_dentry, 14981da177e4SLinus Torvalds }; 14991da177e4SLinus Torvalds 15001da177e4SLinus Torvalds /* Lookups */ 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds static unsigned name_to_int(struct dentry *dentry) 15031da177e4SLinus Torvalds { 15041da177e4SLinus Torvalds const char *name = dentry->d_name.name; 15051da177e4SLinus Torvalds int len = dentry->d_name.len; 15061da177e4SLinus Torvalds unsigned n = 0; 15071da177e4SLinus Torvalds 15081da177e4SLinus Torvalds if (len > 1 && *name == '0') 15091da177e4SLinus Torvalds goto out; 15101da177e4SLinus Torvalds while (len-- > 0) { 15111da177e4SLinus Torvalds unsigned c = *name++ - '0'; 15121da177e4SLinus Torvalds if (c > 9) 15131da177e4SLinus Torvalds goto out; 15141da177e4SLinus Torvalds if (n >= (~0U-9)/10) 15151da177e4SLinus Torvalds goto out; 15161da177e4SLinus Torvalds n *= 10; 15171da177e4SLinus Torvalds n += c; 15181da177e4SLinus Torvalds } 15191da177e4SLinus Torvalds return n; 15201da177e4SLinus Torvalds out: 15211da177e4SLinus Torvalds return ~0U; 15221da177e4SLinus Torvalds } 15231da177e4SLinus Torvalds 15241da177e4SLinus Torvalds /* SMP-safe */ 15251da177e4SLinus Torvalds static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry, struct nameidata *nd) 15261da177e4SLinus Torvalds { 1527*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 15281da177e4SLinus Torvalds unsigned fd = name_to_int(dentry); 1529cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 15301da177e4SLinus Torvalds struct file * file; 15311da177e4SLinus Torvalds struct files_struct * files; 15321da177e4SLinus Torvalds struct inode *inode; 15331da177e4SLinus Torvalds struct proc_inode *ei; 15341da177e4SLinus Torvalds 1535*99f89551SEric W. Biederman if (!task) 1536*99f89551SEric W. Biederman goto out_no_task; 15371da177e4SLinus Torvalds if (fd == ~0U) 15381da177e4SLinus Torvalds goto out; 15391da177e4SLinus Torvalds 15401da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_FD_DIR+fd); 15411da177e4SLinus Torvalds if (!inode) 15421da177e4SLinus Torvalds goto out; 15431da177e4SLinus Torvalds ei = PROC_I(inode); 1544aed7a6c4SEric W. Biederman ei->fd = fd; 15451da177e4SLinus Torvalds files = get_files_struct(task); 15461da177e4SLinus Torvalds if (!files) 15471da177e4SLinus Torvalds goto out_unlock; 15481da177e4SLinus Torvalds inode->i_mode = S_IFLNK; 1549ca99c1daSDipankar Sarma 1550ca99c1daSDipankar Sarma /* 1551ca99c1daSDipankar Sarma * We are not taking a ref to the file structure, so we must 1552ca99c1daSDipankar Sarma * hold ->file_lock. 1553ca99c1daSDipankar Sarma */ 1554ca99c1daSDipankar Sarma spin_lock(&files->file_lock); 15551da177e4SLinus Torvalds file = fcheck_files(files, fd); 15561da177e4SLinus Torvalds if (!file) 15571da177e4SLinus Torvalds goto out_unlock2; 15581da177e4SLinus Torvalds if (file->f_mode & 1) 15591da177e4SLinus Torvalds inode->i_mode |= S_IRUSR | S_IXUSR; 15601da177e4SLinus Torvalds if (file->f_mode & 2) 15611da177e4SLinus Torvalds inode->i_mode |= S_IWUSR | S_IXUSR; 1562ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 15631da177e4SLinus Torvalds put_files_struct(files); 15641da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 15651da177e4SLinus Torvalds inode->i_size = 64; 15661da177e4SLinus Torvalds ei->op.proc_get_link = proc_fd_link; 15671da177e4SLinus Torvalds dentry->d_op = &tid_fd_dentry_operations; 15681da177e4SLinus Torvalds d_add(dentry, inode); 1569cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 1570cd6a3ce9SEric W. Biederman if (tid_fd_revalidate(dentry, NULL)) 1571cd6a3ce9SEric W. Biederman result = NULL; 1572cd6a3ce9SEric W. Biederman out: 1573*99f89551SEric W. Biederman put_task_struct(task); 1574*99f89551SEric W. Biederman out_no_task: 1575cd6a3ce9SEric W. Biederman return result; 15761da177e4SLinus Torvalds 15771da177e4SLinus Torvalds out_unlock2: 1578ca99c1daSDipankar Sarma spin_unlock(&files->file_lock); 15791da177e4SLinus Torvalds put_files_struct(files); 15801da177e4SLinus Torvalds out_unlock: 15811da177e4SLinus Torvalds iput(inode); 1582cd6a3ce9SEric W. Biederman goto out; 15831da177e4SLinus Torvalds } 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir); 15861da177e4SLinus Torvalds static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd); 15876e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat); 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds static struct file_operations proc_fd_operations = { 15901da177e4SLinus Torvalds .read = generic_read_dir, 15911da177e4SLinus Torvalds .readdir = proc_readfd, 15921da177e4SLinus Torvalds }; 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds static struct file_operations proc_task_operations = { 15951da177e4SLinus Torvalds .read = generic_read_dir, 15961da177e4SLinus Torvalds .readdir = proc_task_readdir, 15971da177e4SLinus Torvalds }; 15981da177e4SLinus Torvalds 15991da177e4SLinus Torvalds /* 16001da177e4SLinus Torvalds * proc directories can do almost nothing.. 16011da177e4SLinus Torvalds */ 16021da177e4SLinus Torvalds static struct inode_operations proc_fd_inode_operations = { 16031da177e4SLinus Torvalds .lookup = proc_lookupfd, 16041da177e4SLinus Torvalds }; 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds static struct inode_operations proc_task_inode_operations = { 16071da177e4SLinus Torvalds .lookup = proc_task_lookup, 16086e66b52bSEric W. Biederman .getattr = proc_task_getattr, 16091da177e4SLinus Torvalds }; 16101da177e4SLinus Torvalds 16111da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 16121da177e4SLinus Torvalds static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 16131da177e4SLinus Torvalds size_t count, loff_t *ppos) 16141da177e4SLinus Torvalds { 16151da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 16161da177e4SLinus Torvalds unsigned long page; 16171da177e4SLinus Torvalds ssize_t length; 1618*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1619*99f89551SEric W. Biederman 1620*99f89551SEric W. Biederman length = -ESRCH; 1621*99f89551SEric W. Biederman if (!task) 1622*99f89551SEric W. Biederman goto out_no_task; 16231da177e4SLinus Torvalds 16241da177e4SLinus Torvalds if (count > PAGE_SIZE) 16251da177e4SLinus Torvalds count = PAGE_SIZE; 1626*99f89551SEric W. Biederman length = -ENOMEM; 16271da177e4SLinus Torvalds if (!(page = __get_free_page(GFP_KERNEL))) 1628*99f89551SEric W. Biederman goto out; 16291da177e4SLinus Torvalds 16301da177e4SLinus Torvalds length = security_getprocattr(task, 16311da177e4SLinus Torvalds (char*)file->f_dentry->d_name.name, 16321da177e4SLinus Torvalds (void*)page, count); 16331da177e4SLinus Torvalds if (length >= 0) 16341da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 16351da177e4SLinus Torvalds free_page(page); 1636*99f89551SEric W. Biederman out: 1637*99f89551SEric W. Biederman put_task_struct(task); 1638*99f89551SEric W. Biederman out_no_task: 16391da177e4SLinus Torvalds return length; 16401da177e4SLinus Torvalds } 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 16431da177e4SLinus Torvalds size_t count, loff_t *ppos) 16441da177e4SLinus Torvalds { 16451da177e4SLinus Torvalds struct inode * inode = file->f_dentry->d_inode; 16461da177e4SLinus Torvalds char *page; 16471da177e4SLinus Torvalds ssize_t length; 1648*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 16491da177e4SLinus Torvalds 1650*99f89551SEric W. Biederman length = -ESRCH; 1651*99f89551SEric W. Biederman if (!task) 1652*99f89551SEric W. Biederman goto out_no_task; 16531da177e4SLinus Torvalds if (count > PAGE_SIZE) 16541da177e4SLinus Torvalds count = PAGE_SIZE; 1655*99f89551SEric W. Biederman 16561da177e4SLinus Torvalds /* No partial writes. */ 1657*99f89551SEric W. Biederman length = -EINVAL; 1658*99f89551SEric W. Biederman if (*ppos != 0) 1659*99f89551SEric W. Biederman goto out; 1660*99f89551SEric W. Biederman 1661*99f89551SEric W. Biederman length = -ENOMEM; 16621da177e4SLinus Torvalds page = (char*)__get_free_page(GFP_USER); 16631da177e4SLinus Torvalds if (!page) 1664*99f89551SEric W. Biederman goto out; 1665*99f89551SEric W. Biederman 16661da177e4SLinus Torvalds length = -EFAULT; 16671da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 1668*99f89551SEric W. Biederman goto out_free; 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds length = security_setprocattr(task, 16711da177e4SLinus Torvalds (char*)file->f_dentry->d_name.name, 16721da177e4SLinus Torvalds (void*)page, count); 1673*99f89551SEric W. Biederman out_free: 16741da177e4SLinus Torvalds free_page((unsigned long) page); 1675*99f89551SEric W. Biederman out: 1676*99f89551SEric W. Biederman put_task_struct(task); 1677*99f89551SEric W. Biederman out_no_task: 16781da177e4SLinus Torvalds return length; 16791da177e4SLinus Torvalds } 16801da177e4SLinus Torvalds 16811da177e4SLinus Torvalds static struct file_operations proc_pid_attr_operations = { 16821da177e4SLinus Torvalds .read = proc_pid_attr_read, 16831da177e4SLinus Torvalds .write = proc_pid_attr_write, 16841da177e4SLinus Torvalds }; 16851da177e4SLinus Torvalds 16861da177e4SLinus Torvalds static struct file_operations proc_tid_attr_operations; 16871da177e4SLinus Torvalds static struct inode_operations proc_tid_attr_inode_operations; 16881da177e4SLinus Torvalds static struct file_operations proc_tgid_attr_operations; 16891da177e4SLinus Torvalds static struct inode_operations proc_tgid_attr_inode_operations; 16901da177e4SLinus Torvalds #endif 16911da177e4SLinus Torvalds 16921da177e4SLinus Torvalds /* SMP-safe */ 16931da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 16941da177e4SLinus Torvalds struct dentry *dentry, 16951da177e4SLinus Torvalds struct pid_entry *ents) 16961da177e4SLinus Torvalds { 16971da177e4SLinus Torvalds struct inode *inode; 1698cd6a3ce9SEric W. Biederman struct dentry *error; 1699*99f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 17001da177e4SLinus Torvalds struct pid_entry *p; 17011da177e4SLinus Torvalds struct proc_inode *ei; 17021da177e4SLinus Torvalds 1703cd6a3ce9SEric W. Biederman error = ERR_PTR(-ENOENT); 17041da177e4SLinus Torvalds inode = NULL; 17051da177e4SLinus Torvalds 1706*99f89551SEric W. Biederman if (!task) 1707*99f89551SEric W. Biederman goto out_no_task; 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds for (p = ents; p->name; p++) { 17101da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 17111da177e4SLinus Torvalds continue; 17121da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 17131da177e4SLinus Torvalds break; 17141da177e4SLinus Torvalds } 17151da177e4SLinus Torvalds if (!p->name) 17161da177e4SLinus Torvalds goto out; 17171da177e4SLinus Torvalds 1718cd6a3ce9SEric W. Biederman error = ERR_PTR(-EINVAL); 17191da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, p->type); 17201da177e4SLinus Torvalds if (!inode) 17211da177e4SLinus Torvalds goto out; 17221da177e4SLinus Torvalds 17231da177e4SLinus Torvalds ei = PROC_I(inode); 17241da177e4SLinus Torvalds inode->i_mode = p->mode; 17251da177e4SLinus Torvalds /* 17261da177e4SLinus Torvalds * Yes, it does not scale. And it should not. Don't add 17271da177e4SLinus Torvalds * new entries into /proc/<tgid>/ without very good reasons. 17281da177e4SLinus Torvalds */ 17291da177e4SLinus Torvalds switch(p->type) { 17301da177e4SLinus Torvalds case PROC_TGID_TASK: 17316e66b52bSEric W. Biederman inode->i_nlink = 2; 17321da177e4SLinus Torvalds inode->i_op = &proc_task_inode_operations; 17331da177e4SLinus Torvalds inode->i_fop = &proc_task_operations; 17341da177e4SLinus Torvalds break; 17351da177e4SLinus Torvalds case PROC_TID_FD: 17361da177e4SLinus Torvalds case PROC_TGID_FD: 17371da177e4SLinus Torvalds inode->i_nlink = 2; 17381da177e4SLinus Torvalds inode->i_op = &proc_fd_inode_operations; 17391da177e4SLinus Torvalds inode->i_fop = &proc_fd_operations; 17401da177e4SLinus Torvalds break; 17411da177e4SLinus Torvalds case PROC_TID_EXE: 17421da177e4SLinus Torvalds case PROC_TGID_EXE: 17431da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 17441da177e4SLinus Torvalds ei->op.proc_get_link = proc_exe_link; 17451da177e4SLinus Torvalds break; 17461da177e4SLinus Torvalds case PROC_TID_CWD: 17471da177e4SLinus Torvalds case PROC_TGID_CWD: 17481da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 17491da177e4SLinus Torvalds ei->op.proc_get_link = proc_cwd_link; 17501da177e4SLinus Torvalds break; 17511da177e4SLinus Torvalds case PROC_TID_ROOT: 17521da177e4SLinus Torvalds case PROC_TGID_ROOT: 17531da177e4SLinus Torvalds inode->i_op = &proc_pid_link_inode_operations; 17541da177e4SLinus Torvalds ei->op.proc_get_link = proc_root_link; 17551da177e4SLinus Torvalds break; 17561da177e4SLinus Torvalds case PROC_TID_ENVIRON: 17571da177e4SLinus Torvalds case PROC_TGID_ENVIRON: 17581da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17591da177e4SLinus Torvalds ei->op.proc_read = proc_pid_environ; 17601da177e4SLinus Torvalds break; 17611da177e4SLinus Torvalds case PROC_TID_AUXV: 17621da177e4SLinus Torvalds case PROC_TGID_AUXV: 17631da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17641da177e4SLinus Torvalds ei->op.proc_read = proc_pid_auxv; 17651da177e4SLinus Torvalds break; 17661da177e4SLinus Torvalds case PROC_TID_STATUS: 17671da177e4SLinus Torvalds case PROC_TGID_STATUS: 17681da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17691da177e4SLinus Torvalds ei->op.proc_read = proc_pid_status; 17701da177e4SLinus Torvalds break; 17711da177e4SLinus Torvalds case PROC_TID_STAT: 17721da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17731da177e4SLinus Torvalds ei->op.proc_read = proc_tid_stat; 17741da177e4SLinus Torvalds break; 17751da177e4SLinus Torvalds case PROC_TGID_STAT: 17761da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17771da177e4SLinus Torvalds ei->op.proc_read = proc_tgid_stat; 17781da177e4SLinus Torvalds break; 17791da177e4SLinus Torvalds case PROC_TID_CMDLINE: 17801da177e4SLinus Torvalds case PROC_TGID_CMDLINE: 17811da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17821da177e4SLinus Torvalds ei->op.proc_read = proc_pid_cmdline; 17831da177e4SLinus Torvalds break; 17841da177e4SLinus Torvalds case PROC_TID_STATM: 17851da177e4SLinus Torvalds case PROC_TGID_STATM: 17861da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 17871da177e4SLinus Torvalds ei->op.proc_read = proc_pid_statm; 17881da177e4SLinus Torvalds break; 17891da177e4SLinus Torvalds case PROC_TID_MAPS: 17901da177e4SLinus Torvalds case PROC_TGID_MAPS: 17911da177e4SLinus Torvalds inode->i_fop = &proc_maps_operations; 17921da177e4SLinus Torvalds break; 17936e21c8f1SChristoph Lameter #ifdef CONFIG_NUMA 17946e21c8f1SChristoph Lameter case PROC_TID_NUMA_MAPS: 17956e21c8f1SChristoph Lameter case PROC_TGID_NUMA_MAPS: 17966e21c8f1SChristoph Lameter inode->i_fop = &proc_numa_maps_operations; 17976e21c8f1SChristoph Lameter break; 17986e21c8f1SChristoph Lameter #endif 17991da177e4SLinus Torvalds case PROC_TID_MEM: 18001da177e4SLinus Torvalds case PROC_TGID_MEM: 18011da177e4SLinus Torvalds inode->i_fop = &proc_mem_operations; 18021da177e4SLinus Torvalds break; 18031da177e4SLinus Torvalds #ifdef CONFIG_SECCOMP 18041da177e4SLinus Torvalds case PROC_TID_SECCOMP: 18051da177e4SLinus Torvalds case PROC_TGID_SECCOMP: 18061da177e4SLinus Torvalds inode->i_fop = &proc_seccomp_operations; 18071da177e4SLinus Torvalds break; 18081da177e4SLinus Torvalds #endif /* CONFIG_SECCOMP */ 18091da177e4SLinus Torvalds case PROC_TID_MOUNTS: 18101da177e4SLinus Torvalds case PROC_TGID_MOUNTS: 18111da177e4SLinus Torvalds inode->i_fop = &proc_mounts_operations; 18121da177e4SLinus Torvalds break; 181363c6764cSYoshinori Sato #ifdef CONFIG_MMU 1814e070ad49SMauricio Lin case PROC_TID_SMAPS: 1815e070ad49SMauricio Lin case PROC_TGID_SMAPS: 1816e070ad49SMauricio Lin inode->i_fop = &proc_smaps_operations; 1817e070ad49SMauricio Lin break; 181863c6764cSYoshinori Sato #endif 1819b4629fe2SChuck Lever case PROC_TID_MOUNTSTATS: 1820b4629fe2SChuck Lever case PROC_TGID_MOUNTSTATS: 1821b4629fe2SChuck Lever inode->i_fop = &proc_mountstats_operations; 1822b4629fe2SChuck Lever break; 18231da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 18241da177e4SLinus Torvalds case PROC_TID_ATTR: 18251da177e4SLinus Torvalds inode->i_nlink = 2; 18261da177e4SLinus Torvalds inode->i_op = &proc_tid_attr_inode_operations; 18271da177e4SLinus Torvalds inode->i_fop = &proc_tid_attr_operations; 18281da177e4SLinus Torvalds break; 18291da177e4SLinus Torvalds case PROC_TGID_ATTR: 18301da177e4SLinus Torvalds inode->i_nlink = 2; 18311da177e4SLinus Torvalds inode->i_op = &proc_tgid_attr_inode_operations; 18321da177e4SLinus Torvalds inode->i_fop = &proc_tgid_attr_operations; 18331da177e4SLinus Torvalds break; 18341da177e4SLinus Torvalds case PROC_TID_ATTR_CURRENT: 18351da177e4SLinus Torvalds case PROC_TGID_ATTR_CURRENT: 18361da177e4SLinus Torvalds case PROC_TID_ATTR_PREV: 18371da177e4SLinus Torvalds case PROC_TGID_ATTR_PREV: 18381da177e4SLinus Torvalds case PROC_TID_ATTR_EXEC: 18391da177e4SLinus Torvalds case PROC_TGID_ATTR_EXEC: 18401da177e4SLinus Torvalds case PROC_TID_ATTR_FSCREATE: 18411da177e4SLinus Torvalds case PROC_TGID_ATTR_FSCREATE: 18424eb582cfSMichael LeMay case PROC_TID_ATTR_KEYCREATE: 18434eb582cfSMichael LeMay case PROC_TGID_ATTR_KEYCREATE: 18441da177e4SLinus Torvalds inode->i_fop = &proc_pid_attr_operations; 18451da177e4SLinus Torvalds break; 18461da177e4SLinus Torvalds #endif 18471da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 18481da177e4SLinus Torvalds case PROC_TID_WCHAN: 18491da177e4SLinus Torvalds case PROC_TGID_WCHAN: 18501da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 18511da177e4SLinus Torvalds ei->op.proc_read = proc_pid_wchan; 18521da177e4SLinus Torvalds break; 18531da177e4SLinus Torvalds #endif 18541da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 18551da177e4SLinus Torvalds case PROC_TID_SCHEDSTAT: 18561da177e4SLinus Torvalds case PROC_TGID_SCHEDSTAT: 18571da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 18581da177e4SLinus Torvalds ei->op.proc_read = proc_pid_schedstat; 18591da177e4SLinus Torvalds break; 18601da177e4SLinus Torvalds #endif 18611da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 18621da177e4SLinus Torvalds case PROC_TID_CPUSET: 18631da177e4SLinus Torvalds case PROC_TGID_CPUSET: 18641da177e4SLinus Torvalds inode->i_fop = &proc_cpuset_operations; 18651da177e4SLinus Torvalds break; 18661da177e4SLinus Torvalds #endif 18671da177e4SLinus Torvalds case PROC_TID_OOM_SCORE: 18681da177e4SLinus Torvalds case PROC_TGID_OOM_SCORE: 18691da177e4SLinus Torvalds inode->i_fop = &proc_info_file_operations; 18701da177e4SLinus Torvalds ei->op.proc_read = proc_oom_score; 18711da177e4SLinus Torvalds break; 18721da177e4SLinus Torvalds case PROC_TID_OOM_ADJUST: 18731da177e4SLinus Torvalds case PROC_TGID_OOM_ADJUST: 18741da177e4SLinus Torvalds inode->i_fop = &proc_oom_adjust_operations; 18751da177e4SLinus Torvalds break; 18761da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 18771da177e4SLinus Torvalds case PROC_TID_LOGINUID: 18781da177e4SLinus Torvalds case PROC_TGID_LOGINUID: 18791da177e4SLinus Torvalds inode->i_fop = &proc_loginuid_operations; 18801da177e4SLinus Torvalds break; 18811da177e4SLinus Torvalds #endif 18821da177e4SLinus Torvalds default: 18831da177e4SLinus Torvalds printk("procfs: impossible type (%d)",p->type); 18841da177e4SLinus Torvalds iput(inode); 1885cd6a3ce9SEric W. Biederman error = ERR_PTR(-EINVAL); 1886cd6a3ce9SEric W. Biederman goto out; 18871da177e4SLinus Torvalds } 18881da177e4SLinus Torvalds dentry->d_op = &pid_dentry_operations; 18891da177e4SLinus Torvalds d_add(dentry, inode); 1890cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 1891cd6a3ce9SEric W. Biederman if (pid_revalidate(dentry, NULL)) 1892cd6a3ce9SEric W. Biederman error = NULL; 18931da177e4SLinus Torvalds out: 1894*99f89551SEric W. Biederman put_task_struct(task); 1895*99f89551SEric W. Biederman out_no_task: 1896cd6a3ce9SEric W. Biederman return error; 18971da177e4SLinus Torvalds } 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 19001da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tgid_base_stuff); 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 19041da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tid_base_stuff); 19051da177e4SLinus Torvalds } 19061da177e4SLinus Torvalds 19071da177e4SLinus Torvalds static struct file_operations proc_tgid_base_operations = { 19081da177e4SLinus Torvalds .read = generic_read_dir, 19091da177e4SLinus Torvalds .readdir = proc_tgid_base_readdir, 19101da177e4SLinus Torvalds }; 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds static struct file_operations proc_tid_base_operations = { 19131da177e4SLinus Torvalds .read = generic_read_dir, 19141da177e4SLinus Torvalds .readdir = proc_tid_base_readdir, 19151da177e4SLinus Torvalds }; 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds static struct inode_operations proc_tgid_base_inode_operations = { 19181da177e4SLinus Torvalds .lookup = proc_tgid_base_lookup, 1919*99f89551SEric W. Biederman .getattr = pid_getattr, 19201da177e4SLinus Torvalds }; 19211da177e4SLinus Torvalds 19221da177e4SLinus Torvalds static struct inode_operations proc_tid_base_inode_operations = { 19231da177e4SLinus Torvalds .lookup = proc_tid_base_lookup, 1924*99f89551SEric W. Biederman .getattr = pid_getattr, 19251da177e4SLinus Torvalds }; 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 19281da177e4SLinus Torvalds static int proc_tgid_attr_readdir(struct file * filp, 19291da177e4SLinus Torvalds void * dirent, filldir_t filldir) 19301da177e4SLinus Torvalds { 19311da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 19321da177e4SLinus Torvalds tgid_attr_stuff,ARRAY_SIZE(tgid_attr_stuff)); 19331da177e4SLinus Torvalds } 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds static int proc_tid_attr_readdir(struct file * filp, 19361da177e4SLinus Torvalds void * dirent, filldir_t filldir) 19371da177e4SLinus Torvalds { 19381da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 19391da177e4SLinus Torvalds tid_attr_stuff,ARRAY_SIZE(tid_attr_stuff)); 19401da177e4SLinus Torvalds } 19411da177e4SLinus Torvalds 19421da177e4SLinus Torvalds static struct file_operations proc_tgid_attr_operations = { 19431da177e4SLinus Torvalds .read = generic_read_dir, 19441da177e4SLinus Torvalds .readdir = proc_tgid_attr_readdir, 19451da177e4SLinus Torvalds }; 19461da177e4SLinus Torvalds 19471da177e4SLinus Torvalds static struct file_operations proc_tid_attr_operations = { 19481da177e4SLinus Torvalds .read = generic_read_dir, 19491da177e4SLinus Torvalds .readdir = proc_tid_attr_readdir, 19501da177e4SLinus Torvalds }; 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds static struct dentry *proc_tgid_attr_lookup(struct inode *dir, 19531da177e4SLinus Torvalds struct dentry *dentry, struct nameidata *nd) 19541da177e4SLinus Torvalds { 19551da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tgid_attr_stuff); 19561da177e4SLinus Torvalds } 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds static struct dentry *proc_tid_attr_lookup(struct inode *dir, 19591da177e4SLinus Torvalds struct dentry *dentry, struct nameidata *nd) 19601da177e4SLinus Torvalds { 19611da177e4SLinus Torvalds return proc_pident_lookup(dir, dentry, tid_attr_stuff); 19621da177e4SLinus Torvalds } 19631da177e4SLinus Torvalds 19641da177e4SLinus Torvalds static struct inode_operations proc_tgid_attr_inode_operations = { 19651da177e4SLinus Torvalds .lookup = proc_tgid_attr_lookup, 1966*99f89551SEric W. Biederman .getattr = pid_getattr, 19671da177e4SLinus Torvalds }; 19681da177e4SLinus Torvalds 19691da177e4SLinus Torvalds static struct inode_operations proc_tid_attr_inode_operations = { 19701da177e4SLinus Torvalds .lookup = proc_tid_attr_lookup, 1971*99f89551SEric W. Biederman .getattr = pid_getattr, 19721da177e4SLinus Torvalds }; 19731da177e4SLinus Torvalds #endif 19741da177e4SLinus Torvalds 19751da177e4SLinus Torvalds /* 19761da177e4SLinus Torvalds * /proc/self: 19771da177e4SLinus Torvalds */ 19781da177e4SLinus Torvalds static int proc_self_readlink(struct dentry *dentry, char __user *buffer, 19791da177e4SLinus Torvalds int buflen) 19801da177e4SLinus Torvalds { 19818578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 19821da177e4SLinus Torvalds sprintf(tmp, "%d", current->tgid); 19831da177e4SLinus Torvalds return vfs_readlink(dentry,buffer,buflen,tmp); 19841da177e4SLinus Torvalds } 19851da177e4SLinus Torvalds 1986008b150aSAl Viro static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd) 19871da177e4SLinus Torvalds { 19888578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 19891da177e4SLinus Torvalds sprintf(tmp, "%d", current->tgid); 1990008b150aSAl Viro return ERR_PTR(vfs_follow_link(nd,tmp)); 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds 19931da177e4SLinus Torvalds static struct inode_operations proc_self_inode_operations = { 19941da177e4SLinus Torvalds .readlink = proc_self_readlink, 19951da177e4SLinus Torvalds .follow_link = proc_self_follow_link, 19961da177e4SLinus Torvalds }; 19971da177e4SLinus Torvalds 19981da177e4SLinus Torvalds /** 199948e6484dSEric W. Biederman * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 20001da177e4SLinus Torvalds * 200148e6484dSEric W. Biederman * @task: task that should be flushed. 20021da177e4SLinus Torvalds * 200348e6484dSEric W. Biederman * Looks in the dcache for 200448e6484dSEric W. Biederman * /proc/@pid 200548e6484dSEric W. Biederman * /proc/@tgid/task/@pid 200648e6484dSEric W. Biederman * if either directory is present flushes it and all of it'ts children 200748e6484dSEric W. Biederman * from the dcache. 200848e6484dSEric W. Biederman * 200948e6484dSEric W. Biederman * It is safe and reasonable to cache /proc entries for a task until 201048e6484dSEric W. Biederman * that task exits. After that they just clog up the dcache with 201148e6484dSEric W. Biederman * useless entries, possibly causing useful dcache entries to be 201248e6484dSEric W. Biederman * flushed instead. This routine is proved to flush those useless 201348e6484dSEric W. Biederman * dcache entries at process exit time. 201448e6484dSEric W. Biederman * 201548e6484dSEric W. Biederman * NOTE: This routine is just an optimization so it does not guarantee 201648e6484dSEric W. Biederman * that no dcache entries will exist at process exit time it 201748e6484dSEric W. Biederman * just makes it very unlikely that any will persist. 20181da177e4SLinus Torvalds */ 201948e6484dSEric W. Biederman void proc_flush_task(struct task_struct *task) 20201da177e4SLinus Torvalds { 202148e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 20228578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 202348e6484dSEric W. Biederman struct qstr name; 20241da177e4SLinus Torvalds 202548e6484dSEric W. Biederman name.name = buf; 202648e6484dSEric W. Biederman name.len = snprintf(buf, sizeof(buf), "%d", task->pid); 202748e6484dSEric W. Biederman dentry = d_hash_and_lookup(proc_mnt->mnt_root, &name); 202848e6484dSEric W. Biederman if (dentry) { 202948e6484dSEric W. Biederman shrink_dcache_parent(dentry); 203048e6484dSEric W. Biederman d_drop(dentry); 203148e6484dSEric W. Biederman dput(dentry); 20321da177e4SLinus Torvalds } 20331da177e4SLinus Torvalds 203448e6484dSEric W. Biederman if (thread_group_leader(task)) 203548e6484dSEric W. Biederman goto out; 20361da177e4SLinus Torvalds 203748e6484dSEric W. Biederman name.name = buf; 203848e6484dSEric W. Biederman name.len = snprintf(buf, sizeof(buf), "%d", task->tgid); 203948e6484dSEric W. Biederman leader = d_hash_and_lookup(proc_mnt->mnt_root, &name); 204048e6484dSEric W. Biederman if (!leader) 204148e6484dSEric W. Biederman goto out; 204248e6484dSEric W. Biederman 204348e6484dSEric W. Biederman name.name = "task"; 204448e6484dSEric W. Biederman name.len = strlen(name.name); 204548e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 204648e6484dSEric W. Biederman if (!dir) 204748e6484dSEric W. Biederman goto out_put_leader; 204848e6484dSEric W. Biederman 204948e6484dSEric W. Biederman name.name = buf; 205048e6484dSEric W. Biederman name.len = snprintf(buf, sizeof(buf), "%d", task->pid); 205148e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 205248e6484dSEric W. Biederman if (dentry) { 205348e6484dSEric W. Biederman shrink_dcache_parent(dentry); 205448e6484dSEric W. Biederman d_drop(dentry); 205548e6484dSEric W. Biederman dput(dentry); 20561da177e4SLinus Torvalds } 205748e6484dSEric W. Biederman 205848e6484dSEric W. Biederman dput(dir); 205948e6484dSEric W. Biederman out_put_leader: 206048e6484dSEric W. Biederman dput(leader); 206148e6484dSEric W. Biederman out: 206248e6484dSEric W. Biederman return; 20631da177e4SLinus Torvalds } 20641da177e4SLinus Torvalds 20651da177e4SLinus Torvalds /* SMP-safe */ 20661da177e4SLinus Torvalds struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 20671da177e4SLinus Torvalds { 2068cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 20691da177e4SLinus Torvalds struct task_struct *task; 20701da177e4SLinus Torvalds struct inode *inode; 20711da177e4SLinus Torvalds struct proc_inode *ei; 20721da177e4SLinus Torvalds unsigned tgid; 20731da177e4SLinus Torvalds 20741da177e4SLinus Torvalds if (dentry->d_name.len == 4 && !memcmp(dentry->d_name.name,"self",4)) { 20751da177e4SLinus Torvalds inode = new_inode(dir->i_sb); 20761da177e4SLinus Torvalds if (!inode) 20771da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 20781da177e4SLinus Torvalds ei = PROC_I(inode); 20791da177e4SLinus Torvalds inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 20801da177e4SLinus Torvalds inode->i_ino = fake_ino(0, PROC_TGID_INO); 20811da177e4SLinus Torvalds ei->pde = NULL; 20821da177e4SLinus Torvalds inode->i_mode = S_IFLNK|S_IRWXUGO; 20831da177e4SLinus Torvalds inode->i_uid = inode->i_gid = 0; 20841da177e4SLinus Torvalds inode->i_size = 64; 20851da177e4SLinus Torvalds inode->i_op = &proc_self_inode_operations; 20861da177e4SLinus Torvalds d_add(dentry, inode); 20871da177e4SLinus Torvalds return NULL; 20881da177e4SLinus Torvalds } 20891da177e4SLinus Torvalds tgid = name_to_int(dentry); 20901da177e4SLinus Torvalds if (tgid == ~0U) 20911da177e4SLinus Torvalds goto out; 20921da177e4SLinus Torvalds 2093de758734SEric W. Biederman rcu_read_lock(); 20941da177e4SLinus Torvalds task = find_task_by_pid(tgid); 20951da177e4SLinus Torvalds if (task) 20961da177e4SLinus Torvalds get_task_struct(task); 2097de758734SEric W. Biederman rcu_read_unlock(); 20981da177e4SLinus Torvalds if (!task) 20991da177e4SLinus Torvalds goto out; 21001da177e4SLinus Torvalds 21011da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, PROC_TGID_INO); 2102cd6a3ce9SEric W. Biederman if (!inode) 2103cd6a3ce9SEric W. Biederman goto out_put_task; 21041da177e4SLinus Torvalds 21051da177e4SLinus Torvalds inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 21061da177e4SLinus Torvalds inode->i_op = &proc_tgid_base_inode_operations; 21071da177e4SLinus Torvalds inode->i_fop = &proc_tgid_base_operations; 21081da177e4SLinus Torvalds inode->i_flags|=S_IMMUTABLE; 2109bcf88e11SDaniel Drake #ifdef CONFIG_SECURITY 2110bcf88e11SDaniel Drake inode->i_nlink = 5; 2111bcf88e11SDaniel Drake #else 2112bcf88e11SDaniel Drake inode->i_nlink = 4; 2113bcf88e11SDaniel Drake #endif 21141da177e4SLinus Torvalds 211548e6484dSEric W. Biederman dentry->d_op = &pid_dentry_operations; 21161da177e4SLinus Torvalds 21171da177e4SLinus Torvalds d_add(dentry, inode); 2118cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2119cd6a3ce9SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2120cd6a3ce9SEric W. Biederman result = NULL; 212148e6484dSEric W. Biederman 2122cd6a3ce9SEric W. Biederman out_put_task: 212348e6484dSEric W. Biederman put_task_struct(task); 21241da177e4SLinus Torvalds out: 2125cd6a3ce9SEric W. Biederman return result; 21261da177e4SLinus Torvalds } 21271da177e4SLinus Torvalds 21281da177e4SLinus Torvalds /* SMP-safe */ 21291da177e4SLinus Torvalds static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 21301da177e4SLinus Torvalds { 2131cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 21321da177e4SLinus Torvalds struct task_struct *task; 2133*99f89551SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 21341da177e4SLinus Torvalds struct inode *inode; 21351da177e4SLinus Torvalds unsigned tid; 21361da177e4SLinus Torvalds 2137*99f89551SEric W. Biederman if (!leader) 2138*99f89551SEric W. Biederman goto out_no_task; 2139*99f89551SEric W. Biederman 21401da177e4SLinus Torvalds tid = name_to_int(dentry); 21411da177e4SLinus Torvalds if (tid == ~0U) 21421da177e4SLinus Torvalds goto out; 21431da177e4SLinus Torvalds 2144de758734SEric W. Biederman rcu_read_lock(); 21451da177e4SLinus Torvalds task = find_task_by_pid(tid); 21461da177e4SLinus Torvalds if (task) 21471da177e4SLinus Torvalds get_task_struct(task); 2148de758734SEric W. Biederman rcu_read_unlock(); 21491da177e4SLinus Torvalds if (!task) 21501da177e4SLinus Torvalds goto out; 21511da177e4SLinus Torvalds if (leader->tgid != task->tgid) 21521da177e4SLinus Torvalds goto out_drop_task; 21531da177e4SLinus Torvalds 21541da177e4SLinus Torvalds inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_INO); 21551da177e4SLinus Torvalds 21561da177e4SLinus Torvalds 21571da177e4SLinus Torvalds if (!inode) 21581da177e4SLinus Torvalds goto out_drop_task; 21591da177e4SLinus Torvalds inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 21601da177e4SLinus Torvalds inode->i_op = &proc_tid_base_inode_operations; 21611da177e4SLinus Torvalds inode->i_fop = &proc_tid_base_operations; 21621da177e4SLinus Torvalds inode->i_flags|=S_IMMUTABLE; 2163bcf88e11SDaniel Drake #ifdef CONFIG_SECURITY 2164bcf88e11SDaniel Drake inode->i_nlink = 4; 2165bcf88e11SDaniel Drake #else 2166bcf88e11SDaniel Drake inode->i_nlink = 3; 2167bcf88e11SDaniel Drake #endif 21681da177e4SLinus Torvalds 216948e6484dSEric W. Biederman dentry->d_op = &pid_dentry_operations; 21701da177e4SLinus Torvalds 21711da177e4SLinus Torvalds d_add(dentry, inode); 2172cd6a3ce9SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2173cd6a3ce9SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2174cd6a3ce9SEric W. Biederman result = NULL; 21751da177e4SLinus Torvalds 21761da177e4SLinus Torvalds out_drop_task: 21771da177e4SLinus Torvalds put_task_struct(task); 21781da177e4SLinus Torvalds out: 2179*99f89551SEric W. Biederman put_task_struct(leader); 2180*99f89551SEric W. Biederman out_no_task: 2181cd6a3ce9SEric W. Biederman return result; 21821da177e4SLinus Torvalds } 21831da177e4SLinus Torvalds 21841da177e4SLinus Torvalds /* 21850bc58a91SEric W. Biederman * Find the first tgid to return to user space. 21860bc58a91SEric W. Biederman * 21870bc58a91SEric W. Biederman * Usually this is just whatever follows &init_task, but if the users 21880bc58a91SEric W. Biederman * buffer was too small to hold the full list or there was a seek into 21890bc58a91SEric W. Biederman * the middle of the directory we have more work to do. 21900bc58a91SEric W. Biederman * 21910bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 21920bc58a91SEric W. Biederman * 21930bc58a91SEric W. Biederman * In the case of a seek we start with &init_task and walk nr 21940bc58a91SEric W. Biederman * threads past it. 21951da177e4SLinus Torvalds */ 21969cc8cbc7SEric W. Biederman static struct task_struct *first_tgid(int tgid, unsigned int nr) 21971da177e4SLinus Torvalds { 21989cc8cbc7SEric W. Biederman struct task_struct *pos; 2199454cc105SEric W. Biederman rcu_read_lock(); 22000bc58a91SEric W. Biederman if (tgid && nr) { 22010bc58a91SEric W. Biederman pos = find_task_by_pid(tgid); 22029cc8cbc7SEric W. Biederman if (pos && thread_group_leader(pos)) 22039cc8cbc7SEric W. Biederman goto found; 22041da177e4SLinus Torvalds } 22050bc58a91SEric W. Biederman /* If nr exceeds the number of processes get out quickly */ 22069cc8cbc7SEric W. Biederman pos = NULL; 22070bc58a91SEric W. Biederman if (nr && nr >= nr_processes()) 22080bc58a91SEric W. Biederman goto done; 22091da177e4SLinus Torvalds 22100bc58a91SEric W. Biederman /* If we haven't found our starting place yet start with 22110bc58a91SEric W. Biederman * the init_task and walk nr tasks forward. 22120bc58a91SEric W. Biederman */ 22139cc8cbc7SEric W. Biederman for (pos = next_task(&init_task); nr > 0; --nr) { 22149cc8cbc7SEric W. Biederman pos = next_task(pos); 22159cc8cbc7SEric W. Biederman if (pos == &init_task) { 22169cc8cbc7SEric W. Biederman pos = NULL; 22170bc58a91SEric W. Biederman goto done; 22181da177e4SLinus Torvalds } 22199cc8cbc7SEric W. Biederman } 22209cc8cbc7SEric W. Biederman found: 22219cc8cbc7SEric W. Biederman get_task_struct(pos); 22220bc58a91SEric W. Biederman done: 2223454cc105SEric W. Biederman rcu_read_unlock(); 22240bc58a91SEric W. Biederman return pos; 22251da177e4SLinus Torvalds } 22261da177e4SLinus Torvalds 22271da177e4SLinus Torvalds /* 22280bc58a91SEric W. Biederman * Find the next task in the task list. 22290bc58a91SEric W. Biederman * Return NULL if we loop or there is any error. 22300bc58a91SEric W. Biederman * 22310bc58a91SEric W. Biederman * The reference to the input task_struct is released. 22321da177e4SLinus Torvalds */ 22330bc58a91SEric W. Biederman static struct task_struct *next_tgid(struct task_struct *start) 22341da177e4SLinus Torvalds { 22350bc58a91SEric W. Biederman struct task_struct *pos; 2236454cc105SEric W. Biederman rcu_read_lock(); 22370bc58a91SEric W. Biederman pos = start; 22380bc58a91SEric W. Biederman if (pid_alive(start)) 22390bc58a91SEric W. Biederman pos = next_task(start); 22400bc58a91SEric W. Biederman if (pid_alive(pos) && (pos != &init_task)) { 22410bc58a91SEric W. Biederman get_task_struct(pos); 22420bc58a91SEric W. Biederman goto done; 22430bc58a91SEric W. Biederman } 22440bc58a91SEric W. Biederman pos = NULL; 22450bc58a91SEric W. Biederman done: 2246454cc105SEric W. Biederman rcu_read_unlock(); 22470bc58a91SEric W. Biederman put_task_struct(start); 22480bc58a91SEric W. Biederman return pos; 22491da177e4SLinus Torvalds } 22501da177e4SLinus Torvalds 22511da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 22521da177e4SLinus Torvalds int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir) 22531da177e4SLinus Torvalds { 22541da177e4SLinus Torvalds char buf[PROC_NUMBUF]; 22551da177e4SLinus Torvalds unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY; 22560bc58a91SEric W. Biederman struct task_struct *task; 22570bc58a91SEric W. Biederman int tgid; 22581da177e4SLinus Torvalds 22591da177e4SLinus Torvalds if (!nr) { 22601da177e4SLinus Torvalds ino_t ino = fake_ino(0,PROC_TGID_INO); 22611da177e4SLinus Torvalds if (filldir(dirent, "self", 4, filp->f_pos, ino, DT_LNK) < 0) 22621da177e4SLinus Torvalds return 0; 22631da177e4SLinus Torvalds filp->f_pos++; 22641da177e4SLinus Torvalds nr++; 22651da177e4SLinus Torvalds } 22660bc58a91SEric W. Biederman nr -= 1; 22671da177e4SLinus Torvalds 22681da177e4SLinus Torvalds /* f_version caches the tgid value that the last readdir call couldn't 22691da177e4SLinus Torvalds * return. lseek aka telldir automagically resets f_version to 0. 22701da177e4SLinus Torvalds */ 22710bc58a91SEric W. Biederman tgid = filp->f_version; 22721da177e4SLinus Torvalds filp->f_version = 0; 22730bc58a91SEric W. Biederman for (task = first_tgid(tgid, nr); 22740bc58a91SEric W. Biederman task; 22750bc58a91SEric W. Biederman task = next_tgid(task), filp->f_pos++) { 22760bc58a91SEric W. Biederman int len; 22770bc58a91SEric W. Biederman ino_t ino; 22780bc58a91SEric W. Biederman tgid = task->pid; 22790bc58a91SEric W. Biederman len = snprintf(buf, sizeof(buf), "%d", tgid); 22800bc58a91SEric W. Biederman ino = fake_ino(tgid, PROC_TGID_INO); 22810bc58a91SEric W. Biederman if (filldir(dirent, buf, len, filp->f_pos, ino, DT_DIR) < 0) { 22821da177e4SLinus Torvalds /* returning this tgid failed, save it as the first 22831da177e4SLinus Torvalds * pid for the next readir call */ 22840bc58a91SEric W. Biederman filp->f_version = tgid; 22850bc58a91SEric W. Biederman put_task_struct(task); 22860bc58a91SEric W. Biederman break; 22871da177e4SLinus Torvalds } 22881da177e4SLinus Torvalds } 22891da177e4SLinus Torvalds return 0; 22901da177e4SLinus Torvalds } 22911da177e4SLinus Torvalds 22920bc58a91SEric W. Biederman /* 22930bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 22940bc58a91SEric W. Biederman * 22950bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 22960bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 22970bc58a91SEric W. Biederman * directory we have more work todo. 22980bc58a91SEric W. Biederman * 22990bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 23000bc58a91SEric W. Biederman * 23010bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 23020bc58a91SEric W. Biederman * threads past it. 23030bc58a91SEric W. Biederman */ 23040bc58a91SEric W. Biederman static struct task_struct *first_tid(struct task_struct *leader, int tid, int nr) 23050bc58a91SEric W. Biederman { 23060bc58a91SEric W. Biederman struct task_struct *pos = NULL; 23070bc58a91SEric W. Biederman read_lock(&tasklist_lock); 23080bc58a91SEric W. Biederman 23090bc58a91SEric W. Biederman /* Attempt to start with the pid of a thread */ 23100bc58a91SEric W. Biederman if (tid && (nr > 0)) { 23110bc58a91SEric W. Biederman pos = find_task_by_pid(tid); 23120bc58a91SEric W. Biederman if (pos && (pos->group_leader != leader)) 23130bc58a91SEric W. Biederman pos = NULL; 23140bc58a91SEric W. Biederman if (pos) 23150bc58a91SEric W. Biederman nr = 0; 23160bc58a91SEric W. Biederman } 23170bc58a91SEric W. Biederman 23180bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 23190bc58a91SEric W. Biederman if (nr) { 2320*99f89551SEric W. Biederman if (nr >= get_nr_threads(leader)) 23210bc58a91SEric W. Biederman goto done; 23220bc58a91SEric W. Biederman } 23230bc58a91SEric W. Biederman 23240bc58a91SEric W. Biederman /* If we haven't found our starting place yet start with the 23250bc58a91SEric W. Biederman * leader and walk nr threads forward. 23260bc58a91SEric W. Biederman */ 23270bc58a91SEric W. Biederman if (!pos && (nr >= 0)) 23280bc58a91SEric W. Biederman pos = leader; 23290bc58a91SEric W. Biederman 23300bc58a91SEric W. Biederman for (; pos && pid_alive(pos); pos = next_thread(pos)) { 23310bc58a91SEric W. Biederman if (--nr > 0) 23320bc58a91SEric W. Biederman continue; 23330bc58a91SEric W. Biederman get_task_struct(pos); 23340bc58a91SEric W. Biederman goto done; 23350bc58a91SEric W. Biederman } 23360bc58a91SEric W. Biederman pos = NULL; 23370bc58a91SEric W. Biederman done: 23380bc58a91SEric W. Biederman read_unlock(&tasklist_lock); 23390bc58a91SEric W. Biederman return pos; 23400bc58a91SEric W. Biederman } 23410bc58a91SEric W. Biederman 23420bc58a91SEric W. Biederman /* 23430bc58a91SEric W. Biederman * Find the next thread in the thread list. 23440bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 23450bc58a91SEric W. Biederman * 23460bc58a91SEric W. Biederman * The reference to the input task_struct is released. 23470bc58a91SEric W. Biederman */ 23480bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 23490bc58a91SEric W. Biederman { 23500bc58a91SEric W. Biederman struct task_struct *pos; 23510bc58a91SEric W. Biederman read_lock(&tasklist_lock); 23520bc58a91SEric W. Biederman pos = start; 23530bc58a91SEric W. Biederman if (pid_alive(start)) 23540bc58a91SEric W. Biederman pos = next_thread(start); 23550bc58a91SEric W. Biederman if (pid_alive(pos) && (pos != start->group_leader)) 23560bc58a91SEric W. Biederman get_task_struct(pos); 23570bc58a91SEric W. Biederman else 23580bc58a91SEric W. Biederman pos = NULL; 23590bc58a91SEric W. Biederman read_unlock(&tasklist_lock); 23600bc58a91SEric W. Biederman put_task_struct(start); 23610bc58a91SEric W. Biederman return pos; 23620bc58a91SEric W. Biederman } 23630bc58a91SEric W. Biederman 23641da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 23651da177e4SLinus Torvalds static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir) 23661da177e4SLinus Torvalds { 23671da177e4SLinus Torvalds char buf[PROC_NUMBUF]; 23681da177e4SLinus Torvalds struct dentry *dentry = filp->f_dentry; 23691da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 2370*99f89551SEric W. Biederman struct task_struct *leader = get_proc_task(inode); 23710bc58a91SEric W. Biederman struct task_struct *task; 23721da177e4SLinus Torvalds int retval = -ENOENT; 23731da177e4SLinus Torvalds ino_t ino; 23740bc58a91SEric W. Biederman int tid; 23751da177e4SLinus Torvalds unsigned long pos = filp->f_pos; /* avoiding "long long" filp->f_pos */ 23761da177e4SLinus Torvalds 2377*99f89551SEric W. Biederman if (!leader) 2378*99f89551SEric W. Biederman goto out_no_task; 23791da177e4SLinus Torvalds retval = 0; 23801da177e4SLinus Torvalds 23811da177e4SLinus Torvalds switch (pos) { 23821da177e4SLinus Torvalds case 0: 23831da177e4SLinus Torvalds ino = inode->i_ino; 23841da177e4SLinus Torvalds if (filldir(dirent, ".", 1, pos, ino, DT_DIR) < 0) 23851da177e4SLinus Torvalds goto out; 23861da177e4SLinus Torvalds pos++; 23871da177e4SLinus Torvalds /* fall through */ 23881da177e4SLinus Torvalds case 1: 23891da177e4SLinus Torvalds ino = parent_ino(dentry); 23901da177e4SLinus Torvalds if (filldir(dirent, "..", 2, pos, ino, DT_DIR) < 0) 23911da177e4SLinus Torvalds goto out; 23921da177e4SLinus Torvalds pos++; 23931da177e4SLinus Torvalds /* fall through */ 23941da177e4SLinus Torvalds } 23951da177e4SLinus Torvalds 23960bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 23970bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 23980bc58a91SEric W. Biederman */ 23990bc58a91SEric W. Biederman tid = filp->f_version; 24000bc58a91SEric W. Biederman filp->f_version = 0; 24010bc58a91SEric W. Biederman for (task = first_tid(leader, tid, pos - 2); 24020bc58a91SEric W. Biederman task; 24030bc58a91SEric W. Biederman task = next_tid(task), pos++) { 24040bc58a91SEric W. Biederman int len; 24050bc58a91SEric W. Biederman tid = task->pid; 24060bc58a91SEric W. Biederman len = snprintf(buf, sizeof(buf), "%d", tid); 24071da177e4SLinus Torvalds ino = fake_ino(tid, PROC_TID_INO); 24080bc58a91SEric W. Biederman if (filldir(dirent, buf, len, pos, ino, DT_DIR < 0)) { 24090bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 24100bc58a91SEric W. Biederman * pid for the next readir call */ 24110bc58a91SEric W. Biederman filp->f_version = tid; 24120bc58a91SEric W. Biederman put_task_struct(task); 24131da177e4SLinus Torvalds break; 24140bc58a91SEric W. Biederman } 24151da177e4SLinus Torvalds } 24161da177e4SLinus Torvalds out: 24171da177e4SLinus Torvalds filp->f_pos = pos; 2418*99f89551SEric W. Biederman put_task_struct(leader); 2419*99f89551SEric W. Biederman out_no_task: 24201da177e4SLinus Torvalds return retval; 24211da177e4SLinus Torvalds } 24226e66b52bSEric W. Biederman 24236e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 24246e66b52bSEric W. Biederman { 24256e66b52bSEric W. Biederman struct inode *inode = dentry->d_inode; 2426*99f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 24276e66b52bSEric W. Biederman generic_fillattr(inode, stat); 24286e66b52bSEric W. Biederman 2429*99f89551SEric W. Biederman if (p) { 2430*99f89551SEric W. Biederman rcu_read_lock(); 2431*99f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 2432*99f89551SEric W. Biederman rcu_read_unlock(); 2433*99f89551SEric W. Biederman put_task_struct(p); 24346e66b52bSEric W. Biederman } 24356e66b52bSEric W. Biederman 24366e66b52bSEric W. Biederman return 0; 24376e66b52bSEric W. Biederman } 2438