11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/proc/base.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * proc base directory handling functions 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * 1999, Al Viro. Rewritten. Now it covers the whole per-process part. 91da177e4SLinus Torvalds * Instead of using magical inumbers to determine the kind of object 101da177e4SLinus Torvalds * we allocate and fill in-core inodes upon lookup. They don't even 111da177e4SLinus Torvalds * go into icache. We cache the reference to task_struct upon lookup too. 121da177e4SLinus Torvalds * Eventually it should become a filesystem in its own. We don't use the 131da177e4SLinus Torvalds * rest of procfs anymore. 14e070ad49SMauricio Lin * 15e070ad49SMauricio Lin * 16e070ad49SMauricio Lin * Changelog: 17e070ad49SMauricio Lin * 17-Jan-2005 18e070ad49SMauricio Lin * Allan Bezerra 19e070ad49SMauricio Lin * Bruna Moreira <bruna.moreira@indt.org.br> 20e070ad49SMauricio Lin * Edjard Mota <edjard.mota@indt.org.br> 21e070ad49SMauricio Lin * Ilias Biris <ilias.biris@indt.org.br> 22e070ad49SMauricio Lin * Mauricio Lin <mauricio.lin@indt.org.br> 23e070ad49SMauricio Lin * 24e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 25e070ad49SMauricio Lin * 26e070ad49SMauricio Lin * A new process specific entry (smaps) included in /proc. It shows the 27e070ad49SMauricio Lin * size of rss for each memory area. The maps entry lacks information 28e070ad49SMauricio Lin * about physical memory size (rss) for each mapped file, i.e., 29e070ad49SMauricio Lin * rss information for executables and library files. 30e070ad49SMauricio Lin * This additional information is useful for any tools that need to know 31e070ad49SMauricio Lin * about physical memory consumption for a process specific library. 32e070ad49SMauricio Lin * 33e070ad49SMauricio Lin * Changelog: 34e070ad49SMauricio Lin * 21-Feb-2005 35e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 36e070ad49SMauricio Lin * Pud inclusion in the page table walking. 37e070ad49SMauricio Lin * 38e070ad49SMauricio Lin * ChangeLog: 39e070ad49SMauricio Lin * 10-Mar-2005 40e070ad49SMauricio Lin * 10LE Instituto Nokia de Tecnologia - INdT: 41e070ad49SMauricio Lin * A better way to walks through the page table as suggested by Hugh Dickins. 42e070ad49SMauricio Lin * 43e070ad49SMauricio Lin * Simo Piiroinen <simo.piiroinen@nokia.com>: 44e070ad49SMauricio Lin * Smaps information related to shared, private, clean and dirty pages. 45e070ad49SMauricio Lin * 46e070ad49SMauricio Lin * Paul Mundt <paul.mundt@nokia.com>: 47e070ad49SMauricio Lin * Overall revision about smaps. 481da177e4SLinus Torvalds */ 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include <asm/uaccess.h> 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #include <linux/errno.h> 531da177e4SLinus Torvalds #include <linux/time.h> 541da177e4SLinus Torvalds #include <linux/proc_fs.h> 551da177e4SLinus Torvalds #include <linux/stat.h> 565995477aSAndrea Righi #include <linux/task_io_accounting_ops.h> 571da177e4SLinus Torvalds #include <linux/init.h> 5816f7e0feSRandy Dunlap #include <linux/capability.h> 591da177e4SLinus Torvalds #include <linux/file.h> 609f3acc31SAl Viro #include <linux/fdtable.h> 611da177e4SLinus Torvalds #include <linux/string.h> 621da177e4SLinus Torvalds #include <linux/seq_file.h> 631da177e4SLinus Torvalds #include <linux/namei.h> 646b3286edSKirill Korotaev #include <linux/mnt_namespace.h> 651da177e4SLinus Torvalds #include <linux/mm.h> 66a63d83f4SDavid Rientjes #include <linux/swap.h> 67b835996fSDipankar Sarma #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/kallsyms.h> 692ec220e2SKen Chen #include <linux/stacktrace.h> 70d85f50d5SNeil Horman #include <linux/resource.h> 715096add8SKees Cook #include <linux/module.h> 721da177e4SLinus Torvalds #include <linux/mount.h> 731da177e4SLinus Torvalds #include <linux/security.h> 741da177e4SLinus Torvalds #include <linux/ptrace.h> 750d094efeSRoland McGrath #include <linux/tracehook.h> 76a424316cSPaul Menage #include <linux/cgroup.h> 771da177e4SLinus Torvalds #include <linux/cpuset.h> 781da177e4SLinus Torvalds #include <linux/audit.h> 795addc5ddSAl Viro #include <linux/poll.h> 801651e14eSSerge E. Hallyn #include <linux/nsproxy.h> 818ac773b4SAlexey Dobriyan #include <linux/oom.h> 823cb4a0bbSKawai, Hidehiro #include <linux/elf.h> 8360347f67SPavel Emelyanov #include <linux/pid_namespace.h> 845ad4e53bSAl Viro #include <linux/fs_struct.h> 855a0e3ad6STejun Heo #include <linux/slab.h> 861da177e4SLinus Torvalds #include "internal.h" 871da177e4SLinus Torvalds 880f2fe20fSEric W. Biederman /* NOTE: 890f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 900f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 910f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 920f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 930f2fe20fSEric W. Biederman * 940f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 950f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 960f2fe20fSEric W. Biederman */ 970f2fe20fSEric W. Biederman 981da177e4SLinus Torvalds struct pid_entry { 991da177e4SLinus Torvalds char *name; 100c5141e6dSEric Dumazet int len; 1011da177e4SLinus Torvalds mode_t mode; 102c5ef1c42SArjan van de Ven const struct inode_operations *iop; 10300977a59SArjan van de Ven const struct file_operations *fop; 10420cdc894SEric W. Biederman union proc_op op; 1051da177e4SLinus Torvalds }; 1061da177e4SLinus Torvalds 10761a28784SEric W. Biederman #define NOD(NAME, MODE, IOP, FOP, OP) { \ 10820cdc894SEric W. Biederman .name = (NAME), \ 109c5141e6dSEric Dumazet .len = sizeof(NAME) - 1, \ 11020cdc894SEric W. Biederman .mode = MODE, \ 11120cdc894SEric W. Biederman .iop = IOP, \ 11220cdc894SEric W. Biederman .fop = FOP, \ 11320cdc894SEric W. Biederman .op = OP, \ 11420cdc894SEric W. Biederman } 11520cdc894SEric W. Biederman 116631f9c18SAlexey Dobriyan #define DIR(NAME, MODE, iops, fops) \ 117631f9c18SAlexey Dobriyan NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} ) 118631f9c18SAlexey Dobriyan #define LNK(NAME, get_link) \ 11961a28784SEric W. Biederman NOD(NAME, (S_IFLNK|S_IRWXUGO), \ 12020cdc894SEric W. Biederman &proc_pid_link_inode_operations, NULL, \ 121631f9c18SAlexey Dobriyan { .proc_get_link = get_link } ) 122631f9c18SAlexey Dobriyan #define REG(NAME, MODE, fops) \ 123631f9c18SAlexey Dobriyan NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {}) 124631f9c18SAlexey Dobriyan #define INF(NAME, MODE, read) \ 12561a28784SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 12620cdc894SEric W. Biederman NULL, &proc_info_file_operations, \ 127631f9c18SAlexey Dobriyan { .proc_read = read } ) 128631f9c18SAlexey Dobriyan #define ONE(NAME, MODE, show) \ 129be614086SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 130be614086SEric W. Biederman NULL, &proc_single_file_operations, \ 131631f9c18SAlexey Dobriyan { .proc_show = show } ) 1321da177e4SLinus Torvalds 133aed54175SVegard Nossum /* 134aed54175SVegard Nossum * Count the number of hardlinks for the pid_entry table, excluding the . 135aed54175SVegard Nossum * and .. links. 136aed54175SVegard Nossum */ 137aed54175SVegard Nossum static unsigned int pid_entry_count_dirs(const struct pid_entry *entries, 138aed54175SVegard Nossum unsigned int n) 139aed54175SVegard Nossum { 140aed54175SVegard Nossum unsigned int i; 141aed54175SVegard Nossum unsigned int count; 142aed54175SVegard Nossum 143aed54175SVegard Nossum count = 0; 144aed54175SVegard Nossum for (i = 0; i < n; ++i) { 145aed54175SVegard Nossum if (S_ISDIR(entries[i].mode)) 146aed54175SVegard Nossum ++count; 147aed54175SVegard Nossum } 148aed54175SVegard Nossum 149aed54175SVegard Nossum return count; 150aed54175SVegard Nossum } 151aed54175SVegard Nossum 152f7ad3c6bSMiklos Szeredi static int get_task_root(struct task_struct *task, struct path *root) 1531da177e4SLinus Torvalds { 1547c2c7d99SHugh Dickins int result = -ENOENT; 1557c2c7d99SHugh Dickins 1560494f6ecSMiklos Szeredi task_lock(task); 157f7ad3c6bSMiklos Szeredi if (task->fs) { 158f7ad3c6bSMiklos Szeredi get_fs_root(task->fs, root); 1597c2c7d99SHugh Dickins result = 0; 1607c2c7d99SHugh Dickins } 1610494f6ecSMiklos Szeredi task_unlock(task); 1627c2c7d99SHugh Dickins return result; 1630494f6ecSMiklos Szeredi } 1640494f6ecSMiklos Szeredi 1653dcd25f3SJan Blunck static int proc_cwd_link(struct inode *inode, struct path *path) 1660494f6ecSMiklos Szeredi { 16799f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1680494f6ecSMiklos Szeredi int result = -ENOENT; 16999f89551SEric W. Biederman 17099f89551SEric W. Biederman if (task) { 171f7ad3c6bSMiklos Szeredi task_lock(task); 172f7ad3c6bSMiklos Szeredi if (task->fs) { 173f7ad3c6bSMiklos Szeredi get_fs_pwd(task->fs, path); 174f7ad3c6bSMiklos Szeredi result = 0; 175f7ad3c6bSMiklos Szeredi } 176f7ad3c6bSMiklos Szeredi task_unlock(task); 17799f89551SEric W. Biederman put_task_struct(task); 17899f89551SEric W. Biederman } 1791da177e4SLinus Torvalds return result; 1801da177e4SLinus Torvalds } 1811da177e4SLinus Torvalds 1823dcd25f3SJan Blunck static int proc_root_link(struct inode *inode, struct path *path) 1831da177e4SLinus Torvalds { 18499f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1851da177e4SLinus Torvalds int result = -ENOENT; 18699f89551SEric W. Biederman 18799f89551SEric W. Biederman if (task) { 188f7ad3c6bSMiklos Szeredi result = get_task_root(task, path); 18999f89551SEric W. Biederman put_task_struct(task); 19099f89551SEric W. Biederman } 1911da177e4SLinus Torvalds return result; 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 1948b0db9dbSStephen Wilson static struct mm_struct *__check_mem_permission(struct task_struct *task) 195638fa202SRoland McGrath { 1968b0db9dbSStephen Wilson struct mm_struct *mm; 1978b0db9dbSStephen Wilson 1988b0db9dbSStephen Wilson mm = get_task_mm(task); 1998b0db9dbSStephen Wilson if (!mm) 2008b0db9dbSStephen Wilson return ERR_PTR(-EINVAL); 2018b0db9dbSStephen Wilson 202638fa202SRoland McGrath /* 203638fa202SRoland McGrath * A task can always look at itself, in case it chooses 204638fa202SRoland McGrath * to use system calls instead of load instructions. 205638fa202SRoland McGrath */ 206638fa202SRoland McGrath if (task == current) 2078b0db9dbSStephen Wilson return mm; 208638fa202SRoland McGrath 209638fa202SRoland McGrath /* 210638fa202SRoland McGrath * If current is actively ptrace'ing, and would also be 211638fa202SRoland McGrath * permitted to freshly attach with ptrace now, permit it. 212638fa202SRoland McGrath */ 2130d094efeSRoland McGrath if (task_is_stopped_or_traced(task)) { 2140d094efeSRoland McGrath int match; 2150d094efeSRoland McGrath rcu_read_lock(); 2160d094efeSRoland McGrath match = (tracehook_tracer_task(task) == current); 2170d094efeSRoland McGrath rcu_read_unlock(); 2180d094efeSRoland McGrath if (match && ptrace_may_access(task, PTRACE_MODE_ATTACH)) 2198b0db9dbSStephen Wilson return mm; 2200d094efeSRoland McGrath } 221638fa202SRoland McGrath 222638fa202SRoland McGrath /* 223638fa202SRoland McGrath * No one else is allowed. 224638fa202SRoland McGrath */ 2258b0db9dbSStephen Wilson mmput(mm); 2268b0db9dbSStephen Wilson return ERR_PTR(-EPERM); 227638fa202SRoland McGrath } 2281da177e4SLinus Torvalds 22918f661bcSStephen Wilson /* 2308b0db9dbSStephen Wilson * If current may access user memory in @task return a reference to the 2318b0db9dbSStephen Wilson * corresponding mm, otherwise ERR_PTR. 23218f661bcSStephen Wilson */ 2338b0db9dbSStephen Wilson static struct mm_struct *check_mem_permission(struct task_struct *task) 23418f661bcSStephen Wilson { 2358b0db9dbSStephen Wilson struct mm_struct *mm; 23618f661bcSStephen Wilson int err; 23718f661bcSStephen Wilson 23818f661bcSStephen Wilson /* 23918f661bcSStephen Wilson * Avoid racing if task exec's as we might get a new mm but validate 24018f661bcSStephen Wilson * against old credentials. 24118f661bcSStephen Wilson */ 24218f661bcSStephen Wilson err = mutex_lock_killable(&task->signal->cred_guard_mutex); 24318f661bcSStephen Wilson if (err) 2448b0db9dbSStephen Wilson return ERR_PTR(err); 24518f661bcSStephen Wilson 2468b0db9dbSStephen Wilson mm = __check_mem_permission(task); 24718f661bcSStephen Wilson mutex_unlock(&task->signal->cred_guard_mutex); 24818f661bcSStephen Wilson 2498b0db9dbSStephen Wilson return mm; 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds 252831830b5SAl Viro struct mm_struct *mm_for_maps(struct task_struct *task) 253831830b5SAl Viro { 254704b836cSOleg Nesterov struct mm_struct *mm; 255ec6fd8a4SAl Viro int err; 25600f89d21SOleg Nesterov 257ec6fd8a4SAl Viro err = mutex_lock_killable(&task->signal->cred_guard_mutex); 258ec6fd8a4SAl Viro if (err) 259ec6fd8a4SAl Viro return ERR_PTR(err); 260704b836cSOleg Nesterov 261704b836cSOleg Nesterov mm = get_task_mm(task); 262704b836cSOleg Nesterov if (mm && mm != current->mm && 263704b836cSOleg Nesterov !ptrace_may_access(task, PTRACE_MODE_READ)) { 264831830b5SAl Viro mmput(mm); 265ec6fd8a4SAl Viro mm = ERR_PTR(-EACCES); 266831830b5SAl Viro } 2679b1bf12dSKOSAKI Motohiro mutex_unlock(&task->signal->cred_guard_mutex); 268704b836cSOleg Nesterov 26913f0feafSOleg Nesterov return mm; 27013f0feafSOleg Nesterov } 271831830b5SAl Viro 2721da177e4SLinus Torvalds static int proc_pid_cmdline(struct task_struct *task, char * buffer) 2731da177e4SLinus Torvalds { 2741da177e4SLinus Torvalds int res = 0; 2751da177e4SLinus Torvalds unsigned int len; 2761da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 2771da177e4SLinus Torvalds if (!mm) 2781da177e4SLinus Torvalds goto out; 2791da177e4SLinus Torvalds if (!mm->arg_end) 2801da177e4SLinus Torvalds goto out_mm; /* Shh! No looking before we're done */ 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds len = mm->arg_end - mm->arg_start; 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds if (len > PAGE_SIZE) 2851da177e4SLinus Torvalds len = PAGE_SIZE; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds res = access_process_vm(task, mm->arg_start, buffer, len, 0); 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds // If the nul at the end of args has been overwritten, then 2901da177e4SLinus Torvalds // assume application is using setproctitle(3). 2911da177e4SLinus Torvalds if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) { 2921da177e4SLinus Torvalds len = strnlen(buffer, res); 2931da177e4SLinus Torvalds if (len < res) { 2941da177e4SLinus Torvalds res = len; 2951da177e4SLinus Torvalds } else { 2961da177e4SLinus Torvalds len = mm->env_end - mm->env_start; 2971da177e4SLinus Torvalds if (len > PAGE_SIZE - res) 2981da177e4SLinus Torvalds len = PAGE_SIZE - res; 2991da177e4SLinus Torvalds res += access_process_vm(task, mm->env_start, buffer+res, len, 0); 3001da177e4SLinus Torvalds res = strnlen(buffer, res); 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds } 3031da177e4SLinus Torvalds out_mm: 3041da177e4SLinus Torvalds mmput(mm); 3051da177e4SLinus Torvalds out: 3061da177e4SLinus Torvalds return res; 3071da177e4SLinus Torvalds } 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds static int proc_pid_auxv(struct task_struct *task, char *buffer) 3101da177e4SLinus Torvalds { 3112fadaef4SAl Viro struct mm_struct *mm = mm_for_maps(task); 3122fadaef4SAl Viro int res = PTR_ERR(mm); 3132fadaef4SAl Viro if (mm && !IS_ERR(mm)) { 3141da177e4SLinus Torvalds unsigned int nwords = 0; 315dfe6b7d9SHannes Eder do { 3161da177e4SLinus Torvalds nwords += 2; 317dfe6b7d9SHannes Eder } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 3181da177e4SLinus Torvalds res = nwords * sizeof(mm->saved_auxv[0]); 3191da177e4SLinus Torvalds if (res > PAGE_SIZE) 3201da177e4SLinus Torvalds res = PAGE_SIZE; 3211da177e4SLinus Torvalds memcpy(buffer, mm->saved_auxv, res); 3221da177e4SLinus Torvalds mmput(mm); 3231da177e4SLinus Torvalds } 3241da177e4SLinus Torvalds return res; 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 3291da177e4SLinus Torvalds /* 3301da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 3311da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 3321da177e4SLinus Torvalds */ 3331da177e4SLinus Torvalds static int proc_pid_wchan(struct task_struct *task, char *buffer) 3341da177e4SLinus Torvalds { 335ffb45122SAlexey Dobriyan unsigned long wchan; 3369281aceaSTejun Heo char symname[KSYM_NAME_LEN]; 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds wchan = get_wchan(task); 3391da177e4SLinus Torvalds 3409d65cb4aSAlexey Dobriyan if (lookup_symbol_name(wchan, symname) < 0) 341f83ce3e6SJake Edge if (!ptrace_may_access(task, PTRACE_MODE_READ)) 342f83ce3e6SJake Edge return 0; 343f83ce3e6SJake Edge else 3441da177e4SLinus Torvalds return sprintf(buffer, "%lu", wchan); 3459d65cb4aSAlexey Dobriyan else 3469d65cb4aSAlexey Dobriyan return sprintf(buffer, "%s", symname); 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 3491da177e4SLinus Torvalds 350a9712bc1SAl Viro static int lock_trace(struct task_struct *task) 351a9712bc1SAl Viro { 352a9712bc1SAl Viro int err = mutex_lock_killable(&task->signal->cred_guard_mutex); 353a9712bc1SAl Viro if (err) 354a9712bc1SAl Viro return err; 355a9712bc1SAl Viro if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) { 356a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 357a9712bc1SAl Viro return -EPERM; 358a9712bc1SAl Viro } 359a9712bc1SAl Viro return 0; 360a9712bc1SAl Viro } 361a9712bc1SAl Viro 362a9712bc1SAl Viro static void unlock_trace(struct task_struct *task) 363a9712bc1SAl Viro { 364a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 365a9712bc1SAl Viro } 366a9712bc1SAl Viro 3672ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 3682ec220e2SKen Chen 3692ec220e2SKen Chen #define MAX_STACK_TRACE_DEPTH 64 3702ec220e2SKen Chen 3712ec220e2SKen Chen static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns, 3722ec220e2SKen Chen struct pid *pid, struct task_struct *task) 3732ec220e2SKen Chen { 3742ec220e2SKen Chen struct stack_trace trace; 3752ec220e2SKen Chen unsigned long *entries; 376a9712bc1SAl Viro int err; 3772ec220e2SKen Chen int i; 3782ec220e2SKen Chen 3792ec220e2SKen Chen entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL); 3802ec220e2SKen Chen if (!entries) 3812ec220e2SKen Chen return -ENOMEM; 3822ec220e2SKen Chen 3832ec220e2SKen Chen trace.nr_entries = 0; 3842ec220e2SKen Chen trace.max_entries = MAX_STACK_TRACE_DEPTH; 3852ec220e2SKen Chen trace.entries = entries; 3862ec220e2SKen Chen trace.skip = 0; 387a9712bc1SAl Viro 388a9712bc1SAl Viro err = lock_trace(task); 389a9712bc1SAl Viro if (!err) { 3902ec220e2SKen Chen save_stack_trace_tsk(task, &trace); 3912ec220e2SKen Chen 3922ec220e2SKen Chen for (i = 0; i < trace.nr_entries; i++) { 39351e03149SKonstantin Khlebnikov seq_printf(m, "[<%pK>] %pS\n", 3942ec220e2SKen Chen (void *)entries[i], (void *)entries[i]); 3952ec220e2SKen Chen } 396a9712bc1SAl Viro unlock_trace(task); 397a9712bc1SAl Viro } 3982ec220e2SKen Chen kfree(entries); 3992ec220e2SKen Chen 400a9712bc1SAl Viro return err; 4012ec220e2SKen Chen } 4022ec220e2SKen Chen #endif 4032ec220e2SKen Chen 4041da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 4051da177e4SLinus Torvalds /* 4061da177e4SLinus Torvalds * Provides /proc/PID/schedstat 4071da177e4SLinus Torvalds */ 4081da177e4SLinus Torvalds static int proc_pid_schedstat(struct task_struct *task, char *buffer) 4091da177e4SLinus Torvalds { 410172ba844SBalbir Singh return sprintf(buffer, "%llu %llu %lu\n", 411826e08b0SIngo Molnar (unsigned long long)task->se.sum_exec_runtime, 412826e08b0SIngo Molnar (unsigned long long)task->sched_info.run_delay, 4132d72376bSIngo Molnar task->sched_info.pcount); 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds #endif 4161da177e4SLinus Torvalds 4179745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 4189745512cSArjan van de Ven static int lstats_show_proc(struct seq_file *m, void *v) 4199745512cSArjan van de Ven { 4209745512cSArjan van de Ven int i; 42113d77c37SHiroshi Shimamoto struct inode *inode = m->private; 42213d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(inode); 4239745512cSArjan van de Ven 42413d77c37SHiroshi Shimamoto if (!task) 42513d77c37SHiroshi Shimamoto return -ESRCH; 42613d77c37SHiroshi Shimamoto seq_puts(m, "Latency Top version : v0.1\n"); 4279745512cSArjan van de Ven for (i = 0; i < 32; i++) { 42834e49d4fSJoe Perches struct latency_record *lr = &task->latency_record[i]; 42934e49d4fSJoe Perches if (lr->backtrace[0]) { 4309745512cSArjan van de Ven int q; 4319745512cSArjan van de Ven seq_printf(m, "%i %li %li", 43234e49d4fSJoe Perches lr->count, lr->time, lr->max); 4339745512cSArjan van de Ven for (q = 0; q < LT_BACKTRACEDEPTH; q++) { 43434e49d4fSJoe Perches unsigned long bt = lr->backtrace[q]; 43534e49d4fSJoe Perches if (!bt) 4369745512cSArjan van de Ven break; 43734e49d4fSJoe Perches if (bt == ULONG_MAX) 4389745512cSArjan van de Ven break; 43934e49d4fSJoe Perches seq_printf(m, " %ps", (void *)bt); 4409745512cSArjan van de Ven } 4419d6de12fSAlexey Dobriyan seq_putc(m, '\n'); 4429745512cSArjan van de Ven } 4439745512cSArjan van de Ven 4449745512cSArjan van de Ven } 44513d77c37SHiroshi Shimamoto put_task_struct(task); 4469745512cSArjan van de Ven return 0; 4479745512cSArjan van de Ven } 4489745512cSArjan van de Ven 4499745512cSArjan van de Ven static int lstats_open(struct inode *inode, struct file *file) 4509745512cSArjan van de Ven { 45113d77c37SHiroshi Shimamoto return single_open(file, lstats_show_proc, inode); 452d6643d12SHiroshi Shimamoto } 453d6643d12SHiroshi Shimamoto 4549745512cSArjan van de Ven static ssize_t lstats_write(struct file *file, const char __user *buf, 4559745512cSArjan van de Ven size_t count, loff_t *offs) 4569745512cSArjan van de Ven { 45713d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 4589745512cSArjan van de Ven 45913d77c37SHiroshi Shimamoto if (!task) 46013d77c37SHiroshi Shimamoto return -ESRCH; 4619745512cSArjan van de Ven clear_all_latency_tracing(task); 46213d77c37SHiroshi Shimamoto put_task_struct(task); 4639745512cSArjan van de Ven 4649745512cSArjan van de Ven return count; 4659745512cSArjan van de Ven } 4669745512cSArjan van de Ven 4679745512cSArjan van de Ven static const struct file_operations proc_lstats_operations = { 4689745512cSArjan van de Ven .open = lstats_open, 4699745512cSArjan van de Ven .read = seq_read, 4709745512cSArjan van de Ven .write = lstats_write, 4719745512cSArjan van de Ven .llseek = seq_lseek, 47213d77c37SHiroshi Shimamoto .release = single_release, 4739745512cSArjan van de Ven }; 4749745512cSArjan van de Ven 4759745512cSArjan van de Ven #endif 4769745512cSArjan van de Ven 4771da177e4SLinus Torvalds static int proc_oom_score(struct task_struct *task, char *buffer) 4781da177e4SLinus Torvalds { 479b95c35e7SOleg Nesterov unsigned long points = 0; 4801da177e4SLinus Torvalds 48119c5d45aSAlexey Dobriyan read_lock(&tasklist_lock); 482b95c35e7SOleg Nesterov if (pid_alive(task)) 483a63d83f4SDavid Rientjes points = oom_badness(task, NULL, NULL, 484a63d83f4SDavid Rientjes totalram_pages + total_swap_pages); 48519c5d45aSAlexey Dobriyan read_unlock(&tasklist_lock); 4861da177e4SLinus Torvalds return sprintf(buffer, "%lu\n", points); 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 489d85f50d5SNeil Horman struct limit_names { 490d85f50d5SNeil Horman char *name; 491d85f50d5SNeil Horman char *unit; 492d85f50d5SNeil Horman }; 493d85f50d5SNeil Horman 494d85f50d5SNeil Horman static const struct limit_names lnames[RLIM_NLIMITS] = { 495cff4edb5SKees Cook [RLIMIT_CPU] = {"Max cpu time", "seconds"}, 496d85f50d5SNeil Horman [RLIMIT_FSIZE] = {"Max file size", "bytes"}, 497d85f50d5SNeil Horman [RLIMIT_DATA] = {"Max data size", "bytes"}, 498d85f50d5SNeil Horman [RLIMIT_STACK] = {"Max stack size", "bytes"}, 499d85f50d5SNeil Horman [RLIMIT_CORE] = {"Max core file size", "bytes"}, 500d85f50d5SNeil Horman [RLIMIT_RSS] = {"Max resident set", "bytes"}, 501d85f50d5SNeil Horman [RLIMIT_NPROC] = {"Max processes", "processes"}, 502d85f50d5SNeil Horman [RLIMIT_NOFILE] = {"Max open files", "files"}, 503d85f50d5SNeil Horman [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"}, 504d85f50d5SNeil Horman [RLIMIT_AS] = {"Max address space", "bytes"}, 505d85f50d5SNeil Horman [RLIMIT_LOCKS] = {"Max file locks", "locks"}, 506d85f50d5SNeil Horman [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"}, 507d85f50d5SNeil Horman [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"}, 508d85f50d5SNeil Horman [RLIMIT_NICE] = {"Max nice priority", NULL}, 509d85f50d5SNeil Horman [RLIMIT_RTPRIO] = {"Max realtime priority", NULL}, 5108808117cSEugene Teo [RLIMIT_RTTIME] = {"Max realtime timeout", "us"}, 511d85f50d5SNeil Horman }; 512d85f50d5SNeil Horman 513d85f50d5SNeil Horman /* Display limits for a process */ 514d85f50d5SNeil Horman static int proc_pid_limits(struct task_struct *task, char *buffer) 515d85f50d5SNeil Horman { 516d85f50d5SNeil Horman unsigned int i; 517d85f50d5SNeil Horman int count = 0; 518d85f50d5SNeil Horman unsigned long flags; 519d85f50d5SNeil Horman char *bufptr = buffer; 520d85f50d5SNeil Horman 521d85f50d5SNeil Horman struct rlimit rlim[RLIM_NLIMITS]; 522d85f50d5SNeil Horman 523a6bebbc8SLai Jiangshan if (!lock_task_sighand(task, &flags)) 524d85f50d5SNeil Horman return 0; 525d85f50d5SNeil Horman memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS); 526d85f50d5SNeil Horman unlock_task_sighand(task, &flags); 527d85f50d5SNeil Horman 528d85f50d5SNeil Horman /* 529d85f50d5SNeil Horman * print the file header 530d85f50d5SNeil Horman */ 531d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n", 532d85f50d5SNeil Horman "Limit", "Soft Limit", "Hard Limit", "Units"); 533d85f50d5SNeil Horman 534d85f50d5SNeil Horman for (i = 0; i < RLIM_NLIMITS; i++) { 535d85f50d5SNeil Horman if (rlim[i].rlim_cur == RLIM_INFINITY) 536d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-25s %-20s ", 537d85f50d5SNeil Horman lnames[i].name, "unlimited"); 538d85f50d5SNeil Horman else 539d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-25s %-20lu ", 540d85f50d5SNeil Horman lnames[i].name, rlim[i].rlim_cur); 541d85f50d5SNeil Horman 542d85f50d5SNeil Horman if (rlim[i].rlim_max == RLIM_INFINITY) 543d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-20s ", "unlimited"); 544d85f50d5SNeil Horman else 545d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-20lu ", 546d85f50d5SNeil Horman rlim[i].rlim_max); 547d85f50d5SNeil Horman 548d85f50d5SNeil Horman if (lnames[i].unit) 549d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-10s\n", 550d85f50d5SNeil Horman lnames[i].unit); 551d85f50d5SNeil Horman else 552d85f50d5SNeil Horman count += sprintf(&bufptr[count], "\n"); 553d85f50d5SNeil Horman } 554d85f50d5SNeil Horman 555d85f50d5SNeil Horman return count; 556d85f50d5SNeil Horman } 557d85f50d5SNeil Horman 558ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 559ebcb6734SRoland McGrath static int proc_pid_syscall(struct task_struct *task, char *buffer) 560ebcb6734SRoland McGrath { 561ebcb6734SRoland McGrath long nr; 562ebcb6734SRoland McGrath unsigned long args[6], sp, pc; 563a9712bc1SAl Viro int res = lock_trace(task); 564a9712bc1SAl Viro if (res) 565a9712bc1SAl Viro return res; 566ebcb6734SRoland McGrath 567ebcb6734SRoland McGrath if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) 568a9712bc1SAl Viro res = sprintf(buffer, "running\n"); 569a9712bc1SAl Viro else if (nr < 0) 570a9712bc1SAl Viro res = sprintf(buffer, "%ld 0x%lx 0x%lx\n", nr, sp, pc); 571a9712bc1SAl Viro else 572a9712bc1SAl Viro res = sprintf(buffer, 573ebcb6734SRoland McGrath "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 574ebcb6734SRoland McGrath nr, 575ebcb6734SRoland McGrath args[0], args[1], args[2], args[3], args[4], args[5], 576ebcb6734SRoland McGrath sp, pc); 577a9712bc1SAl Viro unlock_trace(task); 578a9712bc1SAl Viro return res; 579ebcb6734SRoland McGrath } 580ebcb6734SRoland McGrath #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */ 581ebcb6734SRoland McGrath 5821da177e4SLinus Torvalds /************************************************************************/ 5831da177e4SLinus Torvalds /* Here the fs part begins */ 5841da177e4SLinus Torvalds /************************************************************************/ 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds /* permission checks */ 587778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 5881da177e4SLinus Torvalds { 589778c1144SEric W. Biederman struct task_struct *task; 590778c1144SEric W. Biederman int allowed = 0; 591df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 592df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 593df26c40eSEric W. Biederman * information. 594778c1144SEric W. Biederman */ 595778c1144SEric W. Biederman task = get_proc_task(inode); 596df26c40eSEric W. Biederman if (task) { 597006ebb40SStephen Smalley allowed = ptrace_may_access(task, PTRACE_MODE_READ); 598778c1144SEric W. Biederman put_task_struct(task); 599df26c40eSEric W. Biederman } 600778c1144SEric W. Biederman return allowed; 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6036b4e306aSEric W. Biederman int proc_setattr(struct dentry *dentry, struct iattr *attr) 6046d76fa58SLinus Torvalds { 6056d76fa58SLinus Torvalds int error; 6066d76fa58SLinus Torvalds struct inode *inode = dentry->d_inode; 6076d76fa58SLinus Torvalds 6086d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 6096d76fa58SLinus Torvalds return -EPERM; 6106d76fa58SLinus Torvalds 6116d76fa58SLinus Torvalds error = inode_change_ok(inode, attr); 6121025774cSChristoph Hellwig if (error) 6136d76fa58SLinus Torvalds return error; 6141025774cSChristoph Hellwig 6151025774cSChristoph Hellwig if ((attr->ia_valid & ATTR_SIZE) && 6161025774cSChristoph Hellwig attr->ia_size != i_size_read(inode)) { 6171025774cSChristoph Hellwig error = vmtruncate(inode, attr->ia_size); 6181025774cSChristoph Hellwig if (error) 6191025774cSChristoph Hellwig return error; 6201025774cSChristoph Hellwig } 6211025774cSChristoph Hellwig 6221025774cSChristoph Hellwig setattr_copy(inode, attr); 6231025774cSChristoph Hellwig mark_inode_dirty(inode); 6241025774cSChristoph Hellwig return 0; 6256d76fa58SLinus Torvalds } 6266d76fa58SLinus Torvalds 627c5ef1c42SArjan van de Ven static const struct inode_operations proc_def_inode_operations = { 6286d76fa58SLinus Torvalds .setattr = proc_setattr, 6296d76fa58SLinus Torvalds }; 6306d76fa58SLinus Torvalds 631a1a2c409SMiklos Szeredi static int mounts_open_common(struct inode *inode, struct file *file, 632a1a2c409SMiklos Szeredi const struct seq_operations *op) 6331da177e4SLinus Torvalds { 63499f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 635cf7b708cSPavel Emelyanov struct nsproxy *nsp; 6366b3286edSKirill Korotaev struct mnt_namespace *ns = NULL; 637a1a2c409SMiklos Szeredi struct path root; 6385addc5ddSAl Viro struct proc_mounts *p; 6395addc5ddSAl Viro int ret = -EINVAL; 6405addc5ddSAl Viro 64199f89551SEric W. Biederman if (task) { 642cf7b708cSPavel Emelyanov rcu_read_lock(); 643cf7b708cSPavel Emelyanov nsp = task_nsproxy(task); 644cf7b708cSPavel Emelyanov if (nsp) { 645cf7b708cSPavel Emelyanov ns = nsp->mnt_ns; 6466b3286edSKirill Korotaev if (ns) 6476b3286edSKirill Korotaev get_mnt_ns(ns); 648863c4702SAlexey Dobriyan } 649cf7b708cSPavel Emelyanov rcu_read_unlock(); 650f7ad3c6bSMiklos Szeredi if (ns && get_task_root(task, &root) == 0) 6517c2c7d99SHugh Dickins ret = 0; 65299f89551SEric W. Biederman put_task_struct(task); 65399f89551SEric W. Biederman } 6541da177e4SLinus Torvalds 655a1a2c409SMiklos Szeredi if (!ns) 656a1a2c409SMiklos Szeredi goto err; 6577c2c7d99SHugh Dickins if (ret) 658a1a2c409SMiklos Szeredi goto err_put_ns; 659a1a2c409SMiklos Szeredi 6605addc5ddSAl Viro ret = -ENOMEM; 6615addc5ddSAl Viro p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); 662a1a2c409SMiklos Szeredi if (!p) 663a1a2c409SMiklos Szeredi goto err_put_path; 664a1a2c409SMiklos Szeredi 6655addc5ddSAl Viro file->private_data = &p->m; 666a1a2c409SMiklos Szeredi ret = seq_open(file, op); 667a1a2c409SMiklos Szeredi if (ret) 668a1a2c409SMiklos Szeredi goto err_free; 669a1a2c409SMiklos Szeredi 670a1a2c409SMiklos Szeredi p->m.private = p; 671a1a2c409SMiklos Szeredi p->ns = ns; 672a1a2c409SMiklos Szeredi p->root = root; 6736b3286edSKirill Korotaev p->event = ns->event; 674a1a2c409SMiklos Szeredi 6755addc5ddSAl Viro return 0; 676a1a2c409SMiklos Szeredi 677a1a2c409SMiklos Szeredi err_free: 6785addc5ddSAl Viro kfree(p); 679a1a2c409SMiklos Szeredi err_put_path: 680a1a2c409SMiklos Szeredi path_put(&root); 681a1a2c409SMiklos Szeredi err_put_ns: 6826b3286edSKirill Korotaev put_mnt_ns(ns); 683a1a2c409SMiklos Szeredi err: 6841da177e4SLinus Torvalds return ret; 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds static int mounts_release(struct inode *inode, struct file *file) 6881da177e4SLinus Torvalds { 689a1a2c409SMiklos Szeredi struct proc_mounts *p = file->private_data; 690a1a2c409SMiklos Szeredi path_put(&p->root); 691a1a2c409SMiklos Szeredi put_mnt_ns(p->ns); 6921da177e4SLinus Torvalds return seq_release(inode, file); 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds 6955addc5ddSAl Viro static unsigned mounts_poll(struct file *file, poll_table *wait) 6965addc5ddSAl Viro { 6975addc5ddSAl Viro struct proc_mounts *p = file->private_data; 69831b07093SKOSAKI Motohiro unsigned res = POLLIN | POLLRDNORM; 6995addc5ddSAl Viro 7009f5596afSAl Viro poll_wait(file, &p->ns->poll, wait); 7019f5596afSAl Viro if (mnt_had_events(p)) 70231b07093SKOSAKI Motohiro res |= POLLERR | POLLPRI; 7035addc5ddSAl Viro 7045addc5ddSAl Viro return res; 7055addc5ddSAl Viro } 7065addc5ddSAl Viro 707a1a2c409SMiklos Szeredi static int mounts_open(struct inode *inode, struct file *file) 708a1a2c409SMiklos Szeredi { 709a1a2c409SMiklos Szeredi return mounts_open_common(inode, file, &mounts_op); 710a1a2c409SMiklos Szeredi } 711a1a2c409SMiklos Szeredi 71200977a59SArjan van de Ven static const struct file_operations proc_mounts_operations = { 7131da177e4SLinus Torvalds .open = mounts_open, 7141da177e4SLinus Torvalds .read = seq_read, 7151da177e4SLinus Torvalds .llseek = seq_lseek, 7161da177e4SLinus Torvalds .release = mounts_release, 7175addc5ddSAl Viro .poll = mounts_poll, 7181da177e4SLinus Torvalds }; 7191da177e4SLinus Torvalds 7202d4d4864SRam Pai static int mountinfo_open(struct inode *inode, struct file *file) 7212d4d4864SRam Pai { 7222d4d4864SRam Pai return mounts_open_common(inode, file, &mountinfo_op); 7232d4d4864SRam Pai } 7242d4d4864SRam Pai 7252d4d4864SRam Pai static const struct file_operations proc_mountinfo_operations = { 7262d4d4864SRam Pai .open = mountinfo_open, 7272d4d4864SRam Pai .read = seq_read, 7282d4d4864SRam Pai .llseek = seq_lseek, 7292d4d4864SRam Pai .release = mounts_release, 7302d4d4864SRam Pai .poll = mounts_poll, 7312d4d4864SRam Pai }; 7322d4d4864SRam Pai 733b4629fe2SChuck Lever static int mountstats_open(struct inode *inode, struct file *file) 734b4629fe2SChuck Lever { 735a1a2c409SMiklos Szeredi return mounts_open_common(inode, file, &mountstats_op); 736b4629fe2SChuck Lever } 737b4629fe2SChuck Lever 73800977a59SArjan van de Ven static const struct file_operations proc_mountstats_operations = { 739b4629fe2SChuck Lever .open = mountstats_open, 740b4629fe2SChuck Lever .read = seq_read, 741b4629fe2SChuck Lever .llseek = seq_lseek, 742b4629fe2SChuck Lever .release = mounts_release, 743b4629fe2SChuck Lever }; 744b4629fe2SChuck Lever 7451da177e4SLinus Torvalds #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */ 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds static ssize_t proc_info_read(struct file * file, char __user * buf, 7481da177e4SLinus Torvalds size_t count, loff_t *ppos) 7491da177e4SLinus Torvalds { 7502fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 7511da177e4SLinus Torvalds unsigned long page; 7521da177e4SLinus Torvalds ssize_t length; 75399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 75499f89551SEric W. Biederman 75599f89551SEric W. Biederman length = -ESRCH; 75699f89551SEric W. Biederman if (!task) 75799f89551SEric W. Biederman goto out_no_task; 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds if (count > PROC_BLOCK_SIZE) 7601da177e4SLinus Torvalds count = PROC_BLOCK_SIZE; 76199f89551SEric W. Biederman 76299f89551SEric W. Biederman length = -ENOMEM; 763e12ba74dSMel Gorman if (!(page = __get_free_page(GFP_TEMPORARY))) 76499f89551SEric W. Biederman goto out; 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds length = PROC_I(inode)->op.proc_read(task, (char*)page); 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds if (length >= 0) 7691da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 7701da177e4SLinus Torvalds free_page(page); 77199f89551SEric W. Biederman out: 77299f89551SEric W. Biederman put_task_struct(task); 77399f89551SEric W. Biederman out_no_task: 7741da177e4SLinus Torvalds return length; 7751da177e4SLinus Torvalds } 7761da177e4SLinus Torvalds 77700977a59SArjan van de Ven static const struct file_operations proc_info_file_operations = { 7781da177e4SLinus Torvalds .read = proc_info_read, 77987df8424SArnd Bergmann .llseek = generic_file_llseek, 7801da177e4SLinus Torvalds }; 7811da177e4SLinus Torvalds 782be614086SEric W. Biederman static int proc_single_show(struct seq_file *m, void *v) 783be614086SEric W. Biederman { 784be614086SEric W. Biederman struct inode *inode = m->private; 785be614086SEric W. Biederman struct pid_namespace *ns; 786be614086SEric W. Biederman struct pid *pid; 787be614086SEric W. Biederman struct task_struct *task; 788be614086SEric W. Biederman int ret; 789be614086SEric W. Biederman 790be614086SEric W. Biederman ns = inode->i_sb->s_fs_info; 791be614086SEric W. Biederman pid = proc_pid(inode); 792be614086SEric W. Biederman task = get_pid_task(pid, PIDTYPE_PID); 793be614086SEric W. Biederman if (!task) 794be614086SEric W. Biederman return -ESRCH; 795be614086SEric W. Biederman 796be614086SEric W. Biederman ret = PROC_I(inode)->op.proc_show(m, ns, pid, task); 797be614086SEric W. Biederman 798be614086SEric W. Biederman put_task_struct(task); 799be614086SEric W. Biederman return ret; 800be614086SEric W. Biederman } 801be614086SEric W. Biederman 802be614086SEric W. Biederman static int proc_single_open(struct inode *inode, struct file *filp) 803be614086SEric W. Biederman { 804c6a34058SJovi Zhang return single_open(filp, proc_single_show, inode); 805be614086SEric W. Biederman } 806be614086SEric W. Biederman 807be614086SEric W. Biederman static const struct file_operations proc_single_file_operations = { 808be614086SEric W. Biederman .open = proc_single_open, 809be614086SEric W. Biederman .read = seq_read, 810be614086SEric W. Biederman .llseek = seq_lseek, 811be614086SEric W. Biederman .release = single_release, 812be614086SEric W. Biederman }; 813be614086SEric W. Biederman 8141da177e4SLinus Torvalds static int mem_open(struct inode* inode, struct file* file) 8151da177e4SLinus Torvalds { 8161da177e4SLinus Torvalds file->private_data = (void*)((long)current->self_exec_id); 8174a3956c7SKAMEZAWA Hiroyuki /* OK to pass negative loff_t, we can catch out-of-range */ 8184a3956c7SKAMEZAWA Hiroyuki file->f_mode |= FMODE_UNSIGNED_OFFSET; 8191da177e4SLinus Torvalds return 0; 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds static ssize_t mem_read(struct file * file, char __user * buf, 8231da177e4SLinus Torvalds size_t count, loff_t *ppos) 8241da177e4SLinus Torvalds { 8252fddfeefSJosef "Jeff" Sipek struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 8261da177e4SLinus Torvalds char *page; 8271da177e4SLinus Torvalds unsigned long src = *ppos; 8281da177e4SLinus Torvalds int ret = -ESRCH; 8291da177e4SLinus Torvalds struct mm_struct *mm; 8301da177e4SLinus Torvalds 83199f89551SEric W. Biederman if (!task) 83299f89551SEric W. Biederman goto out_no_task; 83399f89551SEric W. Biederman 8341da177e4SLinus Torvalds ret = -ENOMEM; 835e12ba74dSMel Gorman page = (char *)__get_free_page(GFP_TEMPORARY); 8361da177e4SLinus Torvalds if (!page) 8371da177e4SLinus Torvalds goto out; 8381da177e4SLinus Torvalds 8398b0db9dbSStephen Wilson mm = check_mem_permission(task); 8408b0db9dbSStephen Wilson ret = PTR_ERR(mm); 8418b0db9dbSStephen Wilson if (IS_ERR(mm)) 8421da177e4SLinus Torvalds goto out_free; 8431da177e4SLinus Torvalds 8441da177e4SLinus Torvalds ret = -EIO; 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds if (file->private_data != (void*)((long)current->self_exec_id)) 8471da177e4SLinus Torvalds goto out_put; 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds ret = 0; 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds while (count > 0) { 8521da177e4SLinus Torvalds int this_len, retval; 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 8558b0db9dbSStephen Wilson retval = access_remote_vm(mm, src, page, this_len, 0); 8568b0db9dbSStephen Wilson if (!retval) { 8571da177e4SLinus Torvalds if (!ret) 8581da177e4SLinus Torvalds ret = -EIO; 8591da177e4SLinus Torvalds break; 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds if (copy_to_user(buf, page, retval)) { 8631da177e4SLinus Torvalds ret = -EFAULT; 8641da177e4SLinus Torvalds break; 8651da177e4SLinus Torvalds } 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds ret += retval; 8681da177e4SLinus Torvalds src += retval; 8691da177e4SLinus Torvalds buf += retval; 8701da177e4SLinus Torvalds count -= retval; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds *ppos = src; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds out_put: 8751da177e4SLinus Torvalds mmput(mm); 8761da177e4SLinus Torvalds out_free: 8771da177e4SLinus Torvalds free_page((unsigned long) page); 8781da177e4SLinus Torvalds out: 87999f89551SEric W. Biederman put_task_struct(task); 88099f89551SEric W. Biederman out_no_task: 8811da177e4SLinus Torvalds return ret; 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds 88463967fa9SGlauber de Oliveira Costa static ssize_t mem_write(struct file * file, const char __user *buf, 8851da177e4SLinus Torvalds size_t count, loff_t *ppos) 8861da177e4SLinus Torvalds { 887f7ca54f4SFrederik Deweerdt int copied; 8881da177e4SLinus Torvalds char *page; 8892fddfeefSJosef "Jeff" Sipek struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 8901da177e4SLinus Torvalds unsigned long dst = *ppos; 8918b0db9dbSStephen Wilson struct mm_struct *mm; 8921da177e4SLinus Torvalds 89399f89551SEric W. Biederman copied = -ESRCH; 89499f89551SEric W. Biederman if (!task) 89599f89551SEric W. Biederman goto out_no_task; 8961da177e4SLinus Torvalds 8978b0db9dbSStephen Wilson mm = check_mem_permission(task); 8988b0db9dbSStephen Wilson copied = PTR_ERR(mm); 8998b0db9dbSStephen Wilson if (IS_ERR(mm)) 9008b0db9dbSStephen Wilson goto out_task; 90199f89551SEric W. Biederman 90226947f8cSStephen Wilson copied = -EIO; 90326947f8cSStephen Wilson if (file->private_data != (void *)((long)current->self_exec_id)) 9048b0db9dbSStephen Wilson goto out_mm; 90599f89551SEric W. Biederman 90699f89551SEric W. Biederman copied = -ENOMEM; 907e12ba74dSMel Gorman page = (char *)__get_free_page(GFP_TEMPORARY); 9081da177e4SLinus Torvalds if (!page) 9098b0db9dbSStephen Wilson goto out_mm; 9101da177e4SLinus Torvalds 911f7ca54f4SFrederik Deweerdt copied = 0; 9121da177e4SLinus Torvalds while (count > 0) { 9131da177e4SLinus Torvalds int this_len, retval; 9141da177e4SLinus Torvalds 9151da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 9161da177e4SLinus Torvalds if (copy_from_user(page, buf, this_len)) { 9171da177e4SLinus Torvalds copied = -EFAULT; 9181da177e4SLinus Torvalds break; 9191da177e4SLinus Torvalds } 9208b0db9dbSStephen Wilson retval = access_remote_vm(mm, dst, page, this_len, 1); 9211da177e4SLinus Torvalds if (!retval) { 9221da177e4SLinus Torvalds if (!copied) 9231da177e4SLinus Torvalds copied = -EIO; 9241da177e4SLinus Torvalds break; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds copied += retval; 9271da177e4SLinus Torvalds buf += retval; 9281da177e4SLinus Torvalds dst += retval; 9291da177e4SLinus Torvalds count -= retval; 9301da177e4SLinus Torvalds } 9311da177e4SLinus Torvalds *ppos = dst; 9321da177e4SLinus Torvalds free_page((unsigned long) page); 9338b0db9dbSStephen Wilson out_mm: 9348b0db9dbSStephen Wilson mmput(mm); 9358b0db9dbSStephen Wilson out_task: 93699f89551SEric W. Biederman put_task_struct(task); 93799f89551SEric W. Biederman out_no_task: 9381da177e4SLinus Torvalds return copied; 9391da177e4SLinus Torvalds } 9401da177e4SLinus Torvalds 94185863e47SMatt Mackall loff_t mem_lseek(struct file *file, loff_t offset, int orig) 9421da177e4SLinus Torvalds { 9431da177e4SLinus Torvalds switch (orig) { 9441da177e4SLinus Torvalds case 0: 9451da177e4SLinus Torvalds file->f_pos = offset; 9461da177e4SLinus Torvalds break; 9471da177e4SLinus Torvalds case 1: 9481da177e4SLinus Torvalds file->f_pos += offset; 9491da177e4SLinus Torvalds break; 9501da177e4SLinus Torvalds default: 9511da177e4SLinus Torvalds return -EINVAL; 9521da177e4SLinus Torvalds } 9531da177e4SLinus Torvalds force_successful_syscall_return(); 9541da177e4SLinus Torvalds return file->f_pos; 9551da177e4SLinus Torvalds } 9561da177e4SLinus Torvalds 95700977a59SArjan van de Ven static const struct file_operations proc_mem_operations = { 9581da177e4SLinus Torvalds .llseek = mem_lseek, 9591da177e4SLinus Torvalds .read = mem_read, 9601da177e4SLinus Torvalds .write = mem_write, 9611da177e4SLinus Torvalds .open = mem_open, 9621da177e4SLinus Torvalds }; 9631da177e4SLinus Torvalds 964315e28c8SJames Pearson static ssize_t environ_read(struct file *file, char __user *buf, 965315e28c8SJames Pearson size_t count, loff_t *ppos) 966315e28c8SJames Pearson { 967315e28c8SJames Pearson struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 968315e28c8SJames Pearson char *page; 969315e28c8SJames Pearson unsigned long src = *ppos; 970315e28c8SJames Pearson int ret = -ESRCH; 971315e28c8SJames Pearson struct mm_struct *mm; 972315e28c8SJames Pearson 973315e28c8SJames Pearson if (!task) 974315e28c8SJames Pearson goto out_no_task; 975315e28c8SJames Pearson 976315e28c8SJames Pearson ret = -ENOMEM; 977315e28c8SJames Pearson page = (char *)__get_free_page(GFP_TEMPORARY); 978315e28c8SJames Pearson if (!page) 979315e28c8SJames Pearson goto out; 980315e28c8SJames Pearson 981315e28c8SJames Pearson 982d6f64b89SAl Viro mm = mm_for_maps(task); 983d6f64b89SAl Viro ret = PTR_ERR(mm); 984d6f64b89SAl Viro if (!mm || IS_ERR(mm)) 985315e28c8SJames Pearson goto out_free; 986315e28c8SJames Pearson 987d6f64b89SAl Viro ret = 0; 988315e28c8SJames Pearson while (count > 0) { 989315e28c8SJames Pearson int this_len, retval, max_len; 990315e28c8SJames Pearson 991315e28c8SJames Pearson this_len = mm->env_end - (mm->env_start + src); 992315e28c8SJames Pearson 993315e28c8SJames Pearson if (this_len <= 0) 994315e28c8SJames Pearson break; 995315e28c8SJames Pearson 996315e28c8SJames Pearson max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 997315e28c8SJames Pearson this_len = (this_len > max_len) ? max_len : this_len; 998315e28c8SJames Pearson 999315e28c8SJames Pearson retval = access_process_vm(task, (mm->env_start + src), 1000315e28c8SJames Pearson page, this_len, 0); 1001315e28c8SJames Pearson 1002315e28c8SJames Pearson if (retval <= 0) { 1003315e28c8SJames Pearson ret = retval; 1004315e28c8SJames Pearson break; 1005315e28c8SJames Pearson } 1006315e28c8SJames Pearson 1007315e28c8SJames Pearson if (copy_to_user(buf, page, retval)) { 1008315e28c8SJames Pearson ret = -EFAULT; 1009315e28c8SJames Pearson break; 1010315e28c8SJames Pearson } 1011315e28c8SJames Pearson 1012315e28c8SJames Pearson ret += retval; 1013315e28c8SJames Pearson src += retval; 1014315e28c8SJames Pearson buf += retval; 1015315e28c8SJames Pearson count -= retval; 1016315e28c8SJames Pearson } 1017315e28c8SJames Pearson *ppos = src; 1018315e28c8SJames Pearson 1019315e28c8SJames Pearson mmput(mm); 1020315e28c8SJames Pearson out_free: 1021315e28c8SJames Pearson free_page((unsigned long) page); 1022315e28c8SJames Pearson out: 1023315e28c8SJames Pearson put_task_struct(task); 1024315e28c8SJames Pearson out_no_task: 1025315e28c8SJames Pearson return ret; 1026315e28c8SJames Pearson } 1027315e28c8SJames Pearson 1028315e28c8SJames Pearson static const struct file_operations proc_environ_operations = { 1029315e28c8SJames Pearson .read = environ_read, 103087df8424SArnd Bergmann .llseek = generic_file_llseek, 1031315e28c8SJames Pearson }; 1032315e28c8SJames Pearson 10331da177e4SLinus Torvalds static ssize_t oom_adjust_read(struct file *file, char __user *buf, 10341da177e4SLinus Torvalds size_t count, loff_t *ppos) 10351da177e4SLinus Torvalds { 10362fddfeefSJosef "Jeff" Sipek struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 10378578cea7SEric W. Biederman char buffer[PROC_NUMBUF]; 10381da177e4SLinus Torvalds size_t len; 103928b83c51SKOSAKI Motohiro int oom_adjust = OOM_DISABLE; 104028b83c51SKOSAKI Motohiro unsigned long flags; 10411da177e4SLinus Torvalds 104299f89551SEric W. Biederman if (!task) 104399f89551SEric W. Biederman return -ESRCH; 104428b83c51SKOSAKI Motohiro 104528b83c51SKOSAKI Motohiro if (lock_task_sighand(task, &flags)) { 104628b83c51SKOSAKI Motohiro oom_adjust = task->signal->oom_adj; 104728b83c51SKOSAKI Motohiro unlock_task_sighand(task, &flags); 104828b83c51SKOSAKI Motohiro } 104928b83c51SKOSAKI Motohiro 105099f89551SEric W. Biederman put_task_struct(task); 105199f89551SEric W. Biederman 10528578cea7SEric W. Biederman len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust); 10530c28f287SAkinobu Mita 10540c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 10551da177e4SLinus Torvalds } 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds static ssize_t oom_adjust_write(struct file *file, const char __user *buf, 10581da177e4SLinus Torvalds size_t count, loff_t *ppos) 10591da177e4SLinus Torvalds { 106099f89551SEric W. Biederman struct task_struct *task; 10615d863b89SKOSAKI Motohiro char buffer[PROC_NUMBUF]; 1062*0a8cb8e3SAlexey Dobriyan int oom_adjust; 106328b83c51SKOSAKI Motohiro unsigned long flags; 10645d863b89SKOSAKI Motohiro int err; 10651da177e4SLinus Torvalds 10668578cea7SEric W. Biederman memset(buffer, 0, sizeof(buffer)); 10678578cea7SEric W. Biederman if (count > sizeof(buffer) - 1) 10688578cea7SEric W. Biederman count = sizeof(buffer) - 1; 1069723548bfSDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1070723548bfSDavid Rientjes err = -EFAULT; 1071723548bfSDavid Rientjes goto out; 1072723548bfSDavid Rientjes } 10735d863b89SKOSAKI Motohiro 1074*0a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &oom_adjust); 10755d863b89SKOSAKI Motohiro if (err) 1076723548bfSDavid Rientjes goto out; 10778ac773b4SAlexey Dobriyan if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) && 1078723548bfSDavid Rientjes oom_adjust != OOM_DISABLE) { 1079723548bfSDavid Rientjes err = -EINVAL; 1080723548bfSDavid Rientjes goto out; 1081723548bfSDavid Rientjes } 10825d863b89SKOSAKI Motohiro 10832fddfeefSJosef "Jeff" Sipek task = get_proc_task(file->f_path.dentry->d_inode); 1084723548bfSDavid Rientjes if (!task) { 1085723548bfSDavid Rientjes err = -ESRCH; 1086723548bfSDavid Rientjes goto out; 1087723548bfSDavid Rientjes } 108828b83c51SKOSAKI Motohiro 10893d5992d2SYing Han task_lock(task); 10903d5992d2SYing Han if (!task->mm) { 1091723548bfSDavid Rientjes err = -EINVAL; 1092723548bfSDavid Rientjes goto err_task_lock; 10933d5992d2SYing Han } 10943d5992d2SYing Han 1095d19d5476SDavid Rientjes if (!lock_task_sighand(task, &flags)) { 1096d19d5476SDavid Rientjes err = -ESRCH; 1097d19d5476SDavid Rientjes goto err_task_lock; 1098d19d5476SDavid Rientjes } 1099d19d5476SDavid Rientjes 1100d19d5476SDavid Rientjes if (oom_adjust < task->signal->oom_adj && !capable(CAP_SYS_RESOURCE)) { 1101d19d5476SDavid Rientjes err = -EACCES; 1102d19d5476SDavid Rientjes goto err_sighand; 1103d19d5476SDavid Rientjes } 1104d19d5476SDavid Rientjes 11053d5992d2SYing Han if (oom_adjust != task->signal->oom_adj) { 11063d5992d2SYing Han if (oom_adjust == OOM_DISABLE) 11073d5992d2SYing Han atomic_inc(&task->mm->oom_disable_count); 11083d5992d2SYing Han if (task->signal->oom_adj == OOM_DISABLE) 11093d5992d2SYing Han atomic_dec(&task->mm->oom_disable_count); 11103d5992d2SYing Han } 11113d5992d2SYing Han 111251b1bd2aSDavid Rientjes /* 111351b1bd2aSDavid Rientjes * Warn that /proc/pid/oom_adj is deprecated, see 111451b1bd2aSDavid Rientjes * Documentation/feature-removal-schedule.txt. 111551b1bd2aSDavid Rientjes */ 111651b1bd2aSDavid Rientjes printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, " 111751b1bd2aSDavid Rientjes "please use /proc/%d/oom_score_adj instead.\n", 111851b1bd2aSDavid Rientjes current->comm, task_pid_nr(current), 111951b1bd2aSDavid Rientjes task_pid_nr(task), task_pid_nr(task)); 112028b83c51SKOSAKI Motohiro task->signal->oom_adj = oom_adjust; 1121a63d83f4SDavid Rientjes /* 1122a63d83f4SDavid Rientjes * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum 1123a63d83f4SDavid Rientjes * value is always attainable. 1124a63d83f4SDavid Rientjes */ 1125a63d83f4SDavid Rientjes if (task->signal->oom_adj == OOM_ADJUST_MAX) 1126a63d83f4SDavid Rientjes task->signal->oom_score_adj = OOM_SCORE_ADJ_MAX; 1127a63d83f4SDavid Rientjes else 1128a63d83f4SDavid Rientjes task->signal->oom_score_adj = (oom_adjust * OOM_SCORE_ADJ_MAX) / 1129a63d83f4SDavid Rientjes -OOM_DISABLE; 1130723548bfSDavid Rientjes err_sighand: 113128b83c51SKOSAKI Motohiro unlock_task_sighand(task, &flags); 1132d19d5476SDavid Rientjes err_task_lock: 1133d19d5476SDavid Rientjes task_unlock(task); 113499f89551SEric W. Biederman put_task_struct(task); 1135723548bfSDavid Rientjes out: 1136723548bfSDavid Rientjes return err < 0 ? err : count; 11371da177e4SLinus Torvalds } 11381da177e4SLinus Torvalds 113900977a59SArjan van de Ven static const struct file_operations proc_oom_adjust_operations = { 11401da177e4SLinus Torvalds .read = oom_adjust_read, 11411da177e4SLinus Torvalds .write = oom_adjust_write, 114287df8424SArnd Bergmann .llseek = generic_file_llseek, 11431da177e4SLinus Torvalds }; 11441da177e4SLinus Torvalds 1145a63d83f4SDavid Rientjes static ssize_t oom_score_adj_read(struct file *file, char __user *buf, 1146a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1147a63d83f4SDavid Rientjes { 1148a63d83f4SDavid Rientjes struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 1149a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1150a63d83f4SDavid Rientjes int oom_score_adj = OOM_SCORE_ADJ_MIN; 1151a63d83f4SDavid Rientjes unsigned long flags; 1152a63d83f4SDavid Rientjes size_t len; 1153a63d83f4SDavid Rientjes 1154a63d83f4SDavid Rientjes if (!task) 1155a63d83f4SDavid Rientjes return -ESRCH; 1156a63d83f4SDavid Rientjes if (lock_task_sighand(task, &flags)) { 1157a63d83f4SDavid Rientjes oom_score_adj = task->signal->oom_score_adj; 1158a63d83f4SDavid Rientjes unlock_task_sighand(task, &flags); 1159a63d83f4SDavid Rientjes } 1160a63d83f4SDavid Rientjes put_task_struct(task); 1161a63d83f4SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%d\n", oom_score_adj); 1162a63d83f4SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 1163a63d83f4SDavid Rientjes } 1164a63d83f4SDavid Rientjes 1165a63d83f4SDavid Rientjes static ssize_t oom_score_adj_write(struct file *file, const char __user *buf, 1166a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1167a63d83f4SDavid Rientjes { 1168a63d83f4SDavid Rientjes struct task_struct *task; 1169a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1170a63d83f4SDavid Rientjes unsigned long flags; 1171*0a8cb8e3SAlexey Dobriyan int oom_score_adj; 1172a63d83f4SDavid Rientjes int err; 1173a63d83f4SDavid Rientjes 1174a63d83f4SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1175a63d83f4SDavid Rientjes if (count > sizeof(buffer) - 1) 1176a63d83f4SDavid Rientjes count = sizeof(buffer) - 1; 1177723548bfSDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1178723548bfSDavid Rientjes err = -EFAULT; 1179723548bfSDavid Rientjes goto out; 1180723548bfSDavid Rientjes } 1181a63d83f4SDavid Rientjes 1182*0a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &oom_score_adj); 1183a63d83f4SDavid Rientjes if (err) 1184723548bfSDavid Rientjes goto out; 1185a63d83f4SDavid Rientjes if (oom_score_adj < OOM_SCORE_ADJ_MIN || 1186723548bfSDavid Rientjes oom_score_adj > OOM_SCORE_ADJ_MAX) { 1187723548bfSDavid Rientjes err = -EINVAL; 1188723548bfSDavid Rientjes goto out; 1189723548bfSDavid Rientjes } 1190a63d83f4SDavid Rientjes 1191a63d83f4SDavid Rientjes task = get_proc_task(file->f_path.dentry->d_inode); 1192723548bfSDavid Rientjes if (!task) { 1193723548bfSDavid Rientjes err = -ESRCH; 1194723548bfSDavid Rientjes goto out; 1195723548bfSDavid Rientjes } 1196a63d83f4SDavid Rientjes 11973d5992d2SYing Han task_lock(task); 11983d5992d2SYing Han if (!task->mm) { 1199723548bfSDavid Rientjes err = -EINVAL; 1200723548bfSDavid Rientjes goto err_task_lock; 12013d5992d2SYing Han } 1202d19d5476SDavid Rientjes 1203d19d5476SDavid Rientjes if (!lock_task_sighand(task, &flags)) { 1204d19d5476SDavid Rientjes err = -ESRCH; 1205d19d5476SDavid Rientjes goto err_task_lock; 1206d19d5476SDavid Rientjes } 1207d19d5476SDavid Rientjes 1208dabb16f6SMandeep Singh Baines if (oom_score_adj < task->signal->oom_score_adj_min && 1209d19d5476SDavid Rientjes !capable(CAP_SYS_RESOURCE)) { 1210d19d5476SDavid Rientjes err = -EACCES; 1211d19d5476SDavid Rientjes goto err_sighand; 1212d19d5476SDavid Rientjes } 1213d19d5476SDavid Rientjes 12143d5992d2SYing Han if (oom_score_adj != task->signal->oom_score_adj) { 12153d5992d2SYing Han if (oom_score_adj == OOM_SCORE_ADJ_MIN) 12163d5992d2SYing Han atomic_inc(&task->mm->oom_disable_count); 12173d5992d2SYing Han if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN) 12183d5992d2SYing Han atomic_dec(&task->mm->oom_disable_count); 12193d5992d2SYing Han } 1220a63d83f4SDavid Rientjes task->signal->oom_score_adj = oom_score_adj; 1221dabb16f6SMandeep Singh Baines if (has_capability_noaudit(current, CAP_SYS_RESOURCE)) 1222dabb16f6SMandeep Singh Baines task->signal->oom_score_adj_min = oom_score_adj; 1223a63d83f4SDavid Rientjes /* 1224a63d83f4SDavid Rientjes * Scale /proc/pid/oom_adj appropriately ensuring that OOM_DISABLE is 1225a63d83f4SDavid Rientjes * always attainable. 1226a63d83f4SDavid Rientjes */ 1227a63d83f4SDavid Rientjes if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN) 1228a63d83f4SDavid Rientjes task->signal->oom_adj = OOM_DISABLE; 1229a63d83f4SDavid Rientjes else 1230a63d83f4SDavid Rientjes task->signal->oom_adj = (oom_score_adj * OOM_ADJUST_MAX) / 1231a63d83f4SDavid Rientjes OOM_SCORE_ADJ_MAX; 1232723548bfSDavid Rientjes err_sighand: 1233a63d83f4SDavid Rientjes unlock_task_sighand(task, &flags); 1234d19d5476SDavid Rientjes err_task_lock: 1235d19d5476SDavid Rientjes task_unlock(task); 1236a63d83f4SDavid Rientjes put_task_struct(task); 1237723548bfSDavid Rientjes out: 1238723548bfSDavid Rientjes return err < 0 ? err : count; 1239a63d83f4SDavid Rientjes } 1240a63d83f4SDavid Rientjes 1241a63d83f4SDavid Rientjes static const struct file_operations proc_oom_score_adj_operations = { 1242a63d83f4SDavid Rientjes .read = oom_score_adj_read, 1243a63d83f4SDavid Rientjes .write = oom_score_adj_write, 12446038f373SArnd Bergmann .llseek = default_llseek, 1245a63d83f4SDavid Rientjes }; 1246a63d83f4SDavid Rientjes 12471da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 12481da177e4SLinus Torvalds #define TMPBUFLEN 21 12491da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 12501da177e4SLinus Torvalds size_t count, loff_t *ppos) 12511da177e4SLinus Torvalds { 12522fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 125399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 12541da177e4SLinus Torvalds ssize_t length; 12551da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 12561da177e4SLinus Torvalds 125799f89551SEric W. Biederman if (!task) 125899f89551SEric W. Biederman return -ESRCH; 12591da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 12600c11b942SAl Viro audit_get_loginuid(task)); 126199f89551SEric W. Biederman put_task_struct(task); 12621da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 12661da177e4SLinus Torvalds size_t count, loff_t *ppos) 12671da177e4SLinus Torvalds { 12682fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 12691da177e4SLinus Torvalds char *page, *tmp; 12701da177e4SLinus Torvalds ssize_t length; 12711da177e4SLinus Torvalds uid_t loginuid; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds if (!capable(CAP_AUDIT_CONTROL)) 12741da177e4SLinus Torvalds return -EPERM; 12751da177e4SLinus Torvalds 12767dc52157SPaul E. McKenney rcu_read_lock(); 12777dc52157SPaul E. McKenney if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) { 12787dc52157SPaul E. McKenney rcu_read_unlock(); 12791da177e4SLinus Torvalds return -EPERM; 12807dc52157SPaul E. McKenney } 12817dc52157SPaul E. McKenney rcu_read_unlock(); 12821da177e4SLinus Torvalds 1283e0182909SAl Viro if (count >= PAGE_SIZE) 1284e0182909SAl Viro count = PAGE_SIZE - 1; 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds if (*ppos != 0) { 12871da177e4SLinus Torvalds /* No partial writes. */ 12881da177e4SLinus Torvalds return -EINVAL; 12891da177e4SLinus Torvalds } 1290e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 12911da177e4SLinus Torvalds if (!page) 12921da177e4SLinus Torvalds return -ENOMEM; 12931da177e4SLinus Torvalds length = -EFAULT; 12941da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 12951da177e4SLinus Torvalds goto out_free_page; 12961da177e4SLinus Torvalds 1297e0182909SAl Viro page[count] = '\0'; 12981da177e4SLinus Torvalds loginuid = simple_strtoul(page, &tmp, 10); 12991da177e4SLinus Torvalds if (tmp == page) { 13001da177e4SLinus Torvalds length = -EINVAL; 13011da177e4SLinus Torvalds goto out_free_page; 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds } 130499f89551SEric W. Biederman length = audit_set_loginuid(current, loginuid); 13051da177e4SLinus Torvalds if (likely(length == 0)) 13061da177e4SLinus Torvalds length = count; 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds out_free_page: 13091da177e4SLinus Torvalds free_page((unsigned long) page); 13101da177e4SLinus Torvalds return length; 13111da177e4SLinus Torvalds } 13121da177e4SLinus Torvalds 131300977a59SArjan van de Ven static const struct file_operations proc_loginuid_operations = { 13141da177e4SLinus Torvalds .read = proc_loginuid_read, 13151da177e4SLinus Torvalds .write = proc_loginuid_write, 131687df8424SArnd Bergmann .llseek = generic_file_llseek, 13171da177e4SLinus Torvalds }; 13181e0bd755SEric Paris 13191e0bd755SEric Paris static ssize_t proc_sessionid_read(struct file * file, char __user * buf, 13201e0bd755SEric Paris size_t count, loff_t *ppos) 13211e0bd755SEric Paris { 13221e0bd755SEric Paris struct inode * inode = file->f_path.dentry->d_inode; 13231e0bd755SEric Paris struct task_struct *task = get_proc_task(inode); 13241e0bd755SEric Paris ssize_t length; 13251e0bd755SEric Paris char tmpbuf[TMPBUFLEN]; 13261e0bd755SEric Paris 13271e0bd755SEric Paris if (!task) 13281e0bd755SEric Paris return -ESRCH; 13291e0bd755SEric Paris length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 13301e0bd755SEric Paris audit_get_sessionid(task)); 13311e0bd755SEric Paris put_task_struct(task); 13321e0bd755SEric Paris return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 13331e0bd755SEric Paris } 13341e0bd755SEric Paris 13351e0bd755SEric Paris static const struct file_operations proc_sessionid_operations = { 13361e0bd755SEric Paris .read = proc_sessionid_read, 133787df8424SArnd Bergmann .llseek = generic_file_llseek, 13381e0bd755SEric Paris }; 13391da177e4SLinus Torvalds #endif 13401da177e4SLinus Torvalds 1341f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1342f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_read(struct file * file, char __user * buf, 1343f4f154fdSAkinobu Mita size_t count, loff_t *ppos) 1344f4f154fdSAkinobu Mita { 1345f4f154fdSAkinobu Mita struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 1346f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF]; 1347f4f154fdSAkinobu Mita size_t len; 1348f4f154fdSAkinobu Mita int make_it_fail; 1349f4f154fdSAkinobu Mita 1350f4f154fdSAkinobu Mita if (!task) 1351f4f154fdSAkinobu Mita return -ESRCH; 1352f4f154fdSAkinobu Mita make_it_fail = task->make_it_fail; 1353f4f154fdSAkinobu Mita put_task_struct(task); 1354f4f154fdSAkinobu Mita 1355f4f154fdSAkinobu Mita len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail); 13560c28f287SAkinobu Mita 13570c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 1358f4f154fdSAkinobu Mita } 1359f4f154fdSAkinobu Mita 1360f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_write(struct file * file, 1361f4f154fdSAkinobu Mita const char __user * buf, size_t count, loff_t *ppos) 1362f4f154fdSAkinobu Mita { 1363f4f154fdSAkinobu Mita struct task_struct *task; 1364f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF], *end; 1365f4f154fdSAkinobu Mita int make_it_fail; 1366f4f154fdSAkinobu Mita 1367f4f154fdSAkinobu Mita if (!capable(CAP_SYS_RESOURCE)) 1368f4f154fdSAkinobu Mita return -EPERM; 1369f4f154fdSAkinobu Mita memset(buffer, 0, sizeof(buffer)); 1370f4f154fdSAkinobu Mita if (count > sizeof(buffer) - 1) 1371f4f154fdSAkinobu Mita count = sizeof(buffer) - 1; 1372f4f154fdSAkinobu Mita if (copy_from_user(buffer, buf, count)) 1373f4f154fdSAkinobu Mita return -EFAULT; 1374cba8aafeSVincent Li make_it_fail = simple_strtol(strstrip(buffer), &end, 0); 1375cba8aafeSVincent Li if (*end) 1376cba8aafeSVincent Li return -EINVAL; 1377f4f154fdSAkinobu Mita task = get_proc_task(file->f_dentry->d_inode); 1378f4f154fdSAkinobu Mita if (!task) 1379f4f154fdSAkinobu Mita return -ESRCH; 1380f4f154fdSAkinobu Mita task->make_it_fail = make_it_fail; 1381f4f154fdSAkinobu Mita put_task_struct(task); 1382cba8aafeSVincent Li 1383cba8aafeSVincent Li return count; 1384f4f154fdSAkinobu Mita } 1385f4f154fdSAkinobu Mita 138600977a59SArjan van de Ven static const struct file_operations proc_fault_inject_operations = { 1387f4f154fdSAkinobu Mita .read = proc_fault_inject_read, 1388f4f154fdSAkinobu Mita .write = proc_fault_inject_write, 138987df8424SArnd Bergmann .llseek = generic_file_llseek, 1390f4f154fdSAkinobu Mita }; 1391f4f154fdSAkinobu Mita #endif 1392f4f154fdSAkinobu Mita 13939745512cSArjan van de Ven 139443ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 139543ae34cbSIngo Molnar /* 139643ae34cbSIngo Molnar * Print out various scheduling related per-task fields: 139743ae34cbSIngo Molnar */ 139843ae34cbSIngo Molnar static int sched_show(struct seq_file *m, void *v) 139943ae34cbSIngo Molnar { 140043ae34cbSIngo Molnar struct inode *inode = m->private; 140143ae34cbSIngo Molnar struct task_struct *p; 140243ae34cbSIngo Molnar 140343ae34cbSIngo Molnar p = get_proc_task(inode); 140443ae34cbSIngo Molnar if (!p) 140543ae34cbSIngo Molnar return -ESRCH; 140643ae34cbSIngo Molnar proc_sched_show_task(p, m); 140743ae34cbSIngo Molnar 140843ae34cbSIngo Molnar put_task_struct(p); 140943ae34cbSIngo Molnar 141043ae34cbSIngo Molnar return 0; 141143ae34cbSIngo Molnar } 141243ae34cbSIngo Molnar 141343ae34cbSIngo Molnar static ssize_t 141443ae34cbSIngo Molnar sched_write(struct file *file, const char __user *buf, 141543ae34cbSIngo Molnar size_t count, loff_t *offset) 141643ae34cbSIngo Molnar { 141743ae34cbSIngo Molnar struct inode *inode = file->f_path.dentry->d_inode; 141843ae34cbSIngo Molnar struct task_struct *p; 141943ae34cbSIngo Molnar 142043ae34cbSIngo Molnar p = get_proc_task(inode); 142143ae34cbSIngo Molnar if (!p) 142243ae34cbSIngo Molnar return -ESRCH; 142343ae34cbSIngo Molnar proc_sched_set_task(p); 142443ae34cbSIngo Molnar 142543ae34cbSIngo Molnar put_task_struct(p); 142643ae34cbSIngo Molnar 142743ae34cbSIngo Molnar return count; 142843ae34cbSIngo Molnar } 142943ae34cbSIngo Molnar 143043ae34cbSIngo Molnar static int sched_open(struct inode *inode, struct file *filp) 143143ae34cbSIngo Molnar { 1432c6a34058SJovi Zhang return single_open(filp, sched_show, inode); 143343ae34cbSIngo Molnar } 143443ae34cbSIngo Molnar 143543ae34cbSIngo Molnar static const struct file_operations proc_pid_sched_operations = { 143643ae34cbSIngo Molnar .open = sched_open, 143743ae34cbSIngo Molnar .read = seq_read, 143843ae34cbSIngo Molnar .write = sched_write, 143943ae34cbSIngo Molnar .llseek = seq_lseek, 14405ea473a1SAlexey Dobriyan .release = single_release, 144143ae34cbSIngo Molnar }; 144243ae34cbSIngo Molnar 144343ae34cbSIngo Molnar #endif 144443ae34cbSIngo Molnar 14455091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 14465091faa4SMike Galbraith /* 14475091faa4SMike Galbraith * Print out autogroup related information: 14485091faa4SMike Galbraith */ 14495091faa4SMike Galbraith static int sched_autogroup_show(struct seq_file *m, void *v) 14505091faa4SMike Galbraith { 14515091faa4SMike Galbraith struct inode *inode = m->private; 14525091faa4SMike Galbraith struct task_struct *p; 14535091faa4SMike Galbraith 14545091faa4SMike Galbraith p = get_proc_task(inode); 14555091faa4SMike Galbraith if (!p) 14565091faa4SMike Galbraith return -ESRCH; 14575091faa4SMike Galbraith proc_sched_autogroup_show_task(p, m); 14585091faa4SMike Galbraith 14595091faa4SMike Galbraith put_task_struct(p); 14605091faa4SMike Galbraith 14615091faa4SMike Galbraith return 0; 14625091faa4SMike Galbraith } 14635091faa4SMike Galbraith 14645091faa4SMike Galbraith static ssize_t 14655091faa4SMike Galbraith sched_autogroup_write(struct file *file, const char __user *buf, 14665091faa4SMike Galbraith size_t count, loff_t *offset) 14675091faa4SMike Galbraith { 14685091faa4SMike Galbraith struct inode *inode = file->f_path.dentry->d_inode; 14695091faa4SMike Galbraith struct task_struct *p; 14705091faa4SMike Galbraith char buffer[PROC_NUMBUF]; 1471*0a8cb8e3SAlexey Dobriyan int nice; 14725091faa4SMike Galbraith int err; 14735091faa4SMike Galbraith 14745091faa4SMike Galbraith memset(buffer, 0, sizeof(buffer)); 14755091faa4SMike Galbraith if (count > sizeof(buffer) - 1) 14765091faa4SMike Galbraith count = sizeof(buffer) - 1; 14775091faa4SMike Galbraith if (copy_from_user(buffer, buf, count)) 14785091faa4SMike Galbraith return -EFAULT; 14795091faa4SMike Galbraith 1480*0a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &nice); 1481*0a8cb8e3SAlexey Dobriyan if (err < 0) 1482*0a8cb8e3SAlexey Dobriyan return err; 14835091faa4SMike Galbraith 14845091faa4SMike Galbraith p = get_proc_task(inode); 14855091faa4SMike Galbraith if (!p) 14865091faa4SMike Galbraith return -ESRCH; 14875091faa4SMike Galbraith 14885091faa4SMike Galbraith err = nice; 14895091faa4SMike Galbraith err = proc_sched_autogroup_set_nice(p, &err); 14905091faa4SMike Galbraith if (err) 14915091faa4SMike Galbraith count = err; 14925091faa4SMike Galbraith 14935091faa4SMike Galbraith put_task_struct(p); 14945091faa4SMike Galbraith 14955091faa4SMike Galbraith return count; 14965091faa4SMike Galbraith } 14975091faa4SMike Galbraith 14985091faa4SMike Galbraith static int sched_autogroup_open(struct inode *inode, struct file *filp) 14995091faa4SMike Galbraith { 15005091faa4SMike Galbraith int ret; 15015091faa4SMike Galbraith 15025091faa4SMike Galbraith ret = single_open(filp, sched_autogroup_show, NULL); 15035091faa4SMike Galbraith if (!ret) { 15045091faa4SMike Galbraith struct seq_file *m = filp->private_data; 15055091faa4SMike Galbraith 15065091faa4SMike Galbraith m->private = inode; 15075091faa4SMike Galbraith } 15085091faa4SMike Galbraith return ret; 15095091faa4SMike Galbraith } 15105091faa4SMike Galbraith 15115091faa4SMike Galbraith static const struct file_operations proc_pid_sched_autogroup_operations = { 15125091faa4SMike Galbraith .open = sched_autogroup_open, 15135091faa4SMike Galbraith .read = seq_read, 15145091faa4SMike Galbraith .write = sched_autogroup_write, 15155091faa4SMike Galbraith .llseek = seq_lseek, 15165091faa4SMike Galbraith .release = single_release, 15175091faa4SMike Galbraith }; 15185091faa4SMike Galbraith 15195091faa4SMike Galbraith #endif /* CONFIG_SCHED_AUTOGROUP */ 15205091faa4SMike Galbraith 15214614a696Sjohn stultz static ssize_t comm_write(struct file *file, const char __user *buf, 15224614a696Sjohn stultz size_t count, loff_t *offset) 15234614a696Sjohn stultz { 15244614a696Sjohn stultz struct inode *inode = file->f_path.dentry->d_inode; 15254614a696Sjohn stultz struct task_struct *p; 15264614a696Sjohn stultz char buffer[TASK_COMM_LEN]; 15274614a696Sjohn stultz 15284614a696Sjohn stultz memset(buffer, 0, sizeof(buffer)); 15294614a696Sjohn stultz if (count > sizeof(buffer) - 1) 15304614a696Sjohn stultz count = sizeof(buffer) - 1; 15314614a696Sjohn stultz if (copy_from_user(buffer, buf, count)) 15324614a696Sjohn stultz return -EFAULT; 15334614a696Sjohn stultz 15344614a696Sjohn stultz p = get_proc_task(inode); 15354614a696Sjohn stultz if (!p) 15364614a696Sjohn stultz return -ESRCH; 15374614a696Sjohn stultz 15384614a696Sjohn stultz if (same_thread_group(current, p)) 15394614a696Sjohn stultz set_task_comm(p, buffer); 15404614a696Sjohn stultz else 15414614a696Sjohn stultz count = -EINVAL; 15424614a696Sjohn stultz 15434614a696Sjohn stultz put_task_struct(p); 15444614a696Sjohn stultz 15454614a696Sjohn stultz return count; 15464614a696Sjohn stultz } 15474614a696Sjohn stultz 15484614a696Sjohn stultz static int comm_show(struct seq_file *m, void *v) 15494614a696Sjohn stultz { 15504614a696Sjohn stultz struct inode *inode = m->private; 15514614a696Sjohn stultz struct task_struct *p; 15524614a696Sjohn stultz 15534614a696Sjohn stultz p = get_proc_task(inode); 15544614a696Sjohn stultz if (!p) 15554614a696Sjohn stultz return -ESRCH; 15564614a696Sjohn stultz 15574614a696Sjohn stultz task_lock(p); 15584614a696Sjohn stultz seq_printf(m, "%s\n", p->comm); 15594614a696Sjohn stultz task_unlock(p); 15604614a696Sjohn stultz 15614614a696Sjohn stultz put_task_struct(p); 15624614a696Sjohn stultz 15634614a696Sjohn stultz return 0; 15644614a696Sjohn stultz } 15654614a696Sjohn stultz 15664614a696Sjohn stultz static int comm_open(struct inode *inode, struct file *filp) 15674614a696Sjohn stultz { 1568c6a34058SJovi Zhang return single_open(filp, comm_show, inode); 15694614a696Sjohn stultz } 15704614a696Sjohn stultz 15714614a696Sjohn stultz static const struct file_operations proc_pid_set_comm_operations = { 15724614a696Sjohn stultz .open = comm_open, 15734614a696Sjohn stultz .read = seq_read, 15744614a696Sjohn stultz .write = comm_write, 15754614a696Sjohn stultz .llseek = seq_lseek, 15764614a696Sjohn stultz .release = single_release, 15774614a696Sjohn stultz }; 15784614a696Sjohn stultz 1579925d1c40SMatt Helsley static int proc_exe_link(struct inode *inode, struct path *exe_path) 1580925d1c40SMatt Helsley { 1581925d1c40SMatt Helsley struct task_struct *task; 1582925d1c40SMatt Helsley struct mm_struct *mm; 1583925d1c40SMatt Helsley struct file *exe_file; 1584925d1c40SMatt Helsley 1585925d1c40SMatt Helsley task = get_proc_task(inode); 1586925d1c40SMatt Helsley if (!task) 1587925d1c40SMatt Helsley return -ENOENT; 1588925d1c40SMatt Helsley mm = get_task_mm(task); 1589925d1c40SMatt Helsley put_task_struct(task); 1590925d1c40SMatt Helsley if (!mm) 1591925d1c40SMatt Helsley return -ENOENT; 1592925d1c40SMatt Helsley exe_file = get_mm_exe_file(mm); 1593925d1c40SMatt Helsley mmput(mm); 1594925d1c40SMatt Helsley if (exe_file) { 1595925d1c40SMatt Helsley *exe_path = exe_file->f_path; 1596925d1c40SMatt Helsley path_get(&exe_file->f_path); 1597925d1c40SMatt Helsley fput(exe_file); 1598925d1c40SMatt Helsley return 0; 1599925d1c40SMatt Helsley } else 1600925d1c40SMatt Helsley return -ENOENT; 1601925d1c40SMatt Helsley } 1602925d1c40SMatt Helsley 1603008b150aSAl Viro static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) 16041da177e4SLinus Torvalds { 16051da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 16061da177e4SLinus Torvalds int error = -EACCES; 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds /* We don't need a base pointer in the /proc filesystem */ 16091d957f9bSJan Blunck path_put(&nd->path); 16101da177e4SLinus Torvalds 1611778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1612778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 16131da177e4SLinus Torvalds goto out; 16141da177e4SLinus Torvalds 16153dcd25f3SJan Blunck error = PROC_I(inode)->op.proc_get_link(inode, &nd->path); 16161da177e4SLinus Torvalds out: 1617008b150aSAl Viro return ERR_PTR(error); 16181da177e4SLinus Torvalds } 16191da177e4SLinus Torvalds 16203dcd25f3SJan Blunck static int do_proc_readlink(struct path *path, char __user *buffer, int buflen) 16211da177e4SLinus Torvalds { 1622e12ba74dSMel Gorman char *tmp = (char*)__get_free_page(GFP_TEMPORARY); 16233dcd25f3SJan Blunck char *pathname; 16241da177e4SLinus Torvalds int len; 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds if (!tmp) 16271da177e4SLinus Torvalds return -ENOMEM; 16281da177e4SLinus Torvalds 16297b2a69baSEric W. Biederman pathname = d_path(path, tmp, PAGE_SIZE); 16303dcd25f3SJan Blunck len = PTR_ERR(pathname); 16313dcd25f3SJan Blunck if (IS_ERR(pathname)) 16321da177e4SLinus Torvalds goto out; 16333dcd25f3SJan Blunck len = tmp + PAGE_SIZE - 1 - pathname; 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds if (len > buflen) 16361da177e4SLinus Torvalds len = buflen; 16373dcd25f3SJan Blunck if (copy_to_user(buffer, pathname, len)) 16381da177e4SLinus Torvalds len = -EFAULT; 16391da177e4SLinus Torvalds out: 16401da177e4SLinus Torvalds free_page((unsigned long)tmp); 16411da177e4SLinus Torvalds return len; 16421da177e4SLinus Torvalds } 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 16451da177e4SLinus Torvalds { 16461da177e4SLinus Torvalds int error = -EACCES; 16471da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 16483dcd25f3SJan Blunck struct path path; 16491da177e4SLinus Torvalds 1650778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1651778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 16521da177e4SLinus Torvalds goto out; 16531da177e4SLinus Torvalds 16543dcd25f3SJan Blunck error = PROC_I(inode)->op.proc_get_link(inode, &path); 16551da177e4SLinus Torvalds if (error) 16561da177e4SLinus Torvalds goto out; 16571da177e4SLinus Torvalds 16583dcd25f3SJan Blunck error = do_proc_readlink(&path, buffer, buflen); 16593dcd25f3SJan Blunck path_put(&path); 16601da177e4SLinus Torvalds out: 16611da177e4SLinus Torvalds return error; 16621da177e4SLinus Torvalds } 16631da177e4SLinus Torvalds 1664c5ef1c42SArjan van de Ven static const struct inode_operations proc_pid_link_inode_operations = { 16651da177e4SLinus Torvalds .readlink = proc_pid_readlink, 16666d76fa58SLinus Torvalds .follow_link = proc_pid_follow_link, 16676d76fa58SLinus Torvalds .setattr = proc_setattr, 16681da177e4SLinus Torvalds }; 16691da177e4SLinus Torvalds 167028a6d671SEric W. Biederman 167128a6d671SEric W. Biederman /* building an inode */ 167228a6d671SEric W. Biederman 167328a6d671SEric W. Biederman static int task_dumpable(struct task_struct *task) 167428a6d671SEric W. Biederman { 167528a6d671SEric W. Biederman int dumpable = 0; 167628a6d671SEric W. Biederman struct mm_struct *mm; 167728a6d671SEric W. Biederman 167828a6d671SEric W. Biederman task_lock(task); 167928a6d671SEric W. Biederman mm = task->mm; 168028a6d671SEric W. Biederman if (mm) 16816c5d5238SKawai, Hidehiro dumpable = get_dumpable(mm); 168228a6d671SEric W. Biederman task_unlock(task); 168328a6d671SEric W. Biederman if(dumpable == 1) 168428a6d671SEric W. Biederman return 1; 168528a6d671SEric W. Biederman return 0; 168628a6d671SEric W. Biederman } 168728a6d671SEric W. Biederman 16886b4e306aSEric W. Biederman struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task) 168928a6d671SEric W. Biederman { 169028a6d671SEric W. Biederman struct inode * inode; 169128a6d671SEric W. Biederman struct proc_inode *ei; 1692c69e8d9cSDavid Howells const struct cred *cred; 169328a6d671SEric W. Biederman 169428a6d671SEric W. Biederman /* We need a new inode */ 169528a6d671SEric W. Biederman 169628a6d671SEric W. Biederman inode = new_inode(sb); 169728a6d671SEric W. Biederman if (!inode) 169828a6d671SEric W. Biederman goto out; 169928a6d671SEric W. Biederman 170028a6d671SEric W. Biederman /* Common stuff */ 170128a6d671SEric W. Biederman ei = PROC_I(inode); 170285fe4025SChristoph Hellwig inode->i_ino = get_next_ino(); 170328a6d671SEric W. Biederman inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 170428a6d671SEric W. Biederman inode->i_op = &proc_def_inode_operations; 170528a6d671SEric W. Biederman 170628a6d671SEric W. Biederman /* 170728a6d671SEric W. Biederman * grab the reference to task. 170828a6d671SEric W. Biederman */ 17091a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 171028a6d671SEric W. Biederman if (!ei->pid) 171128a6d671SEric W. Biederman goto out_unlock; 171228a6d671SEric W. Biederman 171328a6d671SEric W. Biederman if (task_dumpable(task)) { 1714c69e8d9cSDavid Howells rcu_read_lock(); 1715c69e8d9cSDavid Howells cred = __task_cred(task); 1716c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1717c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1718c69e8d9cSDavid Howells rcu_read_unlock(); 171928a6d671SEric W. Biederman } 172028a6d671SEric W. Biederman security_task_to_inode(task, inode); 172128a6d671SEric W. Biederman 172228a6d671SEric W. Biederman out: 172328a6d671SEric W. Biederman return inode; 172428a6d671SEric W. Biederman 172528a6d671SEric W. Biederman out_unlock: 172628a6d671SEric W. Biederman iput(inode); 172728a6d671SEric W. Biederman return NULL; 172828a6d671SEric W. Biederman } 172928a6d671SEric W. Biederman 17306b4e306aSEric W. Biederman int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 173128a6d671SEric W. Biederman { 173228a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 173328a6d671SEric W. Biederman struct task_struct *task; 1734c69e8d9cSDavid Howells const struct cred *cred; 1735c69e8d9cSDavid Howells 173628a6d671SEric W. Biederman generic_fillattr(inode, stat); 173728a6d671SEric W. Biederman 173828a6d671SEric W. Biederman rcu_read_lock(); 173928a6d671SEric W. Biederman stat->uid = 0; 174028a6d671SEric W. Biederman stat->gid = 0; 174128a6d671SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 174228a6d671SEric W. Biederman if (task) { 174328a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 174428a6d671SEric W. Biederman task_dumpable(task)) { 1745c69e8d9cSDavid Howells cred = __task_cred(task); 1746c69e8d9cSDavid Howells stat->uid = cred->euid; 1747c69e8d9cSDavid Howells stat->gid = cred->egid; 174828a6d671SEric W. Biederman } 174928a6d671SEric W. Biederman } 175028a6d671SEric W. Biederman rcu_read_unlock(); 175128a6d671SEric W. Biederman return 0; 175228a6d671SEric W. Biederman } 175328a6d671SEric W. Biederman 175428a6d671SEric W. Biederman /* dentry stuff */ 175528a6d671SEric W. Biederman 175628a6d671SEric W. Biederman /* 175728a6d671SEric W. Biederman * Exceptional case: normally we are not allowed to unhash a busy 175828a6d671SEric W. Biederman * directory. In this case, however, we can do it - no aliasing problems 175928a6d671SEric W. Biederman * due to the way we treat inodes. 176028a6d671SEric W. Biederman * 176128a6d671SEric W. Biederman * Rewrite the inode's ownerships here because the owning task may have 176228a6d671SEric W. Biederman * performed a setuid(), etc. 176328a6d671SEric W. Biederman * 176428a6d671SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 176528a6d671SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 176628a6d671SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 176728a6d671SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 176828a6d671SEric W. Biederman * made this apply to all per process world readable and executable 176928a6d671SEric W. Biederman * directories. 177028a6d671SEric W. Biederman */ 17716b4e306aSEric W. Biederman int pid_revalidate(struct dentry *dentry, struct nameidata *nd) 177228a6d671SEric W. Biederman { 177334286d66SNick Piggin struct inode *inode; 177434286d66SNick Piggin struct task_struct *task; 1775c69e8d9cSDavid Howells const struct cred *cred; 1776c69e8d9cSDavid Howells 177734286d66SNick Piggin if (nd && nd->flags & LOOKUP_RCU) 177834286d66SNick Piggin return -ECHILD; 177934286d66SNick Piggin 178034286d66SNick Piggin inode = dentry->d_inode; 178134286d66SNick Piggin task = get_proc_task(inode); 178234286d66SNick Piggin 178328a6d671SEric W. Biederman if (task) { 178428a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 178528a6d671SEric W. Biederman task_dumpable(task)) { 1786c69e8d9cSDavid Howells rcu_read_lock(); 1787c69e8d9cSDavid Howells cred = __task_cred(task); 1788c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1789c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1790c69e8d9cSDavid Howells rcu_read_unlock(); 179128a6d671SEric W. Biederman } else { 179228a6d671SEric W. Biederman inode->i_uid = 0; 179328a6d671SEric W. Biederman inode->i_gid = 0; 179428a6d671SEric W. Biederman } 179528a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 179628a6d671SEric W. Biederman security_task_to_inode(task, inode); 179728a6d671SEric W. Biederman put_task_struct(task); 179828a6d671SEric W. Biederman return 1; 179928a6d671SEric W. Biederman } 180028a6d671SEric W. Biederman d_drop(dentry); 180128a6d671SEric W. Biederman return 0; 180228a6d671SEric W. Biederman } 180328a6d671SEric W. Biederman 1804fe15ce44SNick Piggin static int pid_delete_dentry(const struct dentry * dentry) 180528a6d671SEric W. Biederman { 180628a6d671SEric W. Biederman /* Is the task we represent dead? 180728a6d671SEric W. Biederman * If so, then don't put the dentry on the lru list, 180828a6d671SEric W. Biederman * kill it immediately. 180928a6d671SEric W. Biederman */ 181028a6d671SEric W. Biederman return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first; 181128a6d671SEric W. Biederman } 181228a6d671SEric W. Biederman 18136b4e306aSEric W. Biederman const struct dentry_operations pid_dentry_operations = 181428a6d671SEric W. Biederman { 181528a6d671SEric W. Biederman .d_revalidate = pid_revalidate, 181628a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 181728a6d671SEric W. Biederman }; 181828a6d671SEric W. Biederman 181928a6d671SEric W. Biederman /* Lookups */ 182028a6d671SEric W. Biederman 18211c0d04c9SEric W. Biederman /* 18221c0d04c9SEric W. Biederman * Fill a directory entry. 18231c0d04c9SEric W. Biederman * 18241c0d04c9SEric W. Biederman * If possible create the dcache entry and derive our inode number and 18251c0d04c9SEric W. Biederman * file type from dcache entry. 18261c0d04c9SEric W. Biederman * 18271c0d04c9SEric W. Biederman * Since all of the proc inode numbers are dynamically generated, the inode 18281c0d04c9SEric W. Biederman * numbers do not exist until the inode is cache. This means creating the 18291c0d04c9SEric W. Biederman * the dcache entry in readdir is necessary to keep the inode numbers 18301c0d04c9SEric W. Biederman * reported by readdir in sync with the inode numbers reported 18311c0d04c9SEric W. Biederman * by stat. 18321c0d04c9SEric W. Biederman */ 18336b4e306aSEric W. Biederman int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir, 18346b4e306aSEric W. Biederman const char *name, int len, 1835c5141e6dSEric Dumazet instantiate_t instantiate, struct task_struct *task, const void *ptr) 183661a28784SEric W. Biederman { 18372fddfeefSJosef "Jeff" Sipek struct dentry *child, *dir = filp->f_path.dentry; 183861a28784SEric W. Biederman struct inode *inode; 183961a28784SEric W. Biederman struct qstr qname; 184061a28784SEric W. Biederman ino_t ino = 0; 184161a28784SEric W. Biederman unsigned type = DT_UNKNOWN; 184261a28784SEric W. Biederman 184361a28784SEric W. Biederman qname.name = name; 184461a28784SEric W. Biederman qname.len = len; 184561a28784SEric W. Biederman qname.hash = full_name_hash(name, len); 184661a28784SEric W. Biederman 184761a28784SEric W. Biederman child = d_lookup(dir, &qname); 184861a28784SEric W. Biederman if (!child) { 184961a28784SEric W. Biederman struct dentry *new; 185061a28784SEric W. Biederman new = d_alloc(dir, &qname); 185161a28784SEric W. Biederman if (new) { 185261a28784SEric W. Biederman child = instantiate(dir->d_inode, new, task, ptr); 185361a28784SEric W. Biederman if (child) 185461a28784SEric W. Biederman dput(new); 185561a28784SEric W. Biederman else 185661a28784SEric W. Biederman child = new; 185761a28784SEric W. Biederman } 185861a28784SEric W. Biederman } 185961a28784SEric W. Biederman if (!child || IS_ERR(child) || !child->d_inode) 186061a28784SEric W. Biederman goto end_instantiate; 186161a28784SEric W. Biederman inode = child->d_inode; 186261a28784SEric W. Biederman if (inode) { 186361a28784SEric W. Biederman ino = inode->i_ino; 186461a28784SEric W. Biederman type = inode->i_mode >> 12; 186561a28784SEric W. Biederman } 186661a28784SEric W. Biederman dput(child); 186761a28784SEric W. Biederman end_instantiate: 186861a28784SEric W. Biederman if (!ino) 186961a28784SEric W. Biederman ino = find_inode_number(dir, &qname); 187061a28784SEric W. Biederman if (!ino) 187161a28784SEric W. Biederman ino = 1; 187261a28784SEric W. Biederman return filldir(dirent, name, len, filp->f_pos, ino, type); 187361a28784SEric W. Biederman } 187461a28784SEric W. Biederman 187528a6d671SEric W. Biederman static unsigned name_to_int(struct dentry *dentry) 187628a6d671SEric W. Biederman { 187728a6d671SEric W. Biederman const char *name = dentry->d_name.name; 187828a6d671SEric W. Biederman int len = dentry->d_name.len; 187928a6d671SEric W. Biederman unsigned n = 0; 188028a6d671SEric W. Biederman 188128a6d671SEric W. Biederman if (len > 1 && *name == '0') 188228a6d671SEric W. Biederman goto out; 188328a6d671SEric W. Biederman while (len-- > 0) { 188428a6d671SEric W. Biederman unsigned c = *name++ - '0'; 188528a6d671SEric W. Biederman if (c > 9) 188628a6d671SEric W. Biederman goto out; 188728a6d671SEric W. Biederman if (n >= (~0U-9)/10) 188828a6d671SEric W. Biederman goto out; 188928a6d671SEric W. Biederman n *= 10; 189028a6d671SEric W. Biederman n += c; 189128a6d671SEric W. Biederman } 189228a6d671SEric W. Biederman return n; 189328a6d671SEric W. Biederman out: 189428a6d671SEric W. Biederman return ~0U; 189528a6d671SEric W. Biederman } 189628a6d671SEric W. Biederman 189727932742SMiklos Szeredi #define PROC_FDINFO_MAX 64 189827932742SMiklos Szeredi 18993dcd25f3SJan Blunck static int proc_fd_info(struct inode *inode, struct path *path, char *info) 190028a6d671SEric W. Biederman { 190128a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 190228a6d671SEric W. Biederman struct files_struct *files = NULL; 190328a6d671SEric W. Biederman struct file *file; 190428a6d671SEric W. Biederman int fd = proc_fd(inode); 190528a6d671SEric W. Biederman 190628a6d671SEric W. Biederman if (task) { 190728a6d671SEric W. Biederman files = get_files_struct(task); 190828a6d671SEric W. Biederman put_task_struct(task); 190928a6d671SEric W. Biederman } 191028a6d671SEric W. Biederman if (files) { 191128a6d671SEric W. Biederman /* 191228a6d671SEric W. Biederman * We are not taking a ref to the file structure, so we must 191328a6d671SEric W. Biederman * hold ->file_lock. 191428a6d671SEric W. Biederman */ 191528a6d671SEric W. Biederman spin_lock(&files->file_lock); 191628a6d671SEric W. Biederman file = fcheck_files(files, fd); 191728a6d671SEric W. Biederman if (file) { 19183dcd25f3SJan Blunck if (path) { 19193dcd25f3SJan Blunck *path = file->f_path; 19203dcd25f3SJan Blunck path_get(&file->f_path); 19213dcd25f3SJan Blunck } 192227932742SMiklos Szeredi if (info) 192327932742SMiklos Szeredi snprintf(info, PROC_FDINFO_MAX, 192427932742SMiklos Szeredi "pos:\t%lli\n" 192527932742SMiklos Szeredi "flags:\t0%o\n", 192627932742SMiklos Szeredi (long long) file->f_pos, 192727932742SMiklos Szeredi file->f_flags); 192828a6d671SEric W. Biederman spin_unlock(&files->file_lock); 192928a6d671SEric W. Biederman put_files_struct(files); 193028a6d671SEric W. Biederman return 0; 193128a6d671SEric W. Biederman } 193228a6d671SEric W. Biederman spin_unlock(&files->file_lock); 193328a6d671SEric W. Biederman put_files_struct(files); 193428a6d671SEric W. Biederman } 193528a6d671SEric W. Biederman return -ENOENT; 193628a6d671SEric W. Biederman } 193728a6d671SEric W. Biederman 19383dcd25f3SJan Blunck static int proc_fd_link(struct inode *inode, struct path *path) 193927932742SMiklos Szeredi { 19403dcd25f3SJan Blunck return proc_fd_info(inode, path, NULL); 194127932742SMiklos Szeredi } 194227932742SMiklos Szeredi 194328a6d671SEric W. Biederman static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd) 194428a6d671SEric W. Biederman { 194534286d66SNick Piggin struct inode *inode; 194634286d66SNick Piggin struct task_struct *task; 194734286d66SNick Piggin int fd; 194828a6d671SEric W. Biederman struct files_struct *files; 1949c69e8d9cSDavid Howells const struct cred *cred; 195028a6d671SEric W. Biederman 195134286d66SNick Piggin if (nd && nd->flags & LOOKUP_RCU) 195234286d66SNick Piggin return -ECHILD; 195334286d66SNick Piggin 195434286d66SNick Piggin inode = dentry->d_inode; 195534286d66SNick Piggin task = get_proc_task(inode); 195634286d66SNick Piggin fd = proc_fd(inode); 195734286d66SNick Piggin 195828a6d671SEric W. Biederman if (task) { 195928a6d671SEric W. Biederman files = get_files_struct(task); 196028a6d671SEric W. Biederman if (files) { 196128a6d671SEric W. Biederman rcu_read_lock(); 196228a6d671SEric W. Biederman if (fcheck_files(files, fd)) { 196328a6d671SEric W. Biederman rcu_read_unlock(); 196428a6d671SEric W. Biederman put_files_struct(files); 196528a6d671SEric W. Biederman if (task_dumpable(task)) { 1966c69e8d9cSDavid Howells rcu_read_lock(); 1967c69e8d9cSDavid Howells cred = __task_cred(task); 1968c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1969c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1970c69e8d9cSDavid Howells rcu_read_unlock(); 197128a6d671SEric W. Biederman } else { 197228a6d671SEric W. Biederman inode->i_uid = 0; 197328a6d671SEric W. Biederman inode->i_gid = 0; 197428a6d671SEric W. Biederman } 197528a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 197628a6d671SEric W. Biederman security_task_to_inode(task, inode); 197728a6d671SEric W. Biederman put_task_struct(task); 197828a6d671SEric W. Biederman return 1; 197928a6d671SEric W. Biederman } 198028a6d671SEric W. Biederman rcu_read_unlock(); 198128a6d671SEric W. Biederman put_files_struct(files); 198228a6d671SEric W. Biederman } 198328a6d671SEric W. Biederman put_task_struct(task); 198428a6d671SEric W. Biederman } 198528a6d671SEric W. Biederman d_drop(dentry); 198628a6d671SEric W. Biederman return 0; 198728a6d671SEric W. Biederman } 198828a6d671SEric W. Biederman 1989d72f71ebSAl Viro static const struct dentry_operations tid_fd_dentry_operations = 199028a6d671SEric W. Biederman { 199128a6d671SEric W. Biederman .d_revalidate = tid_fd_revalidate, 199228a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 199328a6d671SEric W. Biederman }; 199428a6d671SEric W. Biederman 1995444ceed8SEric W. Biederman static struct dentry *proc_fd_instantiate(struct inode *dir, 1996c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 199728a6d671SEric W. Biederman { 1998c5141e6dSEric Dumazet unsigned fd = *(const unsigned *)ptr; 199928a6d671SEric W. Biederman struct file *file; 200028a6d671SEric W. Biederman struct files_struct *files; 200128a6d671SEric W. Biederman struct inode *inode; 200228a6d671SEric W. Biederman struct proc_inode *ei; 2003444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-ENOENT); 200428a6d671SEric W. Biederman 200561a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 200628a6d671SEric W. Biederman if (!inode) 200728a6d671SEric W. Biederman goto out; 200828a6d671SEric W. Biederman ei = PROC_I(inode); 200928a6d671SEric W. Biederman ei->fd = fd; 201028a6d671SEric W. Biederman files = get_files_struct(task); 201128a6d671SEric W. Biederman if (!files) 2012444ceed8SEric W. Biederman goto out_iput; 201328a6d671SEric W. Biederman inode->i_mode = S_IFLNK; 201428a6d671SEric W. Biederman 201528a6d671SEric W. Biederman /* 201628a6d671SEric W. Biederman * We are not taking a ref to the file structure, so we must 201728a6d671SEric W. Biederman * hold ->file_lock. 201828a6d671SEric W. Biederman */ 201928a6d671SEric W. Biederman spin_lock(&files->file_lock); 202028a6d671SEric W. Biederman file = fcheck_files(files, fd); 202128a6d671SEric W. Biederman if (!file) 2022444ceed8SEric W. Biederman goto out_unlock; 2023aeb5d727SAl Viro if (file->f_mode & FMODE_READ) 202428a6d671SEric W. Biederman inode->i_mode |= S_IRUSR | S_IXUSR; 2025aeb5d727SAl Viro if (file->f_mode & FMODE_WRITE) 202628a6d671SEric W. Biederman inode->i_mode |= S_IWUSR | S_IXUSR; 202728a6d671SEric W. Biederman spin_unlock(&files->file_lock); 202828a6d671SEric W. Biederman put_files_struct(files); 2029444ceed8SEric W. Biederman 203028a6d671SEric W. Biederman inode->i_op = &proc_pid_link_inode_operations; 203128a6d671SEric W. Biederman inode->i_size = 64; 203228a6d671SEric W. Biederman ei->op.proc_get_link = proc_fd_link; 2033fb045adbSNick Piggin d_set_d_op(dentry, &tid_fd_dentry_operations); 203428a6d671SEric W. Biederman d_add(dentry, inode); 203528a6d671SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 203628a6d671SEric W. Biederman if (tid_fd_revalidate(dentry, NULL)) 2037444ceed8SEric W. Biederman error = NULL; 2038444ceed8SEric W. Biederman 2039444ceed8SEric W. Biederman out: 2040444ceed8SEric W. Biederman return error; 2041444ceed8SEric W. Biederman out_unlock: 2042444ceed8SEric W. Biederman spin_unlock(&files->file_lock); 2043444ceed8SEric W. Biederman put_files_struct(files); 2044444ceed8SEric W. Biederman out_iput: 2045444ceed8SEric W. Biederman iput(inode); 2046444ceed8SEric W. Biederman goto out; 2047444ceed8SEric W. Biederman } 2048444ceed8SEric W. Biederman 204927932742SMiklos Szeredi static struct dentry *proc_lookupfd_common(struct inode *dir, 205027932742SMiklos Szeredi struct dentry *dentry, 205127932742SMiklos Szeredi instantiate_t instantiate) 2052444ceed8SEric W. Biederman { 2053444ceed8SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2054444ceed8SEric W. Biederman unsigned fd = name_to_int(dentry); 2055444ceed8SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 2056444ceed8SEric W. Biederman 2057444ceed8SEric W. Biederman if (!task) 2058444ceed8SEric W. Biederman goto out_no_task; 2059444ceed8SEric W. Biederman if (fd == ~0U) 2060444ceed8SEric W. Biederman goto out; 2061444ceed8SEric W. Biederman 206227932742SMiklos Szeredi result = instantiate(dir, dentry, task, &fd); 206328a6d671SEric W. Biederman out: 206428a6d671SEric W. Biederman put_task_struct(task); 206528a6d671SEric W. Biederman out_no_task: 206628a6d671SEric W. Biederman return result; 206728a6d671SEric W. Biederman } 206828a6d671SEric W. Biederman 206927932742SMiklos Szeredi static int proc_readfd_common(struct file * filp, void * dirent, 207027932742SMiklos Szeredi filldir_t filldir, instantiate_t instantiate) 20711da177e4SLinus Torvalds { 20722fddfeefSJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 20735634708bSEric W. Biederman struct inode *inode = dentry->d_inode; 207499f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 2075457c2510SPavel Emelyanov unsigned int fd, ino; 20761da177e4SLinus Torvalds int retval; 20771da177e4SLinus Torvalds struct files_struct * files; 20781da177e4SLinus Torvalds 20791da177e4SLinus Torvalds retval = -ENOENT; 208099f89551SEric W. Biederman if (!p) 208199f89551SEric W. Biederman goto out_no_task; 20821da177e4SLinus Torvalds retval = 0; 20831da177e4SLinus Torvalds 20841da177e4SLinus Torvalds fd = filp->f_pos; 20851da177e4SLinus Torvalds switch (fd) { 20861da177e4SLinus Torvalds case 0: 20871da177e4SLinus Torvalds if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 20881da177e4SLinus Torvalds goto out; 20891da177e4SLinus Torvalds filp->f_pos++; 20901da177e4SLinus Torvalds case 1: 20915634708bSEric W. Biederman ino = parent_ino(dentry); 20921da177e4SLinus Torvalds if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0) 20931da177e4SLinus Torvalds goto out; 20941da177e4SLinus Torvalds filp->f_pos++; 20951da177e4SLinus Torvalds default: 20961da177e4SLinus Torvalds files = get_files_struct(p); 20971da177e4SLinus Torvalds if (!files) 20981da177e4SLinus Torvalds goto out; 2099b835996fSDipankar Sarma rcu_read_lock(); 21001da177e4SLinus Torvalds for (fd = filp->f_pos-2; 21019b4f526cSAl Viro fd < files_fdtable(files)->max_fds; 21021da177e4SLinus Torvalds fd++, filp->f_pos++) { 210327932742SMiklos Szeredi char name[PROC_NUMBUF]; 210427932742SMiklos Szeredi int len; 21051da177e4SLinus Torvalds 21061da177e4SLinus Torvalds if (!fcheck_files(files, fd)) 21071da177e4SLinus Torvalds continue; 2108b835996fSDipankar Sarma rcu_read_unlock(); 21091da177e4SLinus Torvalds 211027932742SMiklos Szeredi len = snprintf(name, sizeof(name), "%d", fd); 211127932742SMiklos Szeredi if (proc_fill_cache(filp, dirent, filldir, 211227932742SMiklos Szeredi name, len, instantiate, 211327932742SMiklos Szeredi p, &fd) < 0) { 2114b835996fSDipankar Sarma rcu_read_lock(); 21151da177e4SLinus Torvalds break; 21161da177e4SLinus Torvalds } 2117b835996fSDipankar Sarma rcu_read_lock(); 21181da177e4SLinus Torvalds } 2119b835996fSDipankar Sarma rcu_read_unlock(); 21201da177e4SLinus Torvalds put_files_struct(files); 21211da177e4SLinus Torvalds } 21221da177e4SLinus Torvalds out: 212399f89551SEric W. Biederman put_task_struct(p); 212499f89551SEric W. Biederman out_no_task: 21251da177e4SLinus Torvalds return retval; 21261da177e4SLinus Torvalds } 21271da177e4SLinus Torvalds 212827932742SMiklos Szeredi static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry, 212927932742SMiklos Szeredi struct nameidata *nd) 213027932742SMiklos Szeredi { 213127932742SMiklos Szeredi return proc_lookupfd_common(dir, dentry, proc_fd_instantiate); 213227932742SMiklos Szeredi } 213327932742SMiklos Szeredi 213427932742SMiklos Szeredi static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir) 213527932742SMiklos Szeredi { 213627932742SMiklos Szeredi return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate); 213727932742SMiklos Szeredi } 213827932742SMiklos Szeredi 213927932742SMiklos Szeredi static ssize_t proc_fdinfo_read(struct file *file, char __user *buf, 214027932742SMiklos Szeredi size_t len, loff_t *ppos) 214127932742SMiklos Szeredi { 214227932742SMiklos Szeredi char tmp[PROC_FDINFO_MAX]; 21433dcd25f3SJan Blunck int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, tmp); 214427932742SMiklos Szeredi if (!err) 214527932742SMiklos Szeredi err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp)); 214627932742SMiklos Szeredi return err; 214727932742SMiklos Szeredi } 214827932742SMiklos Szeredi 214927932742SMiklos Szeredi static const struct file_operations proc_fdinfo_file_operations = { 215027932742SMiklos Szeredi .open = nonseekable_open, 215127932742SMiklos Szeredi .read = proc_fdinfo_read, 21526038f373SArnd Bergmann .llseek = no_llseek, 215327932742SMiklos Szeredi }; 215427932742SMiklos Szeredi 215500977a59SArjan van de Ven static const struct file_operations proc_fd_operations = { 21561da177e4SLinus Torvalds .read = generic_read_dir, 21571da177e4SLinus Torvalds .readdir = proc_readfd, 21586038f373SArnd Bergmann .llseek = default_llseek, 21591da177e4SLinus Torvalds }; 21601da177e4SLinus Torvalds 21611da177e4SLinus Torvalds /* 21628948e11fSAlexey Dobriyan * /proc/pid/fd needs a special permission handler so that a process can still 21638948e11fSAlexey Dobriyan * access /proc/self/fd after it has executed a setuid(). 21648948e11fSAlexey Dobriyan */ 2165b74c79e9SNick Piggin static int proc_fd_permission(struct inode *inode, int mask, unsigned int flags) 21668948e11fSAlexey Dobriyan { 21678948e11fSAlexey Dobriyan int rv; 21688948e11fSAlexey Dobriyan 2169b74c79e9SNick Piggin if (flags & IPERM_FLAG_RCU) 2170b74c79e9SNick Piggin return -ECHILD; 2171b74c79e9SNick Piggin rv = generic_permission(inode, mask, flags, NULL); 21728948e11fSAlexey Dobriyan if (rv == 0) 21738948e11fSAlexey Dobriyan return 0; 21748948e11fSAlexey Dobriyan if (task_pid(current) == proc_pid(inode)) 21758948e11fSAlexey Dobriyan rv = 0; 21768948e11fSAlexey Dobriyan return rv; 21778948e11fSAlexey Dobriyan } 21788948e11fSAlexey Dobriyan 21798948e11fSAlexey Dobriyan /* 21801da177e4SLinus Torvalds * proc directories can do almost nothing.. 21811da177e4SLinus Torvalds */ 2182c5ef1c42SArjan van de Ven static const struct inode_operations proc_fd_inode_operations = { 21831da177e4SLinus Torvalds .lookup = proc_lookupfd, 21848948e11fSAlexey Dobriyan .permission = proc_fd_permission, 21856d76fa58SLinus Torvalds .setattr = proc_setattr, 21861da177e4SLinus Torvalds }; 21871da177e4SLinus Torvalds 218827932742SMiklos Szeredi static struct dentry *proc_fdinfo_instantiate(struct inode *dir, 218927932742SMiklos Szeredi struct dentry *dentry, struct task_struct *task, const void *ptr) 219027932742SMiklos Szeredi { 219127932742SMiklos Szeredi unsigned fd = *(unsigned *)ptr; 219227932742SMiklos Szeredi struct inode *inode; 219327932742SMiklos Szeredi struct proc_inode *ei; 219427932742SMiklos Szeredi struct dentry *error = ERR_PTR(-ENOENT); 219527932742SMiklos Szeredi 219627932742SMiklos Szeredi inode = proc_pid_make_inode(dir->i_sb, task); 219727932742SMiklos Szeredi if (!inode) 219827932742SMiklos Szeredi goto out; 219927932742SMiklos Szeredi ei = PROC_I(inode); 220027932742SMiklos Szeredi ei->fd = fd; 220127932742SMiklos Szeredi inode->i_mode = S_IFREG | S_IRUSR; 220227932742SMiklos Szeredi inode->i_fop = &proc_fdinfo_file_operations; 2203fb045adbSNick Piggin d_set_d_op(dentry, &tid_fd_dentry_operations); 220427932742SMiklos Szeredi d_add(dentry, inode); 220527932742SMiklos Szeredi /* Close the race of the process dying before we return the dentry */ 220627932742SMiklos Szeredi if (tid_fd_revalidate(dentry, NULL)) 220727932742SMiklos Szeredi error = NULL; 220827932742SMiklos Szeredi 220927932742SMiklos Szeredi out: 221027932742SMiklos Szeredi return error; 221127932742SMiklos Szeredi } 221227932742SMiklos Szeredi 221327932742SMiklos Szeredi static struct dentry *proc_lookupfdinfo(struct inode *dir, 221427932742SMiklos Szeredi struct dentry *dentry, 221527932742SMiklos Szeredi struct nameidata *nd) 221627932742SMiklos Szeredi { 221727932742SMiklos Szeredi return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate); 221827932742SMiklos Szeredi } 221927932742SMiklos Szeredi 222027932742SMiklos Szeredi static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir) 222127932742SMiklos Szeredi { 222227932742SMiklos Szeredi return proc_readfd_common(filp, dirent, filldir, 222327932742SMiklos Szeredi proc_fdinfo_instantiate); 222427932742SMiklos Szeredi } 222527932742SMiklos Szeredi 222627932742SMiklos Szeredi static const struct file_operations proc_fdinfo_operations = { 222727932742SMiklos Szeredi .read = generic_read_dir, 222827932742SMiklos Szeredi .readdir = proc_readfdinfo, 22296038f373SArnd Bergmann .llseek = default_llseek, 223027932742SMiklos Szeredi }; 223127932742SMiklos Szeredi 223227932742SMiklos Szeredi /* 223327932742SMiklos Szeredi * proc directories can do almost nothing.. 223427932742SMiklos Szeredi */ 223527932742SMiklos Szeredi static const struct inode_operations proc_fdinfo_inode_operations = { 223627932742SMiklos Szeredi .lookup = proc_lookupfdinfo, 223727932742SMiklos Szeredi .setattr = proc_setattr, 223827932742SMiklos Szeredi }; 223927932742SMiklos Szeredi 224027932742SMiklos Szeredi 2241444ceed8SEric W. Biederman static struct dentry *proc_pident_instantiate(struct inode *dir, 2242c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2243444ceed8SEric W. Biederman { 2244c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2245444ceed8SEric W. Biederman struct inode *inode; 2246444ceed8SEric W. Biederman struct proc_inode *ei; 2247bd6daba9SKOSAKI Motohiro struct dentry *error = ERR_PTR(-ENOENT); 2248444ceed8SEric W. Biederman 224961a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2250444ceed8SEric W. Biederman if (!inode) 2251444ceed8SEric W. Biederman goto out; 2252444ceed8SEric W. Biederman 2253444ceed8SEric W. Biederman ei = PROC_I(inode); 2254444ceed8SEric W. Biederman inode->i_mode = p->mode; 2255444ceed8SEric W. Biederman if (S_ISDIR(inode->i_mode)) 2256444ceed8SEric W. Biederman inode->i_nlink = 2; /* Use getattr to fix if necessary */ 2257444ceed8SEric W. Biederman if (p->iop) 2258444ceed8SEric W. Biederman inode->i_op = p->iop; 2259444ceed8SEric W. Biederman if (p->fop) 2260444ceed8SEric W. Biederman inode->i_fop = p->fop; 2261444ceed8SEric W. Biederman ei->op = p->op; 2262fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2263444ceed8SEric W. Biederman d_add(dentry, inode); 2264444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2265444ceed8SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2266444ceed8SEric W. Biederman error = NULL; 2267444ceed8SEric W. Biederman out: 2268444ceed8SEric W. Biederman return error; 2269444ceed8SEric W. Biederman } 2270444ceed8SEric W. Biederman 22711da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 22721da177e4SLinus Torvalds struct dentry *dentry, 2273c5141e6dSEric Dumazet const struct pid_entry *ents, 22747bcd6b0eSEric W. Biederman unsigned int nents) 22751da177e4SLinus Torvalds { 2276cd6a3ce9SEric W. Biederman struct dentry *error; 227799f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2278c5141e6dSEric Dumazet const struct pid_entry *p, *last; 22791da177e4SLinus Torvalds 2280cd6a3ce9SEric W. Biederman error = ERR_PTR(-ENOENT); 22811da177e4SLinus Torvalds 228299f89551SEric W. Biederman if (!task) 228399f89551SEric W. Biederman goto out_no_task; 22841da177e4SLinus Torvalds 228520cdc894SEric W. Biederman /* 228620cdc894SEric W. Biederman * Yes, it does not scale. And it should not. Don't add 228720cdc894SEric W. Biederman * new entries into /proc/<tgid>/ without very good reasons. 228820cdc894SEric W. Biederman */ 22897bcd6b0eSEric W. Biederman last = &ents[nents - 1]; 22907bcd6b0eSEric W. Biederman for (p = ents; p <= last; p++) { 22911da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 22921da177e4SLinus Torvalds continue; 22931da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 22941da177e4SLinus Torvalds break; 22951da177e4SLinus Torvalds } 22967bcd6b0eSEric W. Biederman if (p > last) 22971da177e4SLinus Torvalds goto out; 22981da177e4SLinus Torvalds 2299444ceed8SEric W. Biederman error = proc_pident_instantiate(dir, dentry, task, p); 23001da177e4SLinus Torvalds out: 230199f89551SEric W. Biederman put_task_struct(task); 230299f89551SEric W. Biederman out_no_task: 2303cd6a3ce9SEric W. Biederman return error; 23041da177e4SLinus Torvalds } 23051da177e4SLinus Torvalds 2306c5141e6dSEric Dumazet static int proc_pident_fill_cache(struct file *filp, void *dirent, 2307c5141e6dSEric Dumazet filldir_t filldir, struct task_struct *task, const struct pid_entry *p) 230861a28784SEric W. Biederman { 230961a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, p->name, p->len, 231061a28784SEric W. Biederman proc_pident_instantiate, task, p); 231161a28784SEric W. Biederman } 231261a28784SEric W. Biederman 231328a6d671SEric W. Biederman static int proc_pident_readdir(struct file *filp, 231428a6d671SEric W. Biederman void *dirent, filldir_t filldir, 2315c5141e6dSEric Dumazet const struct pid_entry *ents, unsigned int nents) 231628a6d671SEric W. Biederman { 231728a6d671SEric W. Biederman int i; 23182fddfeefSJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 231928a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 232028a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 2321c5141e6dSEric Dumazet const struct pid_entry *p, *last; 232228a6d671SEric W. Biederman ino_t ino; 232328a6d671SEric W. Biederman int ret; 232428a6d671SEric W. Biederman 232528a6d671SEric W. Biederman ret = -ENOENT; 232628a6d671SEric W. Biederman if (!task) 232761a28784SEric W. Biederman goto out_no_task; 232828a6d671SEric W. Biederman 232928a6d671SEric W. Biederman ret = 0; 233028a6d671SEric W. Biederman i = filp->f_pos; 233128a6d671SEric W. Biederman switch (i) { 233228a6d671SEric W. Biederman case 0: 233328a6d671SEric W. Biederman ino = inode->i_ino; 233428a6d671SEric W. Biederman if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 233528a6d671SEric W. Biederman goto out; 233628a6d671SEric W. Biederman i++; 233728a6d671SEric W. Biederman filp->f_pos++; 233828a6d671SEric W. Biederman /* fall through */ 233928a6d671SEric W. Biederman case 1: 234028a6d671SEric W. Biederman ino = parent_ino(dentry); 234128a6d671SEric W. Biederman if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 234228a6d671SEric W. Biederman goto out; 234328a6d671SEric W. Biederman i++; 234428a6d671SEric W. Biederman filp->f_pos++; 234528a6d671SEric W. Biederman /* fall through */ 234628a6d671SEric W. Biederman default: 234728a6d671SEric W. Biederman i -= 2; 234828a6d671SEric W. Biederman if (i >= nents) { 234928a6d671SEric W. Biederman ret = 1; 235028a6d671SEric W. Biederman goto out; 235128a6d671SEric W. Biederman } 235228a6d671SEric W. Biederman p = ents + i; 23537bcd6b0eSEric W. Biederman last = &ents[nents - 1]; 23547bcd6b0eSEric W. Biederman while (p <= last) { 235561a28784SEric W. Biederman if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0) 235628a6d671SEric W. Biederman goto out; 235728a6d671SEric W. Biederman filp->f_pos++; 235828a6d671SEric W. Biederman p++; 235928a6d671SEric W. Biederman } 23601da177e4SLinus Torvalds } 23611da177e4SLinus Torvalds 236228a6d671SEric W. Biederman ret = 1; 236328a6d671SEric W. Biederman out: 236461a28784SEric W. Biederman put_task_struct(task); 236561a28784SEric W. Biederman out_no_task: 236628a6d671SEric W. Biederman return ret; 23671da177e4SLinus Torvalds } 23681da177e4SLinus Torvalds 23691da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 237028a6d671SEric W. Biederman static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 237128a6d671SEric W. Biederman size_t count, loff_t *ppos) 237228a6d671SEric W. Biederman { 23732fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 237404ff9708SAl Viro char *p = NULL; 237528a6d671SEric W. Biederman ssize_t length; 237628a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 237728a6d671SEric W. Biederman 237828a6d671SEric W. Biederman if (!task) 237904ff9708SAl Viro return -ESRCH; 238028a6d671SEric W. Biederman 238128a6d671SEric W. Biederman length = security_getprocattr(task, 23822fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 238304ff9708SAl Viro &p); 238428a6d671SEric W. Biederman put_task_struct(task); 238504ff9708SAl Viro if (length > 0) 238604ff9708SAl Viro length = simple_read_from_buffer(buf, count, ppos, p, length); 238704ff9708SAl Viro kfree(p); 238828a6d671SEric W. Biederman return length; 238928a6d671SEric W. Biederman } 239028a6d671SEric W. Biederman 239128a6d671SEric W. Biederman static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 239228a6d671SEric W. Biederman size_t count, loff_t *ppos) 239328a6d671SEric W. Biederman { 23942fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 239528a6d671SEric W. Biederman char *page; 239628a6d671SEric W. Biederman ssize_t length; 239728a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 239828a6d671SEric W. Biederman 239928a6d671SEric W. Biederman length = -ESRCH; 240028a6d671SEric W. Biederman if (!task) 240128a6d671SEric W. Biederman goto out_no_task; 240228a6d671SEric W. Biederman if (count > PAGE_SIZE) 240328a6d671SEric W. Biederman count = PAGE_SIZE; 240428a6d671SEric W. Biederman 240528a6d671SEric W. Biederman /* No partial writes. */ 240628a6d671SEric W. Biederman length = -EINVAL; 240728a6d671SEric W. Biederman if (*ppos != 0) 240828a6d671SEric W. Biederman goto out; 240928a6d671SEric W. Biederman 241028a6d671SEric W. Biederman length = -ENOMEM; 2411e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 241228a6d671SEric W. Biederman if (!page) 241328a6d671SEric W. Biederman goto out; 241428a6d671SEric W. Biederman 241528a6d671SEric W. Biederman length = -EFAULT; 241628a6d671SEric W. Biederman if (copy_from_user(page, buf, count)) 241728a6d671SEric W. Biederman goto out_free; 241828a6d671SEric W. Biederman 2419107db7c7SDavid Howells /* Guard against adverse ptrace interaction */ 24209b1bf12dSKOSAKI Motohiro length = mutex_lock_interruptible(&task->signal->cred_guard_mutex); 2421107db7c7SDavid Howells if (length < 0) 2422107db7c7SDavid Howells goto out_free; 2423107db7c7SDavid Howells 242428a6d671SEric W. Biederman length = security_setprocattr(task, 24252fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 242628a6d671SEric W. Biederman (void*)page, count); 24279b1bf12dSKOSAKI Motohiro mutex_unlock(&task->signal->cred_guard_mutex); 242828a6d671SEric W. Biederman out_free: 242928a6d671SEric W. Biederman free_page((unsigned long) page); 243028a6d671SEric W. Biederman out: 243128a6d671SEric W. Biederman put_task_struct(task); 243228a6d671SEric W. Biederman out_no_task: 243328a6d671SEric W. Biederman return length; 243428a6d671SEric W. Biederman } 243528a6d671SEric W. Biederman 243600977a59SArjan van de Ven static const struct file_operations proc_pid_attr_operations = { 243728a6d671SEric W. Biederman .read = proc_pid_attr_read, 243828a6d671SEric W. Biederman .write = proc_pid_attr_write, 243987df8424SArnd Bergmann .llseek = generic_file_llseek, 244028a6d671SEric W. Biederman }; 244128a6d671SEric W. Biederman 2442c5141e6dSEric Dumazet static const struct pid_entry attr_dir_stuff[] = { 2443631f9c18SAlexey Dobriyan REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2444631f9c18SAlexey Dobriyan REG("prev", S_IRUGO, proc_pid_attr_operations), 2445631f9c18SAlexey Dobriyan REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2446631f9c18SAlexey Dobriyan REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2447631f9c18SAlexey Dobriyan REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2448631f9c18SAlexey Dobriyan REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 244928a6d671SEric W. Biederman }; 245028a6d671SEric W. Biederman 245172d9dcfcSEric W. Biederman static int proc_attr_dir_readdir(struct file * filp, 24521da177e4SLinus Torvalds void * dirent, filldir_t filldir) 24531da177e4SLinus Torvalds { 24541da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 245572d9dcfcSEric W. Biederman attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff)); 24561da177e4SLinus Torvalds } 24571da177e4SLinus Torvalds 245800977a59SArjan van de Ven static const struct file_operations proc_attr_dir_operations = { 24591da177e4SLinus Torvalds .read = generic_read_dir, 246072d9dcfcSEric W. Biederman .readdir = proc_attr_dir_readdir, 24616038f373SArnd Bergmann .llseek = default_llseek, 24621da177e4SLinus Torvalds }; 24631da177e4SLinus Torvalds 246472d9dcfcSEric W. Biederman static struct dentry *proc_attr_dir_lookup(struct inode *dir, 24651da177e4SLinus Torvalds struct dentry *dentry, struct nameidata *nd) 24661da177e4SLinus Torvalds { 24677bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 24687bcd6b0eSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 24691da177e4SLinus Torvalds } 24701da177e4SLinus Torvalds 2471c5ef1c42SArjan van de Ven static const struct inode_operations proc_attr_dir_inode_operations = { 247272d9dcfcSEric W. Biederman .lookup = proc_attr_dir_lookup, 247399f89551SEric W. Biederman .getattr = pid_getattr, 24746d76fa58SLinus Torvalds .setattr = proc_setattr, 24751da177e4SLinus Torvalds }; 24761da177e4SLinus Torvalds 24771da177e4SLinus Torvalds #endif 24781da177e4SLinus Torvalds 2479698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 24803cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, 24813cb4a0bbSKawai, Hidehiro size_t count, loff_t *ppos) 24823cb4a0bbSKawai, Hidehiro { 24833cb4a0bbSKawai, Hidehiro struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 24843cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 24853cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF]; 24863cb4a0bbSKawai, Hidehiro size_t len; 24873cb4a0bbSKawai, Hidehiro int ret; 24883cb4a0bbSKawai, Hidehiro 24893cb4a0bbSKawai, Hidehiro if (!task) 24903cb4a0bbSKawai, Hidehiro return -ESRCH; 24913cb4a0bbSKawai, Hidehiro 24923cb4a0bbSKawai, Hidehiro ret = 0; 24933cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 24943cb4a0bbSKawai, Hidehiro if (mm) { 24953cb4a0bbSKawai, Hidehiro len = snprintf(buffer, sizeof(buffer), "%08lx\n", 24963cb4a0bbSKawai, Hidehiro ((mm->flags & MMF_DUMP_FILTER_MASK) >> 24973cb4a0bbSKawai, Hidehiro MMF_DUMP_FILTER_SHIFT)); 24983cb4a0bbSKawai, Hidehiro mmput(mm); 24993cb4a0bbSKawai, Hidehiro ret = simple_read_from_buffer(buf, count, ppos, buffer, len); 25003cb4a0bbSKawai, Hidehiro } 25013cb4a0bbSKawai, Hidehiro 25023cb4a0bbSKawai, Hidehiro put_task_struct(task); 25033cb4a0bbSKawai, Hidehiro 25043cb4a0bbSKawai, Hidehiro return ret; 25053cb4a0bbSKawai, Hidehiro } 25063cb4a0bbSKawai, Hidehiro 25073cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_write(struct file *file, 25083cb4a0bbSKawai, Hidehiro const char __user *buf, 25093cb4a0bbSKawai, Hidehiro size_t count, 25103cb4a0bbSKawai, Hidehiro loff_t *ppos) 25113cb4a0bbSKawai, Hidehiro { 25123cb4a0bbSKawai, Hidehiro struct task_struct *task; 25133cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 25143cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF], *end; 25153cb4a0bbSKawai, Hidehiro unsigned int val; 25163cb4a0bbSKawai, Hidehiro int ret; 25173cb4a0bbSKawai, Hidehiro int i; 25183cb4a0bbSKawai, Hidehiro unsigned long mask; 25193cb4a0bbSKawai, Hidehiro 25203cb4a0bbSKawai, Hidehiro ret = -EFAULT; 25213cb4a0bbSKawai, Hidehiro memset(buffer, 0, sizeof(buffer)); 25223cb4a0bbSKawai, Hidehiro if (count > sizeof(buffer) - 1) 25233cb4a0bbSKawai, Hidehiro count = sizeof(buffer) - 1; 25243cb4a0bbSKawai, Hidehiro if (copy_from_user(buffer, buf, count)) 25253cb4a0bbSKawai, Hidehiro goto out_no_task; 25263cb4a0bbSKawai, Hidehiro 25273cb4a0bbSKawai, Hidehiro ret = -EINVAL; 25283cb4a0bbSKawai, Hidehiro val = (unsigned int)simple_strtoul(buffer, &end, 0); 25293cb4a0bbSKawai, Hidehiro if (*end == '\n') 25303cb4a0bbSKawai, Hidehiro end++; 25313cb4a0bbSKawai, Hidehiro if (end - buffer == 0) 25323cb4a0bbSKawai, Hidehiro goto out_no_task; 25333cb4a0bbSKawai, Hidehiro 25343cb4a0bbSKawai, Hidehiro ret = -ESRCH; 25353cb4a0bbSKawai, Hidehiro task = get_proc_task(file->f_dentry->d_inode); 25363cb4a0bbSKawai, Hidehiro if (!task) 25373cb4a0bbSKawai, Hidehiro goto out_no_task; 25383cb4a0bbSKawai, Hidehiro 25393cb4a0bbSKawai, Hidehiro ret = end - buffer; 25403cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 25413cb4a0bbSKawai, Hidehiro if (!mm) 25423cb4a0bbSKawai, Hidehiro goto out_no_mm; 25433cb4a0bbSKawai, Hidehiro 25443cb4a0bbSKawai, Hidehiro for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) { 25453cb4a0bbSKawai, Hidehiro if (val & mask) 25463cb4a0bbSKawai, Hidehiro set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 25473cb4a0bbSKawai, Hidehiro else 25483cb4a0bbSKawai, Hidehiro clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 25493cb4a0bbSKawai, Hidehiro } 25503cb4a0bbSKawai, Hidehiro 25513cb4a0bbSKawai, Hidehiro mmput(mm); 25523cb4a0bbSKawai, Hidehiro out_no_mm: 25533cb4a0bbSKawai, Hidehiro put_task_struct(task); 25543cb4a0bbSKawai, Hidehiro out_no_task: 25553cb4a0bbSKawai, Hidehiro return ret; 25563cb4a0bbSKawai, Hidehiro } 25573cb4a0bbSKawai, Hidehiro 25583cb4a0bbSKawai, Hidehiro static const struct file_operations proc_coredump_filter_operations = { 25593cb4a0bbSKawai, Hidehiro .read = proc_coredump_filter_read, 25603cb4a0bbSKawai, Hidehiro .write = proc_coredump_filter_write, 256187df8424SArnd Bergmann .llseek = generic_file_llseek, 25623cb4a0bbSKawai, Hidehiro }; 25633cb4a0bbSKawai, Hidehiro #endif 25643cb4a0bbSKawai, Hidehiro 25651da177e4SLinus Torvalds /* 25661da177e4SLinus Torvalds * /proc/self: 25671da177e4SLinus Torvalds */ 25681da177e4SLinus Torvalds static int proc_self_readlink(struct dentry *dentry, char __user *buffer, 25691da177e4SLinus Torvalds int buflen) 25701da177e4SLinus Torvalds { 2571488e5bc4SEric W. Biederman struct pid_namespace *ns = dentry->d_sb->s_fs_info; 2572b55fcb22SAndrew Morton pid_t tgid = task_tgid_nr_ns(current, ns); 25738578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 2574b55fcb22SAndrew Morton if (!tgid) 2575488e5bc4SEric W. Biederman return -ENOENT; 2576b55fcb22SAndrew Morton sprintf(tmp, "%d", tgid); 25771da177e4SLinus Torvalds return vfs_readlink(dentry,buffer,buflen,tmp); 25781da177e4SLinus Torvalds } 25791da177e4SLinus Torvalds 2580008b150aSAl Viro static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd) 25811da177e4SLinus Torvalds { 2582488e5bc4SEric W. Biederman struct pid_namespace *ns = dentry->d_sb->s_fs_info; 2583b55fcb22SAndrew Morton pid_t tgid = task_tgid_nr_ns(current, ns); 25847fee4868SAl Viro char *name = ERR_PTR(-ENOENT); 25857fee4868SAl Viro if (tgid) { 25867fee4868SAl Viro name = __getname(); 25877fee4868SAl Viro if (!name) 25887fee4868SAl Viro name = ERR_PTR(-ENOMEM); 25897fee4868SAl Viro else 25907fee4868SAl Viro sprintf(name, "%d", tgid); 25917fee4868SAl Viro } 25927fee4868SAl Viro nd_set_link(nd, name); 25937fee4868SAl Viro return NULL; 25947fee4868SAl Viro } 25957fee4868SAl Viro 25967fee4868SAl Viro static void proc_self_put_link(struct dentry *dentry, struct nameidata *nd, 25977fee4868SAl Viro void *cookie) 25987fee4868SAl Viro { 25997fee4868SAl Viro char *s = nd_get_link(nd); 26007fee4868SAl Viro if (!IS_ERR(s)) 26017fee4868SAl Viro __putname(s); 26021da177e4SLinus Torvalds } 26031da177e4SLinus Torvalds 2604c5ef1c42SArjan van de Ven static const struct inode_operations proc_self_inode_operations = { 26051da177e4SLinus Torvalds .readlink = proc_self_readlink, 26061da177e4SLinus Torvalds .follow_link = proc_self_follow_link, 26077fee4868SAl Viro .put_link = proc_self_put_link, 26081da177e4SLinus Torvalds }; 26091da177e4SLinus Torvalds 261028a6d671SEric W. Biederman /* 2611801199ceSEric W. Biederman * proc base 2612801199ceSEric W. Biederman * 2613801199ceSEric W. Biederman * These are the directory entries in the root directory of /proc 2614801199ceSEric W. Biederman * that properly belong to the /proc filesystem, as they describe 2615801199ceSEric W. Biederman * describe something that is process related. 2616801199ceSEric W. Biederman */ 2617c5141e6dSEric Dumazet static const struct pid_entry proc_base_stuff[] = { 261861a28784SEric W. Biederman NOD("self", S_IFLNK|S_IRWXUGO, 2619801199ceSEric W. Biederman &proc_self_inode_operations, NULL, {}), 2620801199ceSEric W. Biederman }; 2621801199ceSEric W. Biederman 2622444ceed8SEric W. Biederman static struct dentry *proc_base_instantiate(struct inode *dir, 2623c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2624801199ceSEric W. Biederman { 2625c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2626801199ceSEric W. Biederman struct inode *inode; 2627801199ceSEric W. Biederman struct proc_inode *ei; 262873d36460SDan Carpenter struct dentry *error; 2629801199ceSEric W. Biederman 2630801199ceSEric W. Biederman /* Allocate the inode */ 2631801199ceSEric W. Biederman error = ERR_PTR(-ENOMEM); 2632801199ceSEric W. Biederman inode = new_inode(dir->i_sb); 2633801199ceSEric W. Biederman if (!inode) 2634801199ceSEric W. Biederman goto out; 2635801199ceSEric W. Biederman 2636801199ceSEric W. Biederman /* Initialize the inode */ 2637801199ceSEric W. Biederman ei = PROC_I(inode); 263885fe4025SChristoph Hellwig inode->i_ino = get_next_ino(); 2639801199ceSEric W. Biederman inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 2640801199ceSEric W. Biederman 2641801199ceSEric W. Biederman /* 2642801199ceSEric W. Biederman * grab the reference to the task. 2643801199ceSEric W. Biederman */ 26441a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 2645801199ceSEric W. Biederman if (!ei->pid) 2646801199ceSEric W. Biederman goto out_iput; 2647801199ceSEric W. Biederman 2648801199ceSEric W. Biederman inode->i_mode = p->mode; 2649801199ceSEric W. Biederman if (S_ISDIR(inode->i_mode)) 2650801199ceSEric W. Biederman inode->i_nlink = 2; 2651801199ceSEric W. Biederman if (S_ISLNK(inode->i_mode)) 2652801199ceSEric W. Biederman inode->i_size = 64; 2653801199ceSEric W. Biederman if (p->iop) 2654801199ceSEric W. Biederman inode->i_op = p->iop; 2655801199ceSEric W. Biederman if (p->fop) 2656801199ceSEric W. Biederman inode->i_fop = p->fop; 2657801199ceSEric W. Biederman ei->op = p->op; 2658801199ceSEric W. Biederman d_add(dentry, inode); 2659801199ceSEric W. Biederman error = NULL; 2660801199ceSEric W. Biederman out: 2661801199ceSEric W. Biederman return error; 2662801199ceSEric W. Biederman out_iput: 2663801199ceSEric W. Biederman iput(inode); 2664801199ceSEric W. Biederman goto out; 2665801199ceSEric W. Biederman } 2666801199ceSEric W. Biederman 2667444ceed8SEric W. Biederman static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry) 2668444ceed8SEric W. Biederman { 2669444ceed8SEric W. Biederman struct dentry *error; 2670444ceed8SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2671c5141e6dSEric Dumazet const struct pid_entry *p, *last; 2672444ceed8SEric W. Biederman 2673444ceed8SEric W. Biederman error = ERR_PTR(-ENOENT); 2674444ceed8SEric W. Biederman 2675444ceed8SEric W. Biederman if (!task) 2676444ceed8SEric W. Biederman goto out_no_task; 2677444ceed8SEric W. Biederman 2678444ceed8SEric W. Biederman /* Lookup the directory entry */ 26797bcd6b0eSEric W. Biederman last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1]; 26807bcd6b0eSEric W. Biederman for (p = proc_base_stuff; p <= last; p++) { 2681444ceed8SEric W. Biederman if (p->len != dentry->d_name.len) 2682444ceed8SEric W. Biederman continue; 2683444ceed8SEric W. Biederman if (!memcmp(dentry->d_name.name, p->name, p->len)) 2684444ceed8SEric W. Biederman break; 2685444ceed8SEric W. Biederman } 26867bcd6b0eSEric W. Biederman if (p > last) 2687444ceed8SEric W. Biederman goto out; 2688444ceed8SEric W. Biederman 2689444ceed8SEric W. Biederman error = proc_base_instantiate(dir, dentry, task, p); 2690444ceed8SEric W. Biederman 2691444ceed8SEric W. Biederman out: 2692444ceed8SEric W. Biederman put_task_struct(task); 2693444ceed8SEric W. Biederman out_no_task: 2694444ceed8SEric W. Biederman return error; 2695444ceed8SEric W. Biederman } 2696444ceed8SEric W. Biederman 2697c5141e6dSEric Dumazet static int proc_base_fill_cache(struct file *filp, void *dirent, 2698c5141e6dSEric Dumazet filldir_t filldir, struct task_struct *task, const struct pid_entry *p) 269961a28784SEric W. Biederman { 270061a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, p->name, p->len, 270161a28784SEric W. Biederman proc_base_instantiate, task, p); 270261a28784SEric W. Biederman } 270361a28784SEric W. Biederman 2704aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 2705297c5d92SAndrea Righi static int do_io_accounting(struct task_struct *task, char *buffer, int whole) 2706aba76fdbSAndrew Morton { 2707940389b8SAndrea Righi struct task_io_accounting acct = task->ioac; 2708297c5d92SAndrea Righi unsigned long flags; 2709297c5d92SAndrea Righi 27105995477aSAndrea Righi if (whole && lock_task_sighand(task, &flags)) { 2711b2d002dbSAndrea Righi struct task_struct *t = task; 2712297c5d92SAndrea Righi 27135995477aSAndrea Righi task_io_accounting_add(&acct, &task->signal->ioac); 27145995477aSAndrea Righi while_each_thread(task, t) 27155995477aSAndrea Righi task_io_accounting_add(&acct, &t->ioac); 2716297c5d92SAndrea Righi 2717297c5d92SAndrea Righi unlock_task_sighand(task, &flags); 2718297c5d92SAndrea Righi } 2719aba76fdbSAndrew Morton return sprintf(buffer, 2720aba76fdbSAndrew Morton "rchar: %llu\n" 2721aba76fdbSAndrew Morton "wchar: %llu\n" 2722aba76fdbSAndrew Morton "syscr: %llu\n" 2723aba76fdbSAndrew Morton "syscw: %llu\n" 2724aba76fdbSAndrew Morton "read_bytes: %llu\n" 2725aba76fdbSAndrew Morton "write_bytes: %llu\n" 2726aba76fdbSAndrew Morton "cancelled_write_bytes: %llu\n", 27277c44319dSAlexander Beregalov (unsigned long long)acct.rchar, 27287c44319dSAlexander Beregalov (unsigned long long)acct.wchar, 27297c44319dSAlexander Beregalov (unsigned long long)acct.syscr, 27307c44319dSAlexander Beregalov (unsigned long long)acct.syscw, 27317c44319dSAlexander Beregalov (unsigned long long)acct.read_bytes, 27327c44319dSAlexander Beregalov (unsigned long long)acct.write_bytes, 27337c44319dSAlexander Beregalov (unsigned long long)acct.cancelled_write_bytes); 2734aba76fdbSAndrew Morton } 2735297c5d92SAndrea Righi 2736297c5d92SAndrea Righi static int proc_tid_io_accounting(struct task_struct *task, char *buffer) 2737297c5d92SAndrea Righi { 2738297c5d92SAndrea Righi return do_io_accounting(task, buffer, 0); 2739297c5d92SAndrea Righi } 2740297c5d92SAndrea Righi 2741297c5d92SAndrea Righi static int proc_tgid_io_accounting(struct task_struct *task, char *buffer) 2742297c5d92SAndrea Righi { 2743297c5d92SAndrea Righi return do_io_accounting(task, buffer, 1); 2744297c5d92SAndrea Righi } 2745297c5d92SAndrea Righi #endif /* CONFIG_TASK_IO_ACCOUNTING */ 2746aba76fdbSAndrew Morton 274747830723SKees Cook static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns, 274847830723SKees Cook struct pid *pid, struct task_struct *task) 274947830723SKees Cook { 2750a9712bc1SAl Viro int err = lock_trace(task); 2751a9712bc1SAl Viro if (!err) { 275247830723SKees Cook seq_printf(m, "%08x\n", task->personality); 2753a9712bc1SAl Viro unlock_trace(task); 2754a9712bc1SAl Viro } 2755a9712bc1SAl Viro return err; 275647830723SKees Cook } 275747830723SKees Cook 2758801199ceSEric W. Biederman /* 275928a6d671SEric W. Biederman * Thread groups 276028a6d671SEric W. Biederman */ 276100977a59SArjan van de Ven static const struct file_operations proc_task_operations; 2762c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations; 276320cdc894SEric W. Biederman 2764c5141e6dSEric Dumazet static const struct pid_entry tgid_base_stuff[] = { 2765631f9c18SAlexey Dobriyan DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations), 2766631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 2767631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 27686b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 2769b2211a36SAndrew Morton #ifdef CONFIG_NET 2770631f9c18SAlexey Dobriyan DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 2771b2211a36SAndrew Morton #endif 2772631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2773631f9c18SAlexey Dobriyan INF("auxv", S_IRUSR, proc_pid_auxv), 2774631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 2775a9712bc1SAl Viro ONE("personality", S_IRUGO, proc_pid_personality), 27763036e7b4SJiri Olsa INF("limits", S_IRUGO, proc_pid_limits), 277743ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2778631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 277943ae34cbSIngo Molnar #endif 27805091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 27815091faa4SMike Galbraith REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations), 27825091faa4SMike Galbraith #endif 27834614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 2784ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 2785a9712bc1SAl Viro INF("syscall", S_IRUGO, proc_pid_syscall), 2786ebcb6734SRoland McGrath #endif 2787631f9c18SAlexey Dobriyan INF("cmdline", S_IRUGO, proc_pid_cmdline), 2788631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tgid_stat), 2789631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2790631f9c18SAlexey Dobriyan REG("maps", S_IRUGO, proc_maps_operations), 279128a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2792631f9c18SAlexey Dobriyan REG("numa_maps", S_IRUGO, proc_numa_maps_operations), 279328a6d671SEric W. Biederman #endif 2794631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2795631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2796631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2797631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2798631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2799631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 2800631f9c18SAlexey Dobriyan REG("mountstats", S_IRUSR, proc_mountstats_operations), 28011e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2802631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2803631f9c18SAlexey Dobriyan REG("smaps", S_IRUGO, proc_smaps_operations), 2804ca6b0bf0SAl Viro REG("pagemap", S_IRUGO, proc_pagemap_operations), 280528a6d671SEric W. Biederman #endif 280628a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2807631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 280828a6d671SEric W. Biederman #endif 280928a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2810631f9c18SAlexey Dobriyan INF("wchan", S_IRUGO, proc_pid_wchan), 281128a6d671SEric W. Biederman #endif 28122ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 2813a9712bc1SAl Viro ONE("stack", S_IRUGO, proc_pid_stack), 281428a6d671SEric W. Biederman #endif 281528a6d671SEric W. Biederman #ifdef CONFIG_SCHEDSTATS 2816631f9c18SAlexey Dobriyan INF("schedstat", S_IRUGO, proc_pid_schedstat), 281728a6d671SEric W. Biederman #endif 28189745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2819631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 28209745512cSArjan van de Ven #endif 28218793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 2822631f9c18SAlexey Dobriyan REG("cpuset", S_IRUGO, proc_cpuset_operations), 282328a6d671SEric W. Biederman #endif 2824a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2825631f9c18SAlexey Dobriyan REG("cgroup", S_IRUGO, proc_cgroup_operations), 2826a424316cSPaul Menage #endif 2827631f9c18SAlexey Dobriyan INF("oom_score", S_IRUGO, proc_oom_score), 2828631f9c18SAlexey Dobriyan REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adjust_operations), 2829a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 283028a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2831631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 2832631f9c18SAlexey Dobriyan REG("sessionid", S_IRUGO, proc_sessionid_operations), 283328a6d671SEric W. Biederman #endif 2834f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2835631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2836f4f154fdSAkinobu Mita #endif 2837698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 2838631f9c18SAlexey Dobriyan REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations), 28393cb4a0bbSKawai, Hidehiro #endif 2840aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 2841631f9c18SAlexey Dobriyan INF("io", S_IRUGO, proc_tgid_io_accounting), 2842aba76fdbSAndrew Morton #endif 284328a6d671SEric W. Biederman }; 284428a6d671SEric W. Biederman 284528a6d671SEric W. Biederman static int proc_tgid_base_readdir(struct file * filp, 284628a6d671SEric W. Biederman void * dirent, filldir_t filldir) 284728a6d671SEric W. Biederman { 284828a6d671SEric W. Biederman return proc_pident_readdir(filp,dirent,filldir, 284928a6d671SEric W. Biederman tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff)); 285028a6d671SEric W. Biederman } 285128a6d671SEric W. Biederman 285200977a59SArjan van de Ven static const struct file_operations proc_tgid_base_operations = { 285328a6d671SEric W. Biederman .read = generic_read_dir, 285428a6d671SEric W. Biederman .readdir = proc_tgid_base_readdir, 28556038f373SArnd Bergmann .llseek = default_llseek, 285628a6d671SEric W. Biederman }; 285728a6d671SEric W. Biederman 285828a6d671SEric W. Biederman static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 28597bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 28607bcd6b0eSEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 286128a6d671SEric W. Biederman } 286228a6d671SEric W. Biederman 2863c5ef1c42SArjan van de Ven static const struct inode_operations proc_tgid_base_inode_operations = { 286428a6d671SEric W. Biederman .lookup = proc_tgid_base_lookup, 286528a6d671SEric W. Biederman .getattr = pid_getattr, 286628a6d671SEric W. Biederman .setattr = proc_setattr, 286728a6d671SEric W. Biederman }; 286828a6d671SEric W. Biederman 286960347f67SPavel Emelyanov static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid) 28701da177e4SLinus Torvalds { 287148e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 28728578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 287348e6484dSEric W. Biederman struct qstr name; 28741da177e4SLinus Torvalds 287548e6484dSEric W. Biederman name.name = buf; 287660347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 287760347f67SPavel Emelyanov dentry = d_hash_and_lookup(mnt->mnt_root, &name); 287848e6484dSEric W. Biederman if (dentry) { 287948e6484dSEric W. Biederman shrink_dcache_parent(dentry); 288048e6484dSEric W. Biederman d_drop(dentry); 288148e6484dSEric W. Biederman dput(dentry); 28821da177e4SLinus Torvalds } 28831da177e4SLinus Torvalds 288448e6484dSEric W. Biederman name.name = buf; 288560347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", tgid); 288660347f67SPavel Emelyanov leader = d_hash_and_lookup(mnt->mnt_root, &name); 288748e6484dSEric W. Biederman if (!leader) 288848e6484dSEric W. Biederman goto out; 288948e6484dSEric W. Biederman 289048e6484dSEric W. Biederman name.name = "task"; 289148e6484dSEric W. Biederman name.len = strlen(name.name); 289248e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 289348e6484dSEric W. Biederman if (!dir) 289448e6484dSEric W. Biederman goto out_put_leader; 289548e6484dSEric W. Biederman 289648e6484dSEric W. Biederman name.name = buf; 289760347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 289848e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 289948e6484dSEric W. Biederman if (dentry) { 290048e6484dSEric W. Biederman shrink_dcache_parent(dentry); 290148e6484dSEric W. Biederman d_drop(dentry); 290248e6484dSEric W. Biederman dput(dentry); 29031da177e4SLinus Torvalds } 290448e6484dSEric W. Biederman 290548e6484dSEric W. Biederman dput(dir); 290648e6484dSEric W. Biederman out_put_leader: 290748e6484dSEric W. Biederman dput(leader); 290848e6484dSEric W. Biederman out: 290948e6484dSEric W. Biederman return; 29101da177e4SLinus Torvalds } 29111da177e4SLinus Torvalds 29120895e91dSRandy Dunlap /** 29130895e91dSRandy Dunlap * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 29140895e91dSRandy Dunlap * @task: task that should be flushed. 29150895e91dSRandy Dunlap * 29160895e91dSRandy Dunlap * When flushing dentries from proc, one needs to flush them from global 291760347f67SPavel Emelyanov * proc (proc_mnt) and from all the namespaces' procs this task was seen 29180895e91dSRandy Dunlap * in. This call is supposed to do all of this job. 29190895e91dSRandy Dunlap * 29200895e91dSRandy Dunlap * Looks in the dcache for 29210895e91dSRandy Dunlap * /proc/@pid 29220895e91dSRandy Dunlap * /proc/@tgid/task/@pid 29230895e91dSRandy Dunlap * if either directory is present flushes it and all of it'ts children 29240895e91dSRandy Dunlap * from the dcache. 29250895e91dSRandy Dunlap * 29260895e91dSRandy Dunlap * It is safe and reasonable to cache /proc entries for a task until 29270895e91dSRandy Dunlap * that task exits. After that they just clog up the dcache with 29280895e91dSRandy Dunlap * useless entries, possibly causing useful dcache entries to be 29290895e91dSRandy Dunlap * flushed instead. This routine is proved to flush those useless 29300895e91dSRandy Dunlap * dcache entries at process exit time. 29310895e91dSRandy Dunlap * 29320895e91dSRandy Dunlap * NOTE: This routine is just an optimization so it does not guarantee 29330895e91dSRandy Dunlap * that no dcache entries will exist at process exit time it 29340895e91dSRandy Dunlap * just makes it very unlikely that any will persist. 293560347f67SPavel Emelyanov */ 293660347f67SPavel Emelyanov 293760347f67SPavel Emelyanov void proc_flush_task(struct task_struct *task) 293860347f67SPavel Emelyanov { 29399fcc2d15SEric W. Biederman int i; 29409b4d1cbeSOleg Nesterov struct pid *pid, *tgid; 2941130f77ecSPavel Emelyanov struct upid *upid; 2942130f77ecSPavel Emelyanov 2943130f77ecSPavel Emelyanov pid = task_pid(task); 2944130f77ecSPavel Emelyanov tgid = task_tgid(task); 29459fcc2d15SEric W. Biederman 29469fcc2d15SEric W. Biederman for (i = 0; i <= pid->level; i++) { 2947130f77ecSPavel Emelyanov upid = &pid->numbers[i]; 2948130f77ecSPavel Emelyanov proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr, 29499b4d1cbeSOleg Nesterov tgid->numbers[i].nr); 2950130f77ecSPavel Emelyanov } 29516f4e6433SPavel Emelyanov 29526f4e6433SPavel Emelyanov upid = &pid->numbers[pid->level]; 29536f4e6433SPavel Emelyanov if (upid->nr == 1) 29546f4e6433SPavel Emelyanov pid_ns_release_proc(upid->ns); 295560347f67SPavel Emelyanov } 295660347f67SPavel Emelyanov 29579711ef99SAdrian Bunk static struct dentry *proc_pid_instantiate(struct inode *dir, 29589711ef99SAdrian Bunk struct dentry * dentry, 2959c5141e6dSEric Dumazet struct task_struct *task, const void *ptr) 2960444ceed8SEric W. Biederman { 2961444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-ENOENT); 2962444ceed8SEric W. Biederman struct inode *inode; 2963444ceed8SEric W. Biederman 296461a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2965444ceed8SEric W. Biederman if (!inode) 2966444ceed8SEric W. Biederman goto out; 2967444ceed8SEric W. Biederman 2968444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 2969444ceed8SEric W. Biederman inode->i_op = &proc_tgid_base_inode_operations; 2970444ceed8SEric W. Biederman inode->i_fop = &proc_tgid_base_operations; 2971444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 2972aed54175SVegard Nossum 2973aed54175SVegard Nossum inode->i_nlink = 2 + pid_entry_count_dirs(tgid_base_stuff, 2974aed54175SVegard Nossum ARRAY_SIZE(tgid_base_stuff)); 2975444ceed8SEric W. Biederman 2976fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2977444ceed8SEric W. Biederman 2978444ceed8SEric W. Biederman d_add(dentry, inode); 2979444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2980444ceed8SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2981444ceed8SEric W. Biederman error = NULL; 2982444ceed8SEric W. Biederman out: 2983444ceed8SEric W. Biederman return error; 2984444ceed8SEric W. Biederman } 2985444ceed8SEric W. Biederman 29861da177e4SLinus Torvalds struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 29871da177e4SLinus Torvalds { 298873d36460SDan Carpenter struct dentry *result; 29891da177e4SLinus Torvalds struct task_struct *task; 29901da177e4SLinus Torvalds unsigned tgid; 2991b488893aSPavel Emelyanov struct pid_namespace *ns; 29921da177e4SLinus Torvalds 2993801199ceSEric W. Biederman result = proc_base_lookup(dir, dentry); 2994801199ceSEric W. Biederman if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT) 2995801199ceSEric W. Biederman goto out; 2996801199ceSEric W. Biederman 29971da177e4SLinus Torvalds tgid = name_to_int(dentry); 29981da177e4SLinus Torvalds if (tgid == ~0U) 29991da177e4SLinus Torvalds goto out; 30001da177e4SLinus Torvalds 3001b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 3002de758734SEric W. Biederman rcu_read_lock(); 3003b488893aSPavel Emelyanov task = find_task_by_pid_ns(tgid, ns); 30041da177e4SLinus Torvalds if (task) 30051da177e4SLinus Torvalds get_task_struct(task); 3006de758734SEric W. Biederman rcu_read_unlock(); 30071da177e4SLinus Torvalds if (!task) 30081da177e4SLinus Torvalds goto out; 30091da177e4SLinus Torvalds 3010444ceed8SEric W. Biederman result = proc_pid_instantiate(dir, dentry, task, NULL); 301148e6484dSEric W. Biederman put_task_struct(task); 30121da177e4SLinus Torvalds out: 3013cd6a3ce9SEric W. Biederman return result; 30141da177e4SLinus Torvalds } 30151da177e4SLinus Torvalds 30161da177e4SLinus Torvalds /* 30170804ef4bSEric W. Biederman * Find the first task with tgid >= tgid 30180bc58a91SEric W. Biederman * 30191da177e4SLinus Torvalds */ 302019fd4bb2SEric W. Biederman struct tgid_iter { 302119fd4bb2SEric W. Biederman unsigned int tgid; 30220804ef4bSEric W. Biederman struct task_struct *task; 302319fd4bb2SEric W. Biederman }; 302419fd4bb2SEric W. Biederman static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter) 302519fd4bb2SEric W. Biederman { 30260804ef4bSEric W. Biederman struct pid *pid; 30271da177e4SLinus Torvalds 302819fd4bb2SEric W. Biederman if (iter.task) 302919fd4bb2SEric W. Biederman put_task_struct(iter.task); 30300804ef4bSEric W. Biederman rcu_read_lock(); 30310804ef4bSEric W. Biederman retry: 303219fd4bb2SEric W. Biederman iter.task = NULL; 303319fd4bb2SEric W. Biederman pid = find_ge_pid(iter.tgid, ns); 30340804ef4bSEric W. Biederman if (pid) { 303519fd4bb2SEric W. Biederman iter.tgid = pid_nr_ns(pid, ns); 303619fd4bb2SEric W. Biederman iter.task = pid_task(pid, PIDTYPE_PID); 30370804ef4bSEric W. Biederman /* What we to know is if the pid we have find is the 30380804ef4bSEric W. Biederman * pid of a thread_group_leader. Testing for task 30390804ef4bSEric W. Biederman * being a thread_group_leader is the obvious thing 30400804ef4bSEric W. Biederman * todo but there is a window when it fails, due to 30410804ef4bSEric W. Biederman * the pid transfer logic in de_thread. 30420804ef4bSEric W. Biederman * 30430804ef4bSEric W. Biederman * So we perform the straight forward test of seeing 30440804ef4bSEric W. Biederman * if the pid we have found is the pid of a thread 30450804ef4bSEric W. Biederman * group leader, and don't worry if the task we have 30460804ef4bSEric W. Biederman * found doesn't happen to be a thread group leader. 30470804ef4bSEric W. Biederman * As we don't care in the case of readdir. 30480bc58a91SEric W. Biederman */ 304919fd4bb2SEric W. Biederman if (!iter.task || !has_group_leader_pid(iter.task)) { 305019fd4bb2SEric W. Biederman iter.tgid += 1; 30510804ef4bSEric W. Biederman goto retry; 305219fd4bb2SEric W. Biederman } 305319fd4bb2SEric W. Biederman get_task_struct(iter.task); 30541da177e4SLinus Torvalds } 3055454cc105SEric W. Biederman rcu_read_unlock(); 305619fd4bb2SEric W. Biederman return iter; 30571da177e4SLinus Torvalds } 30581da177e4SLinus Torvalds 30597bcd6b0eSEric W. Biederman #define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff)) 30601da177e4SLinus Torvalds 306161a28784SEric W. Biederman static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir, 306219fd4bb2SEric W. Biederman struct tgid_iter iter) 306361a28784SEric W. Biederman { 306461a28784SEric W. Biederman char name[PROC_NUMBUF]; 306519fd4bb2SEric W. Biederman int len = snprintf(name, sizeof(name), "%d", iter.tgid); 306661a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, name, len, 306719fd4bb2SEric W. Biederman proc_pid_instantiate, iter.task, NULL); 306861a28784SEric W. Biederman } 306961a28784SEric W. Biederman 30701da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 30711da177e4SLinus Torvalds int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir) 30721da177e4SLinus Torvalds { 3073d8bdc59fSLinus Torvalds unsigned int nr; 3074d8bdc59fSLinus Torvalds struct task_struct *reaper; 307519fd4bb2SEric W. Biederman struct tgid_iter iter; 3076b488893aSPavel Emelyanov struct pid_namespace *ns; 30771da177e4SLinus Torvalds 3078d8bdc59fSLinus Torvalds if (filp->f_pos >= PID_MAX_LIMIT + TGID_OFFSET) 3079d8bdc59fSLinus Torvalds goto out_no_task; 3080d8bdc59fSLinus Torvalds nr = filp->f_pos - FIRST_PROCESS_ENTRY; 3081d8bdc59fSLinus Torvalds 3082d8bdc59fSLinus Torvalds reaper = get_proc_task(filp->f_path.dentry->d_inode); 308361a28784SEric W. Biederman if (!reaper) 308461a28784SEric W. Biederman goto out_no_task; 308561a28784SEric W. Biederman 30867bcd6b0eSEric W. Biederman for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) { 3087c5141e6dSEric Dumazet const struct pid_entry *p = &proc_base_stuff[nr]; 308861a28784SEric W. Biederman if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0) 3089801199ceSEric W. Biederman goto out; 30901da177e4SLinus Torvalds } 30911da177e4SLinus Torvalds 3092b488893aSPavel Emelyanov ns = filp->f_dentry->d_sb->s_fs_info; 309319fd4bb2SEric W. Biederman iter.task = NULL; 309419fd4bb2SEric W. Biederman iter.tgid = filp->f_pos - TGID_OFFSET; 309519fd4bb2SEric W. Biederman for (iter = next_tgid(ns, iter); 309619fd4bb2SEric W. Biederman iter.task; 309719fd4bb2SEric W. Biederman iter.tgid += 1, iter = next_tgid(ns, iter)) { 309819fd4bb2SEric W. Biederman filp->f_pos = iter.tgid + TGID_OFFSET; 309919fd4bb2SEric W. Biederman if (proc_pid_fill_cache(filp, dirent, filldir, iter) < 0) { 310019fd4bb2SEric W. Biederman put_task_struct(iter.task); 31010804ef4bSEric W. Biederman goto out; 31021da177e4SLinus Torvalds } 31031da177e4SLinus Torvalds } 31040804ef4bSEric W. Biederman filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET; 31050804ef4bSEric W. Biederman out: 310661a28784SEric W. Biederman put_task_struct(reaper); 310761a28784SEric W. Biederman out_no_task: 31081da177e4SLinus Torvalds return 0; 31091da177e4SLinus Torvalds } 31101da177e4SLinus Torvalds 31110bc58a91SEric W. Biederman /* 311228a6d671SEric W. Biederman * Tasks 311328a6d671SEric W. Biederman */ 3114c5141e6dSEric Dumazet static const struct pid_entry tid_base_stuff[] = { 3115631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 31163835541dSJerome Marchand DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 31176b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 3118631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 3119631f9c18SAlexey Dobriyan INF("auxv", S_IRUSR, proc_pid_auxv), 3120631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 3121a9712bc1SAl Viro ONE("personality", S_IRUGO, proc_pid_personality), 31223036e7b4SJiri Olsa INF("limits", S_IRUGO, proc_pid_limits), 312343ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 3124631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 312543ae34cbSIngo Molnar #endif 31264614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 3127ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 3128a9712bc1SAl Viro INF("syscall", S_IRUGO, proc_pid_syscall), 3129ebcb6734SRoland McGrath #endif 3130631f9c18SAlexey Dobriyan INF("cmdline", S_IRUGO, proc_pid_cmdline), 3131631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tid_stat), 3132631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 3133631f9c18SAlexey Dobriyan REG("maps", S_IRUGO, proc_maps_operations), 313428a6d671SEric W. Biederman #ifdef CONFIG_NUMA 3135631f9c18SAlexey Dobriyan REG("numa_maps", S_IRUGO, proc_numa_maps_operations), 313628a6d671SEric W. Biederman #endif 3137631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 3138631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 3139631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 3140631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 3141631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 3142631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 31431e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 3144631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 3145631f9c18SAlexey Dobriyan REG("smaps", S_IRUGO, proc_smaps_operations), 3146ca6b0bf0SAl Viro REG("pagemap", S_IRUGO, proc_pagemap_operations), 314728a6d671SEric W. Biederman #endif 314828a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 3149631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 315028a6d671SEric W. Biederman #endif 315128a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 3152631f9c18SAlexey Dobriyan INF("wchan", S_IRUGO, proc_pid_wchan), 315328a6d671SEric W. Biederman #endif 31542ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 3155a9712bc1SAl Viro ONE("stack", S_IRUGO, proc_pid_stack), 315628a6d671SEric W. Biederman #endif 315728a6d671SEric W. Biederman #ifdef CONFIG_SCHEDSTATS 3158631f9c18SAlexey Dobriyan INF("schedstat", S_IRUGO, proc_pid_schedstat), 315928a6d671SEric W. Biederman #endif 31609745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3161631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 31629745512cSArjan van de Ven #endif 31638793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 3164631f9c18SAlexey Dobriyan REG("cpuset", S_IRUGO, proc_cpuset_operations), 316528a6d671SEric W. Biederman #endif 3166a424316cSPaul Menage #ifdef CONFIG_CGROUPS 3167631f9c18SAlexey Dobriyan REG("cgroup", S_IRUGO, proc_cgroup_operations), 3168a424316cSPaul Menage #endif 3169631f9c18SAlexey Dobriyan INF("oom_score", S_IRUGO, proc_oom_score), 3170631f9c18SAlexey Dobriyan REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adjust_operations), 3171a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 317228a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 3173631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 317426ec3c64SAl Viro REG("sessionid", S_IRUGO, proc_sessionid_operations), 317528a6d671SEric W. Biederman #endif 3176f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 3177631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 3178f4f154fdSAkinobu Mita #endif 3179297c5d92SAndrea Righi #ifdef CONFIG_TASK_IO_ACCOUNTING 3180631f9c18SAlexey Dobriyan INF("io", S_IRUGO, proc_tid_io_accounting), 3181297c5d92SAndrea Righi #endif 318228a6d671SEric W. Biederman }; 318328a6d671SEric W. Biederman 318428a6d671SEric W. Biederman static int proc_tid_base_readdir(struct file * filp, 318528a6d671SEric W. Biederman void * dirent, filldir_t filldir) 318628a6d671SEric W. Biederman { 318728a6d671SEric W. Biederman return proc_pident_readdir(filp,dirent,filldir, 318828a6d671SEric W. Biederman tid_base_stuff,ARRAY_SIZE(tid_base_stuff)); 318928a6d671SEric W. Biederman } 319028a6d671SEric W. Biederman 319128a6d671SEric W. Biederman static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 31927bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 31937bcd6b0eSEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 319428a6d671SEric W. Biederman } 319528a6d671SEric W. Biederman 319600977a59SArjan van de Ven static const struct file_operations proc_tid_base_operations = { 319728a6d671SEric W. Biederman .read = generic_read_dir, 319828a6d671SEric W. Biederman .readdir = proc_tid_base_readdir, 31996038f373SArnd Bergmann .llseek = default_llseek, 320028a6d671SEric W. Biederman }; 320128a6d671SEric W. Biederman 3202c5ef1c42SArjan van de Ven static const struct inode_operations proc_tid_base_inode_operations = { 320328a6d671SEric W. Biederman .lookup = proc_tid_base_lookup, 320428a6d671SEric W. Biederman .getattr = pid_getattr, 320528a6d671SEric W. Biederman .setattr = proc_setattr, 320628a6d671SEric W. Biederman }; 320728a6d671SEric W. Biederman 3208444ceed8SEric W. Biederman static struct dentry *proc_task_instantiate(struct inode *dir, 3209c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 3210444ceed8SEric W. Biederman { 3211444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-ENOENT); 3212444ceed8SEric W. Biederman struct inode *inode; 321361a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 3214444ceed8SEric W. Biederman 3215444ceed8SEric W. Biederman if (!inode) 3216444ceed8SEric W. Biederman goto out; 3217444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 3218444ceed8SEric W. Biederman inode->i_op = &proc_tid_base_inode_operations; 3219444ceed8SEric W. Biederman inode->i_fop = &proc_tid_base_operations; 3220444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 3221aed54175SVegard Nossum 3222aed54175SVegard Nossum inode->i_nlink = 2 + pid_entry_count_dirs(tid_base_stuff, 3223aed54175SVegard Nossum ARRAY_SIZE(tid_base_stuff)); 3224444ceed8SEric W. Biederman 3225fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 3226444ceed8SEric W. Biederman 3227444ceed8SEric W. Biederman d_add(dentry, inode); 3228444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 3229444ceed8SEric W. Biederman if (pid_revalidate(dentry, NULL)) 3230444ceed8SEric W. Biederman error = NULL; 3231444ceed8SEric W. Biederman out: 3232444ceed8SEric W. Biederman return error; 3233444ceed8SEric W. Biederman } 3234444ceed8SEric W. Biederman 323528a6d671SEric W. Biederman static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 323628a6d671SEric W. Biederman { 323728a6d671SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 323828a6d671SEric W. Biederman struct task_struct *task; 323928a6d671SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 324028a6d671SEric W. Biederman unsigned tid; 3241b488893aSPavel Emelyanov struct pid_namespace *ns; 324228a6d671SEric W. Biederman 324328a6d671SEric W. Biederman if (!leader) 324428a6d671SEric W. Biederman goto out_no_task; 324528a6d671SEric W. Biederman 324628a6d671SEric W. Biederman tid = name_to_int(dentry); 324728a6d671SEric W. Biederman if (tid == ~0U) 324828a6d671SEric W. Biederman goto out; 324928a6d671SEric W. Biederman 3250b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 325128a6d671SEric W. Biederman rcu_read_lock(); 3252b488893aSPavel Emelyanov task = find_task_by_pid_ns(tid, ns); 325328a6d671SEric W. Biederman if (task) 325428a6d671SEric W. Biederman get_task_struct(task); 325528a6d671SEric W. Biederman rcu_read_unlock(); 325628a6d671SEric W. Biederman if (!task) 325728a6d671SEric W. Biederman goto out; 3258bac0abd6SPavel Emelyanov if (!same_thread_group(leader, task)) 325928a6d671SEric W. Biederman goto out_drop_task; 326028a6d671SEric W. Biederman 3261444ceed8SEric W. Biederman result = proc_task_instantiate(dir, dentry, task, NULL); 326228a6d671SEric W. Biederman out_drop_task: 326328a6d671SEric W. Biederman put_task_struct(task); 326428a6d671SEric W. Biederman out: 326528a6d671SEric W. Biederman put_task_struct(leader); 326628a6d671SEric W. Biederman out_no_task: 326728a6d671SEric W. Biederman return result; 326828a6d671SEric W. Biederman } 326928a6d671SEric W. Biederman 327028a6d671SEric W. Biederman /* 32710bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 32720bc58a91SEric W. Biederman * 32730bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 32740bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 32750bc58a91SEric W. Biederman * directory we have more work todo. 32760bc58a91SEric W. Biederman * 32770bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 32780bc58a91SEric W. Biederman * 32790bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 32800bc58a91SEric W. Biederman * threads past it. 32810bc58a91SEric W. Biederman */ 3282cc288738SEric W. Biederman static struct task_struct *first_tid(struct task_struct *leader, 3283b488893aSPavel Emelyanov int tid, int nr, struct pid_namespace *ns) 32840bc58a91SEric W. Biederman { 3285a872ff0cSOleg Nesterov struct task_struct *pos; 32860bc58a91SEric W. Biederman 3287cc288738SEric W. Biederman rcu_read_lock(); 32880bc58a91SEric W. Biederman /* Attempt to start with the pid of a thread */ 32890bc58a91SEric W. Biederman if (tid && (nr > 0)) { 3290b488893aSPavel Emelyanov pos = find_task_by_pid_ns(tid, ns); 3291a872ff0cSOleg Nesterov if (pos && (pos->group_leader == leader)) 3292a872ff0cSOleg Nesterov goto found; 32930bc58a91SEric W. Biederman } 32940bc58a91SEric W. Biederman 32950bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 32960bc58a91SEric W. Biederman pos = NULL; 3297a872ff0cSOleg Nesterov if (nr && nr >= get_nr_threads(leader)) 3298a872ff0cSOleg Nesterov goto out; 3299a872ff0cSOleg Nesterov 3300a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 3301a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 3302a872ff0cSOleg Nesterov */ 3303a872ff0cSOleg Nesterov for (pos = leader; nr > 0; --nr) { 3304a872ff0cSOleg Nesterov pos = next_thread(pos); 3305a872ff0cSOleg Nesterov if (pos == leader) { 3306a872ff0cSOleg Nesterov pos = NULL; 3307a872ff0cSOleg Nesterov goto out; 3308a872ff0cSOleg Nesterov } 3309a872ff0cSOleg Nesterov } 3310a872ff0cSOleg Nesterov found: 3311a872ff0cSOleg Nesterov get_task_struct(pos); 3312a872ff0cSOleg Nesterov out: 3313cc288738SEric W. Biederman rcu_read_unlock(); 33140bc58a91SEric W. Biederman return pos; 33150bc58a91SEric W. Biederman } 33160bc58a91SEric W. Biederman 33170bc58a91SEric W. Biederman /* 33180bc58a91SEric W. Biederman * Find the next thread in the thread list. 33190bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 33200bc58a91SEric W. Biederman * 33210bc58a91SEric W. Biederman * The reference to the input task_struct is released. 33220bc58a91SEric W. Biederman */ 33230bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 33240bc58a91SEric W. Biederman { 3325c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 3326cc288738SEric W. Biederman rcu_read_lock(); 3327c1df7fb8SOleg Nesterov if (pid_alive(start)) { 33280bc58a91SEric W. Biederman pos = next_thread(start); 3329c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 33300bc58a91SEric W. Biederman pos = NULL; 3331c1df7fb8SOleg Nesterov else 3332c1df7fb8SOleg Nesterov get_task_struct(pos); 3333c1df7fb8SOleg Nesterov } 3334cc288738SEric W. Biederman rcu_read_unlock(); 33350bc58a91SEric W. Biederman put_task_struct(start); 33360bc58a91SEric W. Biederman return pos; 33370bc58a91SEric W. Biederman } 33380bc58a91SEric W. Biederman 333961a28784SEric W. Biederman static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir, 334061a28784SEric W. Biederman struct task_struct *task, int tid) 334161a28784SEric W. Biederman { 334261a28784SEric W. Biederman char name[PROC_NUMBUF]; 334361a28784SEric W. Biederman int len = snprintf(name, sizeof(name), "%d", tid); 334461a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, name, len, 334561a28784SEric W. Biederman proc_task_instantiate, task, NULL); 334661a28784SEric W. Biederman } 334761a28784SEric W. Biederman 33481da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 33491da177e4SLinus Torvalds static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir) 33501da177e4SLinus Torvalds { 33512fddfeefSJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 33521da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 33537d895244SGuillaume Chazarain struct task_struct *leader = NULL; 33540bc58a91SEric W. Biederman struct task_struct *task; 33551da177e4SLinus Torvalds int retval = -ENOENT; 33561da177e4SLinus Torvalds ino_t ino; 33570bc58a91SEric W. Biederman int tid; 3358b488893aSPavel Emelyanov struct pid_namespace *ns; 33591da177e4SLinus Torvalds 33607d895244SGuillaume Chazarain task = get_proc_task(inode); 33617d895244SGuillaume Chazarain if (!task) 33627d895244SGuillaume Chazarain goto out_no_task; 33637d895244SGuillaume Chazarain rcu_read_lock(); 33647d895244SGuillaume Chazarain if (pid_alive(task)) { 33657d895244SGuillaume Chazarain leader = task->group_leader; 33667d895244SGuillaume Chazarain get_task_struct(leader); 33677d895244SGuillaume Chazarain } 33687d895244SGuillaume Chazarain rcu_read_unlock(); 33697d895244SGuillaume Chazarain put_task_struct(task); 337099f89551SEric W. Biederman if (!leader) 337199f89551SEric W. Biederman goto out_no_task; 33721da177e4SLinus Torvalds retval = 0; 33731da177e4SLinus Torvalds 3374ee568b25SLinus Torvalds switch ((unsigned long)filp->f_pos) { 33751da177e4SLinus Torvalds case 0: 33761da177e4SLinus Torvalds ino = inode->i_ino; 3377ee6f779bSZhang Le if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) < 0) 33781da177e4SLinus Torvalds goto out; 3379ee6f779bSZhang Le filp->f_pos++; 33801da177e4SLinus Torvalds /* fall through */ 33811da177e4SLinus Torvalds case 1: 33821da177e4SLinus Torvalds ino = parent_ino(dentry); 3383ee6f779bSZhang Le if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) < 0) 33841da177e4SLinus Torvalds goto out; 3385ee6f779bSZhang Le filp->f_pos++; 33861da177e4SLinus Torvalds /* fall through */ 33871da177e4SLinus Torvalds } 33881da177e4SLinus Torvalds 33890bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 33900bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 33910bc58a91SEric W. Biederman */ 3392b488893aSPavel Emelyanov ns = filp->f_dentry->d_sb->s_fs_info; 33932b47c361SMathieu Desnoyers tid = (int)filp->f_version; 33940bc58a91SEric W. Biederman filp->f_version = 0; 3395ee6f779bSZhang Le for (task = first_tid(leader, tid, filp->f_pos - 2, ns); 33960bc58a91SEric W. Biederman task; 3397ee6f779bSZhang Le task = next_tid(task), filp->f_pos++) { 3398b488893aSPavel Emelyanov tid = task_pid_nr_ns(task, ns); 339961a28784SEric W. Biederman if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) { 34000bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 34010bc58a91SEric W. Biederman * pid for the next readir call */ 34022b47c361SMathieu Desnoyers filp->f_version = (u64)tid; 34030bc58a91SEric W. Biederman put_task_struct(task); 34041da177e4SLinus Torvalds break; 34050bc58a91SEric W. Biederman } 34061da177e4SLinus Torvalds } 34071da177e4SLinus Torvalds out: 340899f89551SEric W. Biederman put_task_struct(leader); 340999f89551SEric W. Biederman out_no_task: 34101da177e4SLinus Torvalds return retval; 34111da177e4SLinus Torvalds } 34126e66b52bSEric W. Biederman 34136e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 34146e66b52bSEric W. Biederman { 34156e66b52bSEric W. Biederman struct inode *inode = dentry->d_inode; 341699f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 34176e66b52bSEric W. Biederman generic_fillattr(inode, stat); 34186e66b52bSEric W. Biederman 341999f89551SEric W. Biederman if (p) { 342099f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 342199f89551SEric W. Biederman put_task_struct(p); 34226e66b52bSEric W. Biederman } 34236e66b52bSEric W. Biederman 34246e66b52bSEric W. Biederman return 0; 34256e66b52bSEric W. Biederman } 342628a6d671SEric W. Biederman 3427c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations = { 342828a6d671SEric W. Biederman .lookup = proc_task_lookup, 342928a6d671SEric W. Biederman .getattr = proc_task_getattr, 343028a6d671SEric W. Biederman .setattr = proc_setattr, 343128a6d671SEric W. Biederman }; 343228a6d671SEric W. Biederman 343300977a59SArjan van de Ven static const struct file_operations proc_task_operations = { 343428a6d671SEric W. Biederman .read = generic_read_dir, 343528a6d671SEric W. Biederman .readdir = proc_task_readdir, 34366038f373SArnd Bergmann .llseek = default_llseek, 343728a6d671SEric W. Biederman }; 3438