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> 66b835996fSDipankar Sarma #include <linux/rcupdate.h> 671da177e4SLinus Torvalds #include <linux/kallsyms.h> 68d85f50d5SNeil Horman #include <linux/resource.h> 695096add8SKees Cook #include <linux/module.h> 701da177e4SLinus Torvalds #include <linux/mount.h> 711da177e4SLinus Torvalds #include <linux/security.h> 721da177e4SLinus Torvalds #include <linux/ptrace.h> 730d094efeSRoland McGrath #include <linux/tracehook.h> 74a424316cSPaul Menage #include <linux/cgroup.h> 751da177e4SLinus Torvalds #include <linux/cpuset.h> 761da177e4SLinus Torvalds #include <linux/audit.h> 775addc5ddSAl Viro #include <linux/poll.h> 781651e14eSSerge E. Hallyn #include <linux/nsproxy.h> 798ac773b4SAlexey Dobriyan #include <linux/oom.h> 803cb4a0bbSKawai, Hidehiro #include <linux/elf.h> 8160347f67SPavel Emelyanov #include <linux/pid_namespace.h> 821da177e4SLinus Torvalds #include "internal.h" 831da177e4SLinus Torvalds 840f2fe20fSEric W. Biederman /* NOTE: 850f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 860f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 870f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 880f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 890f2fe20fSEric W. Biederman * 900f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 910f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 920f2fe20fSEric W. Biederman */ 930f2fe20fSEric W. Biederman 941da177e4SLinus Torvalds struct pid_entry { 951da177e4SLinus Torvalds char *name; 96c5141e6dSEric Dumazet int len; 971da177e4SLinus Torvalds mode_t mode; 98c5ef1c42SArjan van de Ven const struct inode_operations *iop; 9900977a59SArjan van de Ven const struct file_operations *fop; 10020cdc894SEric W. Biederman union proc_op op; 1011da177e4SLinus Torvalds }; 1021da177e4SLinus Torvalds 10361a28784SEric W. Biederman #define NOD(NAME, MODE, IOP, FOP, OP) { \ 10420cdc894SEric W. Biederman .name = (NAME), \ 105c5141e6dSEric Dumazet .len = sizeof(NAME) - 1, \ 10620cdc894SEric W. Biederman .mode = MODE, \ 10720cdc894SEric W. Biederman .iop = IOP, \ 10820cdc894SEric W. Biederman .fop = FOP, \ 10920cdc894SEric W. Biederman .op = OP, \ 11020cdc894SEric W. Biederman } 11120cdc894SEric W. Biederman 112*631f9c18SAlexey Dobriyan #define DIR(NAME, MODE, iops, fops) \ 113*631f9c18SAlexey Dobriyan NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} ) 114*631f9c18SAlexey Dobriyan #define LNK(NAME, get_link) \ 11561a28784SEric W. Biederman NOD(NAME, (S_IFLNK|S_IRWXUGO), \ 11620cdc894SEric W. Biederman &proc_pid_link_inode_operations, NULL, \ 117*631f9c18SAlexey Dobriyan { .proc_get_link = get_link } ) 118*631f9c18SAlexey Dobriyan #define REG(NAME, MODE, fops) \ 119*631f9c18SAlexey Dobriyan NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {}) 120*631f9c18SAlexey Dobriyan #define INF(NAME, MODE, read) \ 12161a28784SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 12220cdc894SEric W. Biederman NULL, &proc_info_file_operations, \ 123*631f9c18SAlexey Dobriyan { .proc_read = read } ) 124*631f9c18SAlexey Dobriyan #define ONE(NAME, MODE, show) \ 125be614086SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 126be614086SEric W. Biederman NULL, &proc_single_file_operations, \ 127*631f9c18SAlexey Dobriyan { .proc_show = show } ) 1281da177e4SLinus Torvalds 129aed54175SVegard Nossum /* 130aed54175SVegard Nossum * Count the number of hardlinks for the pid_entry table, excluding the . 131aed54175SVegard Nossum * and .. links. 132aed54175SVegard Nossum */ 133aed54175SVegard Nossum static unsigned int pid_entry_count_dirs(const struct pid_entry *entries, 134aed54175SVegard Nossum unsigned int n) 135aed54175SVegard Nossum { 136aed54175SVegard Nossum unsigned int i; 137aed54175SVegard Nossum unsigned int count; 138aed54175SVegard Nossum 139aed54175SVegard Nossum count = 0; 140aed54175SVegard Nossum for (i = 0; i < n; ++i) { 141aed54175SVegard Nossum if (S_ISDIR(entries[i].mode)) 142aed54175SVegard Nossum ++count; 143aed54175SVegard Nossum } 144aed54175SVegard Nossum 145aed54175SVegard Nossum return count; 146aed54175SVegard Nossum } 147aed54175SVegard Nossum 1480494f6ecSMiklos Szeredi static struct fs_struct *get_fs_struct(struct task_struct *task) 1491da177e4SLinus Torvalds { 1501da177e4SLinus Torvalds struct fs_struct *fs; 1510494f6ecSMiklos Szeredi task_lock(task); 1520494f6ecSMiklos Szeredi fs = task->fs; 1531da177e4SLinus Torvalds if(fs) 1541da177e4SLinus Torvalds atomic_inc(&fs->count); 1550494f6ecSMiklos Szeredi task_unlock(task); 1560494f6ecSMiklos Szeredi return fs; 1570494f6ecSMiklos Szeredi } 1580494f6ecSMiklos Szeredi 15999f89551SEric W. Biederman static int get_nr_threads(struct task_struct *tsk) 16099f89551SEric W. Biederman { 16199f89551SEric W. Biederman unsigned long flags; 16299f89551SEric W. Biederman int count = 0; 16399f89551SEric W. Biederman 16499f89551SEric W. Biederman if (lock_task_sighand(tsk, &flags)) { 16599f89551SEric W. Biederman count = atomic_read(&tsk->signal->count); 16699f89551SEric W. Biederman unlock_task_sighand(tsk, &flags); 16799f89551SEric W. Biederman } 16899f89551SEric W. Biederman return count; 16999f89551SEric W. Biederman } 17099f89551SEric W. Biederman 1713dcd25f3SJan Blunck static int proc_cwd_link(struct inode *inode, struct path *path) 1720494f6ecSMiklos Szeredi { 17399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 17499f89551SEric W. Biederman struct fs_struct *fs = NULL; 1750494f6ecSMiklos Szeredi int result = -ENOENT; 17699f89551SEric W. Biederman 17799f89551SEric W. Biederman if (task) { 17899f89551SEric W. Biederman fs = get_fs_struct(task); 17999f89551SEric W. Biederman put_task_struct(task); 18099f89551SEric W. Biederman } 1811da177e4SLinus Torvalds if (fs) { 1821da177e4SLinus Torvalds read_lock(&fs->lock); 1833dcd25f3SJan Blunck *path = fs->pwd; 1843dcd25f3SJan Blunck path_get(&fs->pwd); 1851da177e4SLinus Torvalds read_unlock(&fs->lock); 1861da177e4SLinus Torvalds result = 0; 1871da177e4SLinus Torvalds put_fs_struct(fs); 1881da177e4SLinus Torvalds } 1891da177e4SLinus Torvalds return result; 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1923dcd25f3SJan Blunck static int proc_root_link(struct inode *inode, struct path *path) 1931da177e4SLinus Torvalds { 19499f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 19599f89551SEric W. Biederman struct fs_struct *fs = NULL; 1961da177e4SLinus Torvalds int result = -ENOENT; 19799f89551SEric W. Biederman 19899f89551SEric W. Biederman if (task) { 19999f89551SEric W. Biederman fs = get_fs_struct(task); 20099f89551SEric W. Biederman put_task_struct(task); 20199f89551SEric W. Biederman } 2021da177e4SLinus Torvalds if (fs) { 2031da177e4SLinus Torvalds read_lock(&fs->lock); 2043dcd25f3SJan Blunck *path = fs->root; 2053dcd25f3SJan Blunck path_get(&fs->root); 2061da177e4SLinus Torvalds read_unlock(&fs->lock); 2071da177e4SLinus Torvalds result = 0; 2081da177e4SLinus Torvalds put_fs_struct(fs); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds return result; 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds 213638fa202SRoland McGrath /* 214638fa202SRoland McGrath * Return zero if current may access user memory in @task, -error if not. 215638fa202SRoland McGrath */ 216638fa202SRoland McGrath static int check_mem_permission(struct task_struct *task) 217638fa202SRoland McGrath { 218638fa202SRoland McGrath /* 219638fa202SRoland McGrath * A task can always look at itself, in case it chooses 220638fa202SRoland McGrath * to use system calls instead of load instructions. 221638fa202SRoland McGrath */ 222638fa202SRoland McGrath if (task == current) 223638fa202SRoland McGrath return 0; 224638fa202SRoland McGrath 225638fa202SRoland McGrath /* 226638fa202SRoland McGrath * If current is actively ptrace'ing, and would also be 227638fa202SRoland McGrath * permitted to freshly attach with ptrace now, permit it. 228638fa202SRoland McGrath */ 2290d094efeSRoland McGrath if (task_is_stopped_or_traced(task)) { 2300d094efeSRoland McGrath int match; 2310d094efeSRoland McGrath rcu_read_lock(); 2320d094efeSRoland McGrath match = (tracehook_tracer_task(task) == current); 2330d094efeSRoland McGrath rcu_read_unlock(); 2340d094efeSRoland McGrath if (match && ptrace_may_access(task, PTRACE_MODE_ATTACH)) 235638fa202SRoland McGrath return 0; 2360d094efeSRoland McGrath } 237638fa202SRoland McGrath 238638fa202SRoland McGrath /* 239638fa202SRoland McGrath * Noone else is allowed. 240638fa202SRoland McGrath */ 241638fa202SRoland McGrath return -EPERM; 242638fa202SRoland McGrath } 2431da177e4SLinus Torvalds 244831830b5SAl Viro struct mm_struct *mm_for_maps(struct task_struct *task) 245831830b5SAl Viro { 246831830b5SAl Viro struct mm_struct *mm = get_task_mm(task); 247831830b5SAl Viro if (!mm) 248831830b5SAl Viro return NULL; 249831830b5SAl Viro down_read(&mm->mmap_sem); 250831830b5SAl Viro task_lock(task); 251831830b5SAl Viro if (task->mm != mm) 252831830b5SAl Viro goto out; 253006ebb40SStephen Smalley if (task->mm != current->mm && 254006ebb40SStephen Smalley __ptrace_may_access(task, PTRACE_MODE_READ) < 0) 255831830b5SAl Viro goto out; 256831830b5SAl Viro task_unlock(task); 257831830b5SAl Viro return mm; 258831830b5SAl Viro out: 259831830b5SAl Viro task_unlock(task); 260831830b5SAl Viro up_read(&mm->mmap_sem); 261831830b5SAl Viro mmput(mm); 262831830b5SAl Viro return NULL; 263831830b5SAl Viro } 264831830b5SAl Viro 2651da177e4SLinus Torvalds static int proc_pid_cmdline(struct task_struct *task, char * buffer) 2661da177e4SLinus Torvalds { 2671da177e4SLinus Torvalds int res = 0; 2681da177e4SLinus Torvalds unsigned int len; 2691da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 2701da177e4SLinus Torvalds if (!mm) 2711da177e4SLinus Torvalds goto out; 2721da177e4SLinus Torvalds if (!mm->arg_end) 2731da177e4SLinus Torvalds goto out_mm; /* Shh! No looking before we're done */ 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds len = mm->arg_end - mm->arg_start; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds if (len > PAGE_SIZE) 2781da177e4SLinus Torvalds len = PAGE_SIZE; 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds res = access_process_vm(task, mm->arg_start, buffer, len, 0); 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds // If the nul at the end of args has been overwritten, then 2831da177e4SLinus Torvalds // assume application is using setproctitle(3). 2841da177e4SLinus Torvalds if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) { 2851da177e4SLinus Torvalds len = strnlen(buffer, res); 2861da177e4SLinus Torvalds if (len < res) { 2871da177e4SLinus Torvalds res = len; 2881da177e4SLinus Torvalds } else { 2891da177e4SLinus Torvalds len = mm->env_end - mm->env_start; 2901da177e4SLinus Torvalds if (len > PAGE_SIZE - res) 2911da177e4SLinus Torvalds len = PAGE_SIZE - res; 2921da177e4SLinus Torvalds res += access_process_vm(task, mm->env_start, buffer+res, len, 0); 2931da177e4SLinus Torvalds res = strnlen(buffer, res); 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds out_mm: 2971da177e4SLinus Torvalds mmput(mm); 2981da177e4SLinus Torvalds out: 2991da177e4SLinus Torvalds return res; 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds static int proc_pid_auxv(struct task_struct *task, char *buffer) 3031da177e4SLinus Torvalds { 3041da177e4SLinus Torvalds int res = 0; 3051da177e4SLinus Torvalds struct mm_struct *mm = get_task_mm(task); 3061da177e4SLinus Torvalds if (mm) { 3071da177e4SLinus Torvalds unsigned int nwords = 0; 3081da177e4SLinus Torvalds do 3091da177e4SLinus Torvalds nwords += 2; 3101da177e4SLinus Torvalds while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 3111da177e4SLinus Torvalds res = nwords * sizeof(mm->saved_auxv[0]); 3121da177e4SLinus Torvalds if (res > PAGE_SIZE) 3131da177e4SLinus Torvalds res = PAGE_SIZE; 3141da177e4SLinus Torvalds memcpy(buffer, mm->saved_auxv, res); 3151da177e4SLinus Torvalds mmput(mm); 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds return res; 3181da177e4SLinus Torvalds } 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 3221da177e4SLinus Torvalds /* 3231da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 3241da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 3251da177e4SLinus Torvalds */ 3261da177e4SLinus Torvalds static int proc_pid_wchan(struct task_struct *task, char *buffer) 3271da177e4SLinus Torvalds { 328ffb45122SAlexey Dobriyan unsigned long wchan; 3299281aceaSTejun Heo char symname[KSYM_NAME_LEN]; 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds wchan = get_wchan(task); 3321da177e4SLinus Torvalds 3339d65cb4aSAlexey Dobriyan if (lookup_symbol_name(wchan, symname) < 0) 3341da177e4SLinus Torvalds return sprintf(buffer, "%lu", wchan); 3359d65cb4aSAlexey Dobriyan else 3369d65cb4aSAlexey Dobriyan return sprintf(buffer, "%s", symname); 3371da177e4SLinus Torvalds } 3381da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 3411da177e4SLinus Torvalds /* 3421da177e4SLinus Torvalds * Provides /proc/PID/schedstat 3431da177e4SLinus Torvalds */ 3441da177e4SLinus Torvalds static int proc_pid_schedstat(struct task_struct *task, char *buffer) 3451da177e4SLinus Torvalds { 346172ba844SBalbir Singh return sprintf(buffer, "%llu %llu %lu\n", 347826e08b0SIngo Molnar (unsigned long long)task->se.sum_exec_runtime, 348826e08b0SIngo Molnar (unsigned long long)task->sched_info.run_delay, 3492d72376bSIngo Molnar task->sched_info.pcount); 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds #endif 3521da177e4SLinus Torvalds 3539745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3549745512cSArjan van de Ven static int lstats_show_proc(struct seq_file *m, void *v) 3559745512cSArjan van de Ven { 3569745512cSArjan van de Ven int i; 35713d77c37SHiroshi Shimamoto struct inode *inode = m->private; 35813d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(inode); 3599745512cSArjan van de Ven 36013d77c37SHiroshi Shimamoto if (!task) 36113d77c37SHiroshi Shimamoto return -ESRCH; 36213d77c37SHiroshi Shimamoto seq_puts(m, "Latency Top version : v0.1\n"); 3639745512cSArjan van de Ven for (i = 0; i < 32; i++) { 3649745512cSArjan van de Ven if (task->latency_record[i].backtrace[0]) { 3659745512cSArjan van de Ven int q; 3669745512cSArjan van de Ven seq_printf(m, "%i %li %li ", 3679745512cSArjan van de Ven task->latency_record[i].count, 3689745512cSArjan van de Ven task->latency_record[i].time, 3699745512cSArjan van de Ven task->latency_record[i].max); 3709745512cSArjan van de Ven for (q = 0; q < LT_BACKTRACEDEPTH; q++) { 3719c246247SHugh Dickins char sym[KSYM_SYMBOL_LEN]; 3729745512cSArjan van de Ven char *c; 3739745512cSArjan van de Ven if (!task->latency_record[i].backtrace[q]) 3749745512cSArjan van de Ven break; 3759745512cSArjan van de Ven if (task->latency_record[i].backtrace[q] == ULONG_MAX) 3769745512cSArjan van de Ven break; 3779745512cSArjan van de Ven sprint_symbol(sym, task->latency_record[i].backtrace[q]); 3789745512cSArjan van de Ven c = strchr(sym, '+'); 3799745512cSArjan van de Ven if (c) 3809745512cSArjan van de Ven *c = 0; 3819745512cSArjan van de Ven seq_printf(m, "%s ", sym); 3829745512cSArjan van de Ven } 3839745512cSArjan van de Ven seq_printf(m, "\n"); 3849745512cSArjan van de Ven } 3859745512cSArjan van de Ven 3869745512cSArjan van de Ven } 38713d77c37SHiroshi Shimamoto put_task_struct(task); 3889745512cSArjan van de Ven return 0; 3899745512cSArjan van de Ven } 3909745512cSArjan van de Ven 3919745512cSArjan van de Ven static int lstats_open(struct inode *inode, struct file *file) 3929745512cSArjan van de Ven { 39313d77c37SHiroshi Shimamoto return single_open(file, lstats_show_proc, inode); 394d6643d12SHiroshi Shimamoto } 395d6643d12SHiroshi Shimamoto 3969745512cSArjan van de Ven static ssize_t lstats_write(struct file *file, const char __user *buf, 3979745512cSArjan van de Ven size_t count, loff_t *offs) 3989745512cSArjan van de Ven { 39913d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 4009745512cSArjan van de Ven 40113d77c37SHiroshi Shimamoto if (!task) 40213d77c37SHiroshi Shimamoto return -ESRCH; 4039745512cSArjan van de Ven clear_all_latency_tracing(task); 40413d77c37SHiroshi Shimamoto put_task_struct(task); 4059745512cSArjan van de Ven 4069745512cSArjan van de Ven return count; 4079745512cSArjan van de Ven } 4089745512cSArjan van de Ven 4099745512cSArjan van de Ven static const struct file_operations proc_lstats_operations = { 4109745512cSArjan van de Ven .open = lstats_open, 4119745512cSArjan van de Ven .read = seq_read, 4129745512cSArjan van de Ven .write = lstats_write, 4139745512cSArjan van de Ven .llseek = seq_lseek, 41413d77c37SHiroshi Shimamoto .release = single_release, 4159745512cSArjan van de Ven }; 4169745512cSArjan van de Ven 4179745512cSArjan van de Ven #endif 4189745512cSArjan van de Ven 4191da177e4SLinus Torvalds /* The badness from the OOM killer */ 4201da177e4SLinus Torvalds unsigned long badness(struct task_struct *p, unsigned long uptime); 4211da177e4SLinus Torvalds static int proc_oom_score(struct task_struct *task, char *buffer) 4221da177e4SLinus Torvalds { 4231da177e4SLinus Torvalds unsigned long points; 4241da177e4SLinus Torvalds struct timespec uptime; 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds do_posix_clock_monotonic_gettime(&uptime); 42719c5d45aSAlexey Dobriyan read_lock(&tasklist_lock); 4281da177e4SLinus Torvalds points = badness(task, uptime.tv_sec); 42919c5d45aSAlexey Dobriyan read_unlock(&tasklist_lock); 4301da177e4SLinus Torvalds return sprintf(buffer, "%lu\n", points); 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 433d85f50d5SNeil Horman struct limit_names { 434d85f50d5SNeil Horman char *name; 435d85f50d5SNeil Horman char *unit; 436d85f50d5SNeil Horman }; 437d85f50d5SNeil Horman 438d85f50d5SNeil Horman static const struct limit_names lnames[RLIM_NLIMITS] = { 439d85f50d5SNeil Horman [RLIMIT_CPU] = {"Max cpu time", "ms"}, 440d85f50d5SNeil Horman [RLIMIT_FSIZE] = {"Max file size", "bytes"}, 441d85f50d5SNeil Horman [RLIMIT_DATA] = {"Max data size", "bytes"}, 442d85f50d5SNeil Horman [RLIMIT_STACK] = {"Max stack size", "bytes"}, 443d85f50d5SNeil Horman [RLIMIT_CORE] = {"Max core file size", "bytes"}, 444d85f50d5SNeil Horman [RLIMIT_RSS] = {"Max resident set", "bytes"}, 445d85f50d5SNeil Horman [RLIMIT_NPROC] = {"Max processes", "processes"}, 446d85f50d5SNeil Horman [RLIMIT_NOFILE] = {"Max open files", "files"}, 447d85f50d5SNeil Horman [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"}, 448d85f50d5SNeil Horman [RLIMIT_AS] = {"Max address space", "bytes"}, 449d85f50d5SNeil Horman [RLIMIT_LOCKS] = {"Max file locks", "locks"}, 450d85f50d5SNeil Horman [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"}, 451d85f50d5SNeil Horman [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"}, 452d85f50d5SNeil Horman [RLIMIT_NICE] = {"Max nice priority", NULL}, 453d85f50d5SNeil Horman [RLIMIT_RTPRIO] = {"Max realtime priority", NULL}, 4548808117cSEugene Teo [RLIMIT_RTTIME] = {"Max realtime timeout", "us"}, 455d85f50d5SNeil Horman }; 456d85f50d5SNeil Horman 457d85f50d5SNeil Horman /* Display limits for a process */ 458d85f50d5SNeil Horman static int proc_pid_limits(struct task_struct *task, char *buffer) 459d85f50d5SNeil Horman { 460d85f50d5SNeil Horman unsigned int i; 461d85f50d5SNeil Horman int count = 0; 462d85f50d5SNeil Horman unsigned long flags; 463d85f50d5SNeil Horman char *bufptr = buffer; 464d85f50d5SNeil Horman 465d85f50d5SNeil Horman struct rlimit rlim[RLIM_NLIMITS]; 466d85f50d5SNeil Horman 467a6bebbc8SLai Jiangshan if (!lock_task_sighand(task, &flags)) 468d85f50d5SNeil Horman return 0; 469d85f50d5SNeil Horman memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS); 470d85f50d5SNeil Horman unlock_task_sighand(task, &flags); 471d85f50d5SNeil Horman 472d85f50d5SNeil Horman /* 473d85f50d5SNeil Horman * print the file header 474d85f50d5SNeil Horman */ 475d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n", 476d85f50d5SNeil Horman "Limit", "Soft Limit", "Hard Limit", "Units"); 477d85f50d5SNeil Horman 478d85f50d5SNeil Horman for (i = 0; i < RLIM_NLIMITS; i++) { 479d85f50d5SNeil Horman if (rlim[i].rlim_cur == RLIM_INFINITY) 480d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-25s %-20s ", 481d85f50d5SNeil Horman lnames[i].name, "unlimited"); 482d85f50d5SNeil Horman else 483d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-25s %-20lu ", 484d85f50d5SNeil Horman lnames[i].name, rlim[i].rlim_cur); 485d85f50d5SNeil Horman 486d85f50d5SNeil Horman if (rlim[i].rlim_max == RLIM_INFINITY) 487d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-20s ", "unlimited"); 488d85f50d5SNeil Horman else 489d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-20lu ", 490d85f50d5SNeil Horman rlim[i].rlim_max); 491d85f50d5SNeil Horman 492d85f50d5SNeil Horman if (lnames[i].unit) 493d85f50d5SNeil Horman count += sprintf(&bufptr[count], "%-10s\n", 494d85f50d5SNeil Horman lnames[i].unit); 495d85f50d5SNeil Horman else 496d85f50d5SNeil Horman count += sprintf(&bufptr[count], "\n"); 497d85f50d5SNeil Horman } 498d85f50d5SNeil Horman 499d85f50d5SNeil Horman return count; 500d85f50d5SNeil Horman } 501d85f50d5SNeil Horman 502ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 503ebcb6734SRoland McGrath static int proc_pid_syscall(struct task_struct *task, char *buffer) 504ebcb6734SRoland McGrath { 505ebcb6734SRoland McGrath long nr; 506ebcb6734SRoland McGrath unsigned long args[6], sp, pc; 507ebcb6734SRoland McGrath 508ebcb6734SRoland McGrath if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) 509ebcb6734SRoland McGrath return sprintf(buffer, "running\n"); 510ebcb6734SRoland McGrath 511ebcb6734SRoland McGrath if (nr < 0) 512ebcb6734SRoland McGrath return sprintf(buffer, "%ld 0x%lx 0x%lx\n", nr, sp, pc); 513ebcb6734SRoland McGrath 514ebcb6734SRoland McGrath return sprintf(buffer, 515ebcb6734SRoland McGrath "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 516ebcb6734SRoland McGrath nr, 517ebcb6734SRoland McGrath args[0], args[1], args[2], args[3], args[4], args[5], 518ebcb6734SRoland McGrath sp, pc); 519ebcb6734SRoland McGrath } 520ebcb6734SRoland McGrath #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */ 521ebcb6734SRoland McGrath 5221da177e4SLinus Torvalds /************************************************************************/ 5231da177e4SLinus Torvalds /* Here the fs part begins */ 5241da177e4SLinus Torvalds /************************************************************************/ 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* permission checks */ 527778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 5281da177e4SLinus Torvalds { 529778c1144SEric W. Biederman struct task_struct *task; 530778c1144SEric W. Biederman int allowed = 0; 531df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 532df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 533df26c40eSEric W. Biederman * information. 534778c1144SEric W. Biederman */ 535778c1144SEric W. Biederman task = get_proc_task(inode); 536df26c40eSEric W. Biederman if (task) { 537006ebb40SStephen Smalley allowed = ptrace_may_access(task, PTRACE_MODE_READ); 538778c1144SEric W. Biederman put_task_struct(task); 539df26c40eSEric W. Biederman } 540778c1144SEric W. Biederman return allowed; 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds 5436d76fa58SLinus Torvalds static int proc_setattr(struct dentry *dentry, struct iattr *attr) 5446d76fa58SLinus Torvalds { 5456d76fa58SLinus Torvalds int error; 5466d76fa58SLinus Torvalds struct inode *inode = dentry->d_inode; 5476d76fa58SLinus Torvalds 5486d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 5496d76fa58SLinus Torvalds return -EPERM; 5506d76fa58SLinus Torvalds 5516d76fa58SLinus Torvalds error = inode_change_ok(inode, attr); 5526d76fa58SLinus Torvalds if (!error) 5536d76fa58SLinus Torvalds error = inode_setattr(inode, attr); 5546d76fa58SLinus Torvalds return error; 5556d76fa58SLinus Torvalds } 5566d76fa58SLinus Torvalds 557c5ef1c42SArjan van de Ven static const struct inode_operations proc_def_inode_operations = { 5586d76fa58SLinus Torvalds .setattr = proc_setattr, 5596d76fa58SLinus Torvalds }; 5606d76fa58SLinus Torvalds 561a1a2c409SMiklos Szeredi static int mounts_open_common(struct inode *inode, struct file *file, 562a1a2c409SMiklos Szeredi const struct seq_operations *op) 5631da177e4SLinus Torvalds { 56499f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 565cf7b708cSPavel Emelyanov struct nsproxy *nsp; 5666b3286edSKirill Korotaev struct mnt_namespace *ns = NULL; 567a1a2c409SMiklos Szeredi struct fs_struct *fs = NULL; 568a1a2c409SMiklos Szeredi struct path root; 5695addc5ddSAl Viro struct proc_mounts *p; 5705addc5ddSAl Viro int ret = -EINVAL; 5715addc5ddSAl Viro 57299f89551SEric W. Biederman if (task) { 573cf7b708cSPavel Emelyanov rcu_read_lock(); 574cf7b708cSPavel Emelyanov nsp = task_nsproxy(task); 575cf7b708cSPavel Emelyanov if (nsp) { 576cf7b708cSPavel Emelyanov ns = nsp->mnt_ns; 5776b3286edSKirill Korotaev if (ns) 5786b3286edSKirill Korotaev get_mnt_ns(ns); 579863c4702SAlexey Dobriyan } 580cf7b708cSPavel Emelyanov rcu_read_unlock(); 581a1a2c409SMiklos Szeredi if (ns) 582a1a2c409SMiklos Szeredi fs = get_fs_struct(task); 58399f89551SEric W. Biederman put_task_struct(task); 58499f89551SEric W. Biederman } 5851da177e4SLinus Torvalds 586a1a2c409SMiklos Szeredi if (!ns) 587a1a2c409SMiklos Szeredi goto err; 588a1a2c409SMiklos Szeredi if (!fs) 589a1a2c409SMiklos Szeredi goto err_put_ns; 590a1a2c409SMiklos Szeredi 591a1a2c409SMiklos Szeredi read_lock(&fs->lock); 592a1a2c409SMiklos Szeredi root = fs->root; 593a1a2c409SMiklos Szeredi path_get(&root); 594a1a2c409SMiklos Szeredi read_unlock(&fs->lock); 595a1a2c409SMiklos Szeredi put_fs_struct(fs); 596a1a2c409SMiklos Szeredi 5975addc5ddSAl Viro ret = -ENOMEM; 5985addc5ddSAl Viro p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); 599a1a2c409SMiklos Szeredi if (!p) 600a1a2c409SMiklos Szeredi goto err_put_path; 601a1a2c409SMiklos Szeredi 6025addc5ddSAl Viro file->private_data = &p->m; 603a1a2c409SMiklos Szeredi ret = seq_open(file, op); 604a1a2c409SMiklos Szeredi if (ret) 605a1a2c409SMiklos Szeredi goto err_free; 606a1a2c409SMiklos Szeredi 607a1a2c409SMiklos Szeredi p->m.private = p; 608a1a2c409SMiklos Szeredi p->ns = ns; 609a1a2c409SMiklos Szeredi p->root = root; 6106b3286edSKirill Korotaev p->event = ns->event; 611a1a2c409SMiklos Szeredi 6125addc5ddSAl Viro return 0; 613a1a2c409SMiklos Szeredi 614a1a2c409SMiklos Szeredi err_free: 6155addc5ddSAl Viro kfree(p); 616a1a2c409SMiklos Szeredi err_put_path: 617a1a2c409SMiklos Szeredi path_put(&root); 618a1a2c409SMiklos Szeredi err_put_ns: 6196b3286edSKirill Korotaev put_mnt_ns(ns); 620a1a2c409SMiklos Szeredi err: 6211da177e4SLinus Torvalds return ret; 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds static int mounts_release(struct inode *inode, struct file *file) 6251da177e4SLinus Torvalds { 626a1a2c409SMiklos Szeredi struct proc_mounts *p = file->private_data; 627a1a2c409SMiklos Szeredi path_put(&p->root); 628a1a2c409SMiklos Szeredi put_mnt_ns(p->ns); 6291da177e4SLinus Torvalds return seq_release(inode, file); 6301da177e4SLinus Torvalds } 6311da177e4SLinus Torvalds 6325addc5ddSAl Viro static unsigned mounts_poll(struct file *file, poll_table *wait) 6335addc5ddSAl Viro { 6345addc5ddSAl Viro struct proc_mounts *p = file->private_data; 635a1a2c409SMiklos Szeredi struct mnt_namespace *ns = p->ns; 6365addc5ddSAl Viro unsigned res = 0; 6375addc5ddSAl Viro 6385addc5ddSAl Viro poll_wait(file, &ns->poll, wait); 6395addc5ddSAl Viro 6405addc5ddSAl Viro spin_lock(&vfsmount_lock); 6415addc5ddSAl Viro if (p->event != ns->event) { 6425addc5ddSAl Viro p->event = ns->event; 6435addc5ddSAl Viro res = POLLERR; 6445addc5ddSAl Viro } 6455addc5ddSAl Viro spin_unlock(&vfsmount_lock); 6465addc5ddSAl Viro 6475addc5ddSAl Viro return res; 6485addc5ddSAl Viro } 6495addc5ddSAl Viro 650a1a2c409SMiklos Szeredi static int mounts_open(struct inode *inode, struct file *file) 651a1a2c409SMiklos Szeredi { 652a1a2c409SMiklos Szeredi return mounts_open_common(inode, file, &mounts_op); 653a1a2c409SMiklos Szeredi } 654a1a2c409SMiklos Szeredi 65500977a59SArjan van de Ven static const struct file_operations proc_mounts_operations = { 6561da177e4SLinus Torvalds .open = mounts_open, 6571da177e4SLinus Torvalds .read = seq_read, 6581da177e4SLinus Torvalds .llseek = seq_lseek, 6591da177e4SLinus Torvalds .release = mounts_release, 6605addc5ddSAl Viro .poll = mounts_poll, 6611da177e4SLinus Torvalds }; 6621da177e4SLinus Torvalds 6632d4d4864SRam Pai static int mountinfo_open(struct inode *inode, struct file *file) 6642d4d4864SRam Pai { 6652d4d4864SRam Pai return mounts_open_common(inode, file, &mountinfo_op); 6662d4d4864SRam Pai } 6672d4d4864SRam Pai 6682d4d4864SRam Pai static const struct file_operations proc_mountinfo_operations = { 6692d4d4864SRam Pai .open = mountinfo_open, 6702d4d4864SRam Pai .read = seq_read, 6712d4d4864SRam Pai .llseek = seq_lseek, 6722d4d4864SRam Pai .release = mounts_release, 6732d4d4864SRam Pai .poll = mounts_poll, 6742d4d4864SRam Pai }; 6752d4d4864SRam Pai 676b4629fe2SChuck Lever static int mountstats_open(struct inode *inode, struct file *file) 677b4629fe2SChuck Lever { 678a1a2c409SMiklos Szeredi return mounts_open_common(inode, file, &mountstats_op); 679b4629fe2SChuck Lever } 680b4629fe2SChuck Lever 68100977a59SArjan van de Ven static const struct file_operations proc_mountstats_operations = { 682b4629fe2SChuck Lever .open = mountstats_open, 683b4629fe2SChuck Lever .read = seq_read, 684b4629fe2SChuck Lever .llseek = seq_lseek, 685b4629fe2SChuck Lever .release = mounts_release, 686b4629fe2SChuck Lever }; 687b4629fe2SChuck Lever 6881da177e4SLinus Torvalds #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */ 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds static ssize_t proc_info_read(struct file * file, char __user * buf, 6911da177e4SLinus Torvalds size_t count, loff_t *ppos) 6921da177e4SLinus Torvalds { 6932fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 6941da177e4SLinus Torvalds unsigned long page; 6951da177e4SLinus Torvalds ssize_t length; 69699f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 69799f89551SEric W. Biederman 69899f89551SEric W. Biederman length = -ESRCH; 69999f89551SEric W. Biederman if (!task) 70099f89551SEric W. Biederman goto out_no_task; 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds if (count > PROC_BLOCK_SIZE) 7031da177e4SLinus Torvalds count = PROC_BLOCK_SIZE; 70499f89551SEric W. Biederman 70599f89551SEric W. Biederman length = -ENOMEM; 706e12ba74dSMel Gorman if (!(page = __get_free_page(GFP_TEMPORARY))) 70799f89551SEric W. Biederman goto out; 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds length = PROC_I(inode)->op.proc_read(task, (char*)page); 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds if (length >= 0) 7121da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 7131da177e4SLinus Torvalds free_page(page); 71499f89551SEric W. Biederman out: 71599f89551SEric W. Biederman put_task_struct(task); 71699f89551SEric W. Biederman out_no_task: 7171da177e4SLinus Torvalds return length; 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds 72000977a59SArjan van de Ven static const struct file_operations proc_info_file_operations = { 7211da177e4SLinus Torvalds .read = proc_info_read, 7221da177e4SLinus Torvalds }; 7231da177e4SLinus Torvalds 724be614086SEric W. Biederman static int proc_single_show(struct seq_file *m, void *v) 725be614086SEric W. Biederman { 726be614086SEric W. Biederman struct inode *inode = m->private; 727be614086SEric W. Biederman struct pid_namespace *ns; 728be614086SEric W. Biederman struct pid *pid; 729be614086SEric W. Biederman struct task_struct *task; 730be614086SEric W. Biederman int ret; 731be614086SEric W. Biederman 732be614086SEric W. Biederman ns = inode->i_sb->s_fs_info; 733be614086SEric W. Biederman pid = proc_pid(inode); 734be614086SEric W. Biederman task = get_pid_task(pid, PIDTYPE_PID); 735be614086SEric W. Biederman if (!task) 736be614086SEric W. Biederman return -ESRCH; 737be614086SEric W. Biederman 738be614086SEric W. Biederman ret = PROC_I(inode)->op.proc_show(m, ns, pid, task); 739be614086SEric W. Biederman 740be614086SEric W. Biederman put_task_struct(task); 741be614086SEric W. Biederman return ret; 742be614086SEric W. Biederman } 743be614086SEric W. Biederman 744be614086SEric W. Biederman static int proc_single_open(struct inode *inode, struct file *filp) 745be614086SEric W. Biederman { 746be614086SEric W. Biederman int ret; 747be614086SEric W. Biederman ret = single_open(filp, proc_single_show, NULL); 748be614086SEric W. Biederman if (!ret) { 749be614086SEric W. Biederman struct seq_file *m = filp->private_data; 750be614086SEric W. Biederman 751be614086SEric W. Biederman m->private = inode; 752be614086SEric W. Biederman } 753be614086SEric W. Biederman return ret; 754be614086SEric W. Biederman } 755be614086SEric W. Biederman 756be614086SEric W. Biederman static const struct file_operations proc_single_file_operations = { 757be614086SEric W. Biederman .open = proc_single_open, 758be614086SEric W. Biederman .read = seq_read, 759be614086SEric W. Biederman .llseek = seq_lseek, 760be614086SEric W. Biederman .release = single_release, 761be614086SEric W. Biederman }; 762be614086SEric W. Biederman 7631da177e4SLinus Torvalds static int mem_open(struct inode* inode, struct file* file) 7641da177e4SLinus Torvalds { 7651da177e4SLinus Torvalds file->private_data = (void*)((long)current->self_exec_id); 7661da177e4SLinus Torvalds return 0; 7671da177e4SLinus Torvalds } 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds static ssize_t mem_read(struct file * file, char __user * buf, 7701da177e4SLinus Torvalds size_t count, loff_t *ppos) 7711da177e4SLinus Torvalds { 7722fddfeefSJosef "Jeff" Sipek struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 7731da177e4SLinus Torvalds char *page; 7741da177e4SLinus Torvalds unsigned long src = *ppos; 7751da177e4SLinus Torvalds int ret = -ESRCH; 7761da177e4SLinus Torvalds struct mm_struct *mm; 7771da177e4SLinus Torvalds 77899f89551SEric W. Biederman if (!task) 77999f89551SEric W. Biederman goto out_no_task; 78099f89551SEric W. Biederman 781638fa202SRoland McGrath if (check_mem_permission(task)) 7821da177e4SLinus Torvalds goto out; 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds ret = -ENOMEM; 785e12ba74dSMel Gorman page = (char *)__get_free_page(GFP_TEMPORARY); 7861da177e4SLinus Torvalds if (!page) 7871da177e4SLinus Torvalds goto out; 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds ret = 0; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds mm = get_task_mm(task); 7921da177e4SLinus Torvalds if (!mm) 7931da177e4SLinus Torvalds goto out_free; 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds ret = -EIO; 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds if (file->private_data != (void*)((long)current->self_exec_id)) 7981da177e4SLinus Torvalds goto out_put; 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds ret = 0; 8011da177e4SLinus Torvalds 8021da177e4SLinus Torvalds while (count > 0) { 8031da177e4SLinus Torvalds int this_len, retval; 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 8061da177e4SLinus Torvalds retval = access_process_vm(task, src, page, this_len, 0); 807638fa202SRoland McGrath if (!retval || check_mem_permission(task)) { 8081da177e4SLinus Torvalds if (!ret) 8091da177e4SLinus Torvalds ret = -EIO; 8101da177e4SLinus Torvalds break; 8111da177e4SLinus Torvalds } 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds if (copy_to_user(buf, page, retval)) { 8141da177e4SLinus Torvalds ret = -EFAULT; 8151da177e4SLinus Torvalds break; 8161da177e4SLinus Torvalds } 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds ret += retval; 8191da177e4SLinus Torvalds src += retval; 8201da177e4SLinus Torvalds buf += retval; 8211da177e4SLinus Torvalds count -= retval; 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds *ppos = src; 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds out_put: 8261da177e4SLinus Torvalds mmput(mm); 8271da177e4SLinus Torvalds out_free: 8281da177e4SLinus Torvalds free_page((unsigned long) page); 8291da177e4SLinus Torvalds out: 83099f89551SEric W. Biederman put_task_struct(task); 83199f89551SEric W. Biederman out_no_task: 8321da177e4SLinus Torvalds return ret; 8331da177e4SLinus Torvalds } 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds #define mem_write NULL 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds #ifndef mem_write 8381da177e4SLinus Torvalds /* This is a security hazard */ 83963967fa9SGlauber de Oliveira Costa static ssize_t mem_write(struct file * file, const char __user *buf, 8401da177e4SLinus Torvalds size_t count, loff_t *ppos) 8411da177e4SLinus Torvalds { 842f7ca54f4SFrederik Deweerdt int copied; 8431da177e4SLinus Torvalds char *page; 8442fddfeefSJosef "Jeff" Sipek struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 8451da177e4SLinus Torvalds unsigned long dst = *ppos; 8461da177e4SLinus Torvalds 84799f89551SEric W. Biederman copied = -ESRCH; 84899f89551SEric W. Biederman if (!task) 84999f89551SEric W. Biederman goto out_no_task; 8501da177e4SLinus Torvalds 851638fa202SRoland McGrath if (check_mem_permission(task)) 85299f89551SEric W. Biederman goto out; 85399f89551SEric W. Biederman 85499f89551SEric W. Biederman copied = -ENOMEM; 855e12ba74dSMel Gorman page = (char *)__get_free_page(GFP_TEMPORARY); 8561da177e4SLinus Torvalds if (!page) 85799f89551SEric W. Biederman goto out; 8581da177e4SLinus Torvalds 859f7ca54f4SFrederik Deweerdt copied = 0; 8601da177e4SLinus Torvalds while (count > 0) { 8611da177e4SLinus Torvalds int this_len, retval; 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 8641da177e4SLinus Torvalds if (copy_from_user(page, buf, this_len)) { 8651da177e4SLinus Torvalds copied = -EFAULT; 8661da177e4SLinus Torvalds break; 8671da177e4SLinus Torvalds } 8681da177e4SLinus Torvalds retval = access_process_vm(task, dst, page, this_len, 1); 8691da177e4SLinus Torvalds if (!retval) { 8701da177e4SLinus Torvalds if (!copied) 8711da177e4SLinus Torvalds copied = -EIO; 8721da177e4SLinus Torvalds break; 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds copied += retval; 8751da177e4SLinus Torvalds buf += retval; 8761da177e4SLinus Torvalds dst += retval; 8771da177e4SLinus Torvalds count -= retval; 8781da177e4SLinus Torvalds } 8791da177e4SLinus Torvalds *ppos = dst; 8801da177e4SLinus Torvalds free_page((unsigned long) page); 88199f89551SEric W. Biederman out: 88299f89551SEric W. Biederman put_task_struct(task); 88399f89551SEric W. Biederman out_no_task: 8841da177e4SLinus Torvalds return copied; 8851da177e4SLinus Torvalds } 8861da177e4SLinus Torvalds #endif 8871da177e4SLinus Torvalds 88885863e47SMatt Mackall loff_t mem_lseek(struct file *file, loff_t offset, int orig) 8891da177e4SLinus Torvalds { 8901da177e4SLinus Torvalds switch (orig) { 8911da177e4SLinus Torvalds case 0: 8921da177e4SLinus Torvalds file->f_pos = offset; 8931da177e4SLinus Torvalds break; 8941da177e4SLinus Torvalds case 1: 8951da177e4SLinus Torvalds file->f_pos += offset; 8961da177e4SLinus Torvalds break; 8971da177e4SLinus Torvalds default: 8981da177e4SLinus Torvalds return -EINVAL; 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds force_successful_syscall_return(); 9011da177e4SLinus Torvalds return file->f_pos; 9021da177e4SLinus Torvalds } 9031da177e4SLinus Torvalds 90400977a59SArjan van de Ven static const struct file_operations proc_mem_operations = { 9051da177e4SLinus Torvalds .llseek = mem_lseek, 9061da177e4SLinus Torvalds .read = mem_read, 9071da177e4SLinus Torvalds .write = mem_write, 9081da177e4SLinus Torvalds .open = mem_open, 9091da177e4SLinus Torvalds }; 9101da177e4SLinus Torvalds 911315e28c8SJames Pearson static ssize_t environ_read(struct file *file, char __user *buf, 912315e28c8SJames Pearson size_t count, loff_t *ppos) 913315e28c8SJames Pearson { 914315e28c8SJames Pearson struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 915315e28c8SJames Pearson char *page; 916315e28c8SJames Pearson unsigned long src = *ppos; 917315e28c8SJames Pearson int ret = -ESRCH; 918315e28c8SJames Pearson struct mm_struct *mm; 919315e28c8SJames Pearson 920315e28c8SJames Pearson if (!task) 921315e28c8SJames Pearson goto out_no_task; 922315e28c8SJames Pearson 923006ebb40SStephen Smalley if (!ptrace_may_access(task, PTRACE_MODE_READ)) 924315e28c8SJames Pearson goto out; 925315e28c8SJames Pearson 926315e28c8SJames Pearson ret = -ENOMEM; 927315e28c8SJames Pearson page = (char *)__get_free_page(GFP_TEMPORARY); 928315e28c8SJames Pearson if (!page) 929315e28c8SJames Pearson goto out; 930315e28c8SJames Pearson 931315e28c8SJames Pearson ret = 0; 932315e28c8SJames Pearson 933315e28c8SJames Pearson mm = get_task_mm(task); 934315e28c8SJames Pearson if (!mm) 935315e28c8SJames Pearson goto out_free; 936315e28c8SJames Pearson 937315e28c8SJames Pearson while (count > 0) { 938315e28c8SJames Pearson int this_len, retval, max_len; 939315e28c8SJames Pearson 940315e28c8SJames Pearson this_len = mm->env_end - (mm->env_start + src); 941315e28c8SJames Pearson 942315e28c8SJames Pearson if (this_len <= 0) 943315e28c8SJames Pearson break; 944315e28c8SJames Pearson 945315e28c8SJames Pearson max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count; 946315e28c8SJames Pearson this_len = (this_len > max_len) ? max_len : this_len; 947315e28c8SJames Pearson 948315e28c8SJames Pearson retval = access_process_vm(task, (mm->env_start + src), 949315e28c8SJames Pearson page, this_len, 0); 950315e28c8SJames Pearson 951315e28c8SJames Pearson if (retval <= 0) { 952315e28c8SJames Pearson ret = retval; 953315e28c8SJames Pearson break; 954315e28c8SJames Pearson } 955315e28c8SJames Pearson 956315e28c8SJames Pearson if (copy_to_user(buf, page, retval)) { 957315e28c8SJames Pearson ret = -EFAULT; 958315e28c8SJames Pearson break; 959315e28c8SJames Pearson } 960315e28c8SJames Pearson 961315e28c8SJames Pearson ret += retval; 962315e28c8SJames Pearson src += retval; 963315e28c8SJames Pearson buf += retval; 964315e28c8SJames Pearson count -= retval; 965315e28c8SJames Pearson } 966315e28c8SJames Pearson *ppos = src; 967315e28c8SJames Pearson 968315e28c8SJames Pearson mmput(mm); 969315e28c8SJames Pearson out_free: 970315e28c8SJames Pearson free_page((unsigned long) page); 971315e28c8SJames Pearson out: 972315e28c8SJames Pearson put_task_struct(task); 973315e28c8SJames Pearson out_no_task: 974315e28c8SJames Pearson return ret; 975315e28c8SJames Pearson } 976315e28c8SJames Pearson 977315e28c8SJames Pearson static const struct file_operations proc_environ_operations = { 978315e28c8SJames Pearson .read = environ_read, 979315e28c8SJames Pearson }; 980315e28c8SJames Pearson 9811da177e4SLinus Torvalds static ssize_t oom_adjust_read(struct file *file, char __user *buf, 9821da177e4SLinus Torvalds size_t count, loff_t *ppos) 9831da177e4SLinus Torvalds { 9842fddfeefSJosef "Jeff" Sipek struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode); 9858578cea7SEric W. Biederman char buffer[PROC_NUMBUF]; 9861da177e4SLinus Torvalds size_t len; 98799f89551SEric W. Biederman int oom_adjust; 9881da177e4SLinus Torvalds 98999f89551SEric W. Biederman if (!task) 99099f89551SEric W. Biederman return -ESRCH; 99199f89551SEric W. Biederman oom_adjust = task->oomkilladj; 99299f89551SEric W. Biederman put_task_struct(task); 99399f89551SEric W. Biederman 9948578cea7SEric W. Biederman len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust); 9950c28f287SAkinobu Mita 9960c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds static ssize_t oom_adjust_write(struct file *file, const char __user *buf, 10001da177e4SLinus Torvalds size_t count, loff_t *ppos) 10011da177e4SLinus Torvalds { 100299f89551SEric W. Biederman struct task_struct *task; 10038578cea7SEric W. Biederman char buffer[PROC_NUMBUF], *end; 10041da177e4SLinus Torvalds int oom_adjust; 10051da177e4SLinus Torvalds 10068578cea7SEric W. Biederman memset(buffer, 0, sizeof(buffer)); 10078578cea7SEric W. Biederman if (count > sizeof(buffer) - 1) 10088578cea7SEric W. Biederman count = sizeof(buffer) - 1; 10091da177e4SLinus Torvalds if (copy_from_user(buffer, buf, count)) 10101da177e4SLinus Torvalds return -EFAULT; 10111da177e4SLinus Torvalds oom_adjust = simple_strtol(buffer, &end, 0); 10128ac773b4SAlexey Dobriyan if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) && 10138ac773b4SAlexey Dobriyan oom_adjust != OOM_DISABLE) 10141da177e4SLinus Torvalds return -EINVAL; 10151da177e4SLinus Torvalds if (*end == '\n') 10161da177e4SLinus Torvalds end++; 10172fddfeefSJosef "Jeff" Sipek task = get_proc_task(file->f_path.dentry->d_inode); 101899f89551SEric W. Biederman if (!task) 101999f89551SEric W. Biederman return -ESRCH; 10208fb4fc68SGuillem Jover if (oom_adjust < task->oomkilladj && !capable(CAP_SYS_RESOURCE)) { 10218fb4fc68SGuillem Jover put_task_struct(task); 10228fb4fc68SGuillem Jover return -EACCES; 10238fb4fc68SGuillem Jover } 10241da177e4SLinus Torvalds task->oomkilladj = oom_adjust; 102599f89551SEric W. Biederman put_task_struct(task); 10261da177e4SLinus Torvalds if (end - buffer == 0) 10271da177e4SLinus Torvalds return -EIO; 10281da177e4SLinus Torvalds return end - buffer; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 103100977a59SArjan van de Ven static const struct file_operations proc_oom_adjust_operations = { 10321da177e4SLinus Torvalds .read = oom_adjust_read, 10331da177e4SLinus Torvalds .write = oom_adjust_write, 10341da177e4SLinus Torvalds }; 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 10371da177e4SLinus Torvalds #define TMPBUFLEN 21 10381da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 10391da177e4SLinus Torvalds size_t count, loff_t *ppos) 10401da177e4SLinus Torvalds { 10412fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 104299f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 10431da177e4SLinus Torvalds ssize_t length; 10441da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 10451da177e4SLinus Torvalds 104699f89551SEric W. Biederman if (!task) 104799f89551SEric W. Biederman return -ESRCH; 10481da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 10490c11b942SAl Viro audit_get_loginuid(task)); 105099f89551SEric W. Biederman put_task_struct(task); 10511da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 10551da177e4SLinus Torvalds size_t count, loff_t *ppos) 10561da177e4SLinus Torvalds { 10572fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 10581da177e4SLinus Torvalds char *page, *tmp; 10591da177e4SLinus Torvalds ssize_t length; 10601da177e4SLinus Torvalds uid_t loginuid; 10611da177e4SLinus Torvalds 10621da177e4SLinus Torvalds if (!capable(CAP_AUDIT_CONTROL)) 10631da177e4SLinus Torvalds return -EPERM; 10641da177e4SLinus Torvalds 106513b41b09SEric W. Biederman if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) 10661da177e4SLinus Torvalds return -EPERM; 10671da177e4SLinus Torvalds 1068e0182909SAl Viro if (count >= PAGE_SIZE) 1069e0182909SAl Viro count = PAGE_SIZE - 1; 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds if (*ppos != 0) { 10721da177e4SLinus Torvalds /* No partial writes. */ 10731da177e4SLinus Torvalds return -EINVAL; 10741da177e4SLinus Torvalds } 1075e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 10761da177e4SLinus Torvalds if (!page) 10771da177e4SLinus Torvalds return -ENOMEM; 10781da177e4SLinus Torvalds length = -EFAULT; 10791da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 10801da177e4SLinus Torvalds goto out_free_page; 10811da177e4SLinus Torvalds 1082e0182909SAl Viro page[count] = '\0'; 10831da177e4SLinus Torvalds loginuid = simple_strtoul(page, &tmp, 10); 10841da177e4SLinus Torvalds if (tmp == page) { 10851da177e4SLinus Torvalds length = -EINVAL; 10861da177e4SLinus Torvalds goto out_free_page; 10871da177e4SLinus Torvalds 10881da177e4SLinus Torvalds } 108999f89551SEric W. Biederman length = audit_set_loginuid(current, loginuid); 10901da177e4SLinus Torvalds if (likely(length == 0)) 10911da177e4SLinus Torvalds length = count; 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds out_free_page: 10941da177e4SLinus Torvalds free_page((unsigned long) page); 10951da177e4SLinus Torvalds return length; 10961da177e4SLinus Torvalds } 10971da177e4SLinus Torvalds 109800977a59SArjan van de Ven static const struct file_operations proc_loginuid_operations = { 10991da177e4SLinus Torvalds .read = proc_loginuid_read, 11001da177e4SLinus Torvalds .write = proc_loginuid_write, 11011da177e4SLinus Torvalds }; 11021e0bd755SEric Paris 11031e0bd755SEric Paris static ssize_t proc_sessionid_read(struct file * file, char __user * buf, 11041e0bd755SEric Paris size_t count, loff_t *ppos) 11051e0bd755SEric Paris { 11061e0bd755SEric Paris struct inode * inode = file->f_path.dentry->d_inode; 11071e0bd755SEric Paris struct task_struct *task = get_proc_task(inode); 11081e0bd755SEric Paris ssize_t length; 11091e0bd755SEric Paris char tmpbuf[TMPBUFLEN]; 11101e0bd755SEric Paris 11111e0bd755SEric Paris if (!task) 11121e0bd755SEric Paris return -ESRCH; 11131e0bd755SEric Paris length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 11141e0bd755SEric Paris audit_get_sessionid(task)); 11151e0bd755SEric Paris put_task_struct(task); 11161e0bd755SEric Paris return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 11171e0bd755SEric Paris } 11181e0bd755SEric Paris 11191e0bd755SEric Paris static const struct file_operations proc_sessionid_operations = { 11201e0bd755SEric Paris .read = proc_sessionid_read, 11211e0bd755SEric Paris }; 11221da177e4SLinus Torvalds #endif 11231da177e4SLinus Torvalds 1124f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1125f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_read(struct file * file, char __user * buf, 1126f4f154fdSAkinobu Mita size_t count, loff_t *ppos) 1127f4f154fdSAkinobu Mita { 1128f4f154fdSAkinobu Mita struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 1129f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF]; 1130f4f154fdSAkinobu Mita size_t len; 1131f4f154fdSAkinobu Mita int make_it_fail; 1132f4f154fdSAkinobu Mita 1133f4f154fdSAkinobu Mita if (!task) 1134f4f154fdSAkinobu Mita return -ESRCH; 1135f4f154fdSAkinobu Mita make_it_fail = task->make_it_fail; 1136f4f154fdSAkinobu Mita put_task_struct(task); 1137f4f154fdSAkinobu Mita 1138f4f154fdSAkinobu Mita len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail); 11390c28f287SAkinobu Mita 11400c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 1141f4f154fdSAkinobu Mita } 1142f4f154fdSAkinobu Mita 1143f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_write(struct file * file, 1144f4f154fdSAkinobu Mita const char __user * buf, size_t count, loff_t *ppos) 1145f4f154fdSAkinobu Mita { 1146f4f154fdSAkinobu Mita struct task_struct *task; 1147f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF], *end; 1148f4f154fdSAkinobu Mita int make_it_fail; 1149f4f154fdSAkinobu Mita 1150f4f154fdSAkinobu Mita if (!capable(CAP_SYS_RESOURCE)) 1151f4f154fdSAkinobu Mita return -EPERM; 1152f4f154fdSAkinobu Mita memset(buffer, 0, sizeof(buffer)); 1153f4f154fdSAkinobu Mita if (count > sizeof(buffer) - 1) 1154f4f154fdSAkinobu Mita count = sizeof(buffer) - 1; 1155f4f154fdSAkinobu Mita if (copy_from_user(buffer, buf, count)) 1156f4f154fdSAkinobu Mita return -EFAULT; 1157f4f154fdSAkinobu Mita make_it_fail = simple_strtol(buffer, &end, 0); 1158f4f154fdSAkinobu Mita if (*end == '\n') 1159f4f154fdSAkinobu Mita end++; 1160f4f154fdSAkinobu Mita task = get_proc_task(file->f_dentry->d_inode); 1161f4f154fdSAkinobu Mita if (!task) 1162f4f154fdSAkinobu Mita return -ESRCH; 1163f4f154fdSAkinobu Mita task->make_it_fail = make_it_fail; 1164f4f154fdSAkinobu Mita put_task_struct(task); 1165f4f154fdSAkinobu Mita if (end - buffer == 0) 1166f4f154fdSAkinobu Mita return -EIO; 1167f4f154fdSAkinobu Mita return end - buffer; 1168f4f154fdSAkinobu Mita } 1169f4f154fdSAkinobu Mita 117000977a59SArjan van de Ven static const struct file_operations proc_fault_inject_operations = { 1171f4f154fdSAkinobu Mita .read = proc_fault_inject_read, 1172f4f154fdSAkinobu Mita .write = proc_fault_inject_write, 1173f4f154fdSAkinobu Mita }; 1174f4f154fdSAkinobu Mita #endif 1175f4f154fdSAkinobu Mita 11769745512cSArjan van de Ven 117743ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 117843ae34cbSIngo Molnar /* 117943ae34cbSIngo Molnar * Print out various scheduling related per-task fields: 118043ae34cbSIngo Molnar */ 118143ae34cbSIngo Molnar static int sched_show(struct seq_file *m, void *v) 118243ae34cbSIngo Molnar { 118343ae34cbSIngo Molnar struct inode *inode = m->private; 118443ae34cbSIngo Molnar struct task_struct *p; 118543ae34cbSIngo Molnar 118643ae34cbSIngo Molnar p = get_proc_task(inode); 118743ae34cbSIngo Molnar if (!p) 118843ae34cbSIngo Molnar return -ESRCH; 118943ae34cbSIngo Molnar proc_sched_show_task(p, m); 119043ae34cbSIngo Molnar 119143ae34cbSIngo Molnar put_task_struct(p); 119243ae34cbSIngo Molnar 119343ae34cbSIngo Molnar return 0; 119443ae34cbSIngo Molnar } 119543ae34cbSIngo Molnar 119643ae34cbSIngo Molnar static ssize_t 119743ae34cbSIngo Molnar sched_write(struct file *file, const char __user *buf, 119843ae34cbSIngo Molnar size_t count, loff_t *offset) 119943ae34cbSIngo Molnar { 120043ae34cbSIngo Molnar struct inode *inode = file->f_path.dentry->d_inode; 120143ae34cbSIngo Molnar struct task_struct *p; 120243ae34cbSIngo Molnar 120343ae34cbSIngo Molnar p = get_proc_task(inode); 120443ae34cbSIngo Molnar if (!p) 120543ae34cbSIngo Molnar return -ESRCH; 120643ae34cbSIngo Molnar proc_sched_set_task(p); 120743ae34cbSIngo Molnar 120843ae34cbSIngo Molnar put_task_struct(p); 120943ae34cbSIngo Molnar 121043ae34cbSIngo Molnar return count; 121143ae34cbSIngo Molnar } 121243ae34cbSIngo Molnar 121343ae34cbSIngo Molnar static int sched_open(struct inode *inode, struct file *filp) 121443ae34cbSIngo Molnar { 121543ae34cbSIngo Molnar int ret; 121643ae34cbSIngo Molnar 121743ae34cbSIngo Molnar ret = single_open(filp, sched_show, NULL); 121843ae34cbSIngo Molnar if (!ret) { 121943ae34cbSIngo Molnar struct seq_file *m = filp->private_data; 122043ae34cbSIngo Molnar 122143ae34cbSIngo Molnar m->private = inode; 122243ae34cbSIngo Molnar } 122343ae34cbSIngo Molnar return ret; 122443ae34cbSIngo Molnar } 122543ae34cbSIngo Molnar 122643ae34cbSIngo Molnar static const struct file_operations proc_pid_sched_operations = { 122743ae34cbSIngo Molnar .open = sched_open, 122843ae34cbSIngo Molnar .read = seq_read, 122943ae34cbSIngo Molnar .write = sched_write, 123043ae34cbSIngo Molnar .llseek = seq_lseek, 12315ea473a1SAlexey Dobriyan .release = single_release, 123243ae34cbSIngo Molnar }; 123343ae34cbSIngo Molnar 123443ae34cbSIngo Molnar #endif 123543ae34cbSIngo Molnar 1236925d1c40SMatt Helsley /* 1237925d1c40SMatt Helsley * We added or removed a vma mapping the executable. The vmas are only mapped 1238925d1c40SMatt Helsley * during exec and are not mapped with the mmap system call. 1239925d1c40SMatt Helsley * Callers must hold down_write() on the mm's mmap_sem for these 1240925d1c40SMatt Helsley */ 1241925d1c40SMatt Helsley void added_exe_file_vma(struct mm_struct *mm) 1242925d1c40SMatt Helsley { 1243925d1c40SMatt Helsley mm->num_exe_file_vmas++; 1244925d1c40SMatt Helsley } 1245925d1c40SMatt Helsley 1246925d1c40SMatt Helsley void removed_exe_file_vma(struct mm_struct *mm) 1247925d1c40SMatt Helsley { 1248925d1c40SMatt Helsley mm->num_exe_file_vmas--; 1249925d1c40SMatt Helsley if ((mm->num_exe_file_vmas == 0) && mm->exe_file){ 1250925d1c40SMatt Helsley fput(mm->exe_file); 1251925d1c40SMatt Helsley mm->exe_file = NULL; 1252925d1c40SMatt Helsley } 1253925d1c40SMatt Helsley 1254925d1c40SMatt Helsley } 1255925d1c40SMatt Helsley 1256925d1c40SMatt Helsley void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file) 1257925d1c40SMatt Helsley { 1258925d1c40SMatt Helsley if (new_exe_file) 1259925d1c40SMatt Helsley get_file(new_exe_file); 1260925d1c40SMatt Helsley if (mm->exe_file) 1261925d1c40SMatt Helsley fput(mm->exe_file); 1262925d1c40SMatt Helsley mm->exe_file = new_exe_file; 1263925d1c40SMatt Helsley mm->num_exe_file_vmas = 0; 1264925d1c40SMatt Helsley } 1265925d1c40SMatt Helsley 1266925d1c40SMatt Helsley struct file *get_mm_exe_file(struct mm_struct *mm) 1267925d1c40SMatt Helsley { 1268925d1c40SMatt Helsley struct file *exe_file; 1269925d1c40SMatt Helsley 1270925d1c40SMatt Helsley /* We need mmap_sem to protect against races with removal of 1271925d1c40SMatt Helsley * VM_EXECUTABLE vmas */ 1272925d1c40SMatt Helsley down_read(&mm->mmap_sem); 1273925d1c40SMatt Helsley exe_file = mm->exe_file; 1274925d1c40SMatt Helsley if (exe_file) 1275925d1c40SMatt Helsley get_file(exe_file); 1276925d1c40SMatt Helsley up_read(&mm->mmap_sem); 1277925d1c40SMatt Helsley return exe_file; 1278925d1c40SMatt Helsley } 1279925d1c40SMatt Helsley 1280925d1c40SMatt Helsley void dup_mm_exe_file(struct mm_struct *oldmm, struct mm_struct *newmm) 1281925d1c40SMatt Helsley { 1282925d1c40SMatt Helsley /* It's safe to write the exe_file pointer without exe_file_lock because 1283925d1c40SMatt Helsley * this is called during fork when the task is not yet in /proc */ 1284925d1c40SMatt Helsley newmm->exe_file = get_mm_exe_file(oldmm); 1285925d1c40SMatt Helsley } 1286925d1c40SMatt Helsley 1287925d1c40SMatt Helsley static int proc_exe_link(struct inode *inode, struct path *exe_path) 1288925d1c40SMatt Helsley { 1289925d1c40SMatt Helsley struct task_struct *task; 1290925d1c40SMatt Helsley struct mm_struct *mm; 1291925d1c40SMatt Helsley struct file *exe_file; 1292925d1c40SMatt Helsley 1293925d1c40SMatt Helsley task = get_proc_task(inode); 1294925d1c40SMatt Helsley if (!task) 1295925d1c40SMatt Helsley return -ENOENT; 1296925d1c40SMatt Helsley mm = get_task_mm(task); 1297925d1c40SMatt Helsley put_task_struct(task); 1298925d1c40SMatt Helsley if (!mm) 1299925d1c40SMatt Helsley return -ENOENT; 1300925d1c40SMatt Helsley exe_file = get_mm_exe_file(mm); 1301925d1c40SMatt Helsley mmput(mm); 1302925d1c40SMatt Helsley if (exe_file) { 1303925d1c40SMatt Helsley *exe_path = exe_file->f_path; 1304925d1c40SMatt Helsley path_get(&exe_file->f_path); 1305925d1c40SMatt Helsley fput(exe_file); 1306925d1c40SMatt Helsley return 0; 1307925d1c40SMatt Helsley } else 1308925d1c40SMatt Helsley return -ENOENT; 1309925d1c40SMatt Helsley } 1310925d1c40SMatt Helsley 1311008b150aSAl Viro static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) 13121da177e4SLinus Torvalds { 13131da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 13141da177e4SLinus Torvalds int error = -EACCES; 13151da177e4SLinus Torvalds 13161da177e4SLinus Torvalds /* We don't need a base pointer in the /proc filesystem */ 13171d957f9bSJan Blunck path_put(&nd->path); 13181da177e4SLinus Torvalds 1319778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1320778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 13211da177e4SLinus Torvalds goto out; 13221da177e4SLinus Torvalds 13233dcd25f3SJan Blunck error = PROC_I(inode)->op.proc_get_link(inode, &nd->path); 13241da177e4SLinus Torvalds nd->last_type = LAST_BIND; 13251da177e4SLinus Torvalds out: 1326008b150aSAl Viro return ERR_PTR(error); 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 13293dcd25f3SJan Blunck static int do_proc_readlink(struct path *path, char __user *buffer, int buflen) 13301da177e4SLinus Torvalds { 1331e12ba74dSMel Gorman char *tmp = (char*)__get_free_page(GFP_TEMPORARY); 13323dcd25f3SJan Blunck char *pathname; 13331da177e4SLinus Torvalds int len; 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds if (!tmp) 13361da177e4SLinus Torvalds return -ENOMEM; 13371da177e4SLinus Torvalds 1338cf28b486SJan Blunck pathname = d_path(path, tmp, PAGE_SIZE); 13393dcd25f3SJan Blunck len = PTR_ERR(pathname); 13403dcd25f3SJan Blunck if (IS_ERR(pathname)) 13411da177e4SLinus Torvalds goto out; 13423dcd25f3SJan Blunck len = tmp + PAGE_SIZE - 1 - pathname; 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds if (len > buflen) 13451da177e4SLinus Torvalds len = buflen; 13463dcd25f3SJan Blunck if (copy_to_user(buffer, pathname, len)) 13471da177e4SLinus Torvalds len = -EFAULT; 13481da177e4SLinus Torvalds out: 13491da177e4SLinus Torvalds free_page((unsigned long)tmp); 13501da177e4SLinus Torvalds return len; 13511da177e4SLinus Torvalds } 13521da177e4SLinus Torvalds 13531da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 13541da177e4SLinus Torvalds { 13551da177e4SLinus Torvalds int error = -EACCES; 13561da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 13573dcd25f3SJan Blunck struct path path; 13581da177e4SLinus Torvalds 1359778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1360778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 13611da177e4SLinus Torvalds goto out; 13621da177e4SLinus Torvalds 13633dcd25f3SJan Blunck error = PROC_I(inode)->op.proc_get_link(inode, &path); 13641da177e4SLinus Torvalds if (error) 13651da177e4SLinus Torvalds goto out; 13661da177e4SLinus Torvalds 13673dcd25f3SJan Blunck error = do_proc_readlink(&path, buffer, buflen); 13683dcd25f3SJan Blunck path_put(&path); 13691da177e4SLinus Torvalds out: 13701da177e4SLinus Torvalds return error; 13711da177e4SLinus Torvalds } 13721da177e4SLinus Torvalds 1373c5ef1c42SArjan van de Ven static const struct inode_operations proc_pid_link_inode_operations = { 13741da177e4SLinus Torvalds .readlink = proc_pid_readlink, 13756d76fa58SLinus Torvalds .follow_link = proc_pid_follow_link, 13766d76fa58SLinus Torvalds .setattr = proc_setattr, 13771da177e4SLinus Torvalds }; 13781da177e4SLinus Torvalds 137928a6d671SEric W. Biederman 138028a6d671SEric W. Biederman /* building an inode */ 138128a6d671SEric W. Biederman 138228a6d671SEric W. Biederman static int task_dumpable(struct task_struct *task) 138328a6d671SEric W. Biederman { 138428a6d671SEric W. Biederman int dumpable = 0; 138528a6d671SEric W. Biederman struct mm_struct *mm; 138628a6d671SEric W. Biederman 138728a6d671SEric W. Biederman task_lock(task); 138828a6d671SEric W. Biederman mm = task->mm; 138928a6d671SEric W. Biederman if (mm) 13906c5d5238SKawai, Hidehiro dumpable = get_dumpable(mm); 139128a6d671SEric W. Biederman task_unlock(task); 139228a6d671SEric W. Biederman if(dumpable == 1) 139328a6d671SEric W. Biederman return 1; 139428a6d671SEric W. Biederman return 0; 139528a6d671SEric W. Biederman } 139628a6d671SEric W. Biederman 139728a6d671SEric W. Biederman 139861a28784SEric W. Biederman static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task) 139928a6d671SEric W. Biederman { 140028a6d671SEric W. Biederman struct inode * inode; 140128a6d671SEric W. Biederman struct proc_inode *ei; 1402c69e8d9cSDavid Howells const struct cred *cred; 140328a6d671SEric W. Biederman 140428a6d671SEric W. Biederman /* We need a new inode */ 140528a6d671SEric W. Biederman 140628a6d671SEric W. Biederman inode = new_inode(sb); 140728a6d671SEric W. Biederman if (!inode) 140828a6d671SEric W. Biederman goto out; 140928a6d671SEric W. Biederman 141028a6d671SEric W. Biederman /* Common stuff */ 141128a6d671SEric W. Biederman ei = PROC_I(inode); 141228a6d671SEric W. Biederman inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 141328a6d671SEric W. Biederman inode->i_op = &proc_def_inode_operations; 141428a6d671SEric W. Biederman 141528a6d671SEric W. Biederman /* 141628a6d671SEric W. Biederman * grab the reference to task. 141728a6d671SEric W. Biederman */ 14181a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 141928a6d671SEric W. Biederman if (!ei->pid) 142028a6d671SEric W. Biederman goto out_unlock; 142128a6d671SEric W. Biederman 142228a6d671SEric W. Biederman inode->i_uid = 0; 142328a6d671SEric W. Biederman inode->i_gid = 0; 142428a6d671SEric W. Biederman if (task_dumpable(task)) { 1425c69e8d9cSDavid Howells rcu_read_lock(); 1426c69e8d9cSDavid Howells cred = __task_cred(task); 1427c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1428c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1429c69e8d9cSDavid Howells rcu_read_unlock(); 143028a6d671SEric W. Biederman } 143128a6d671SEric W. Biederman security_task_to_inode(task, inode); 143228a6d671SEric W. Biederman 143328a6d671SEric W. Biederman out: 143428a6d671SEric W. Biederman return inode; 143528a6d671SEric W. Biederman 143628a6d671SEric W. Biederman out_unlock: 143728a6d671SEric W. Biederman iput(inode); 143828a6d671SEric W. Biederman return NULL; 143928a6d671SEric W. Biederman } 144028a6d671SEric W. Biederman 144128a6d671SEric W. Biederman static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 144228a6d671SEric W. Biederman { 144328a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 144428a6d671SEric W. Biederman struct task_struct *task; 1445c69e8d9cSDavid Howells const struct cred *cred; 1446c69e8d9cSDavid Howells 144728a6d671SEric W. Biederman generic_fillattr(inode, stat); 144828a6d671SEric W. Biederman 144928a6d671SEric W. Biederman rcu_read_lock(); 145028a6d671SEric W. Biederman stat->uid = 0; 145128a6d671SEric W. Biederman stat->gid = 0; 145228a6d671SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 145328a6d671SEric W. Biederman if (task) { 145428a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 145528a6d671SEric W. Biederman task_dumpable(task)) { 1456c69e8d9cSDavid Howells cred = __task_cred(task); 1457c69e8d9cSDavid Howells stat->uid = cred->euid; 1458c69e8d9cSDavid Howells stat->gid = cred->egid; 145928a6d671SEric W. Biederman } 146028a6d671SEric W. Biederman } 146128a6d671SEric W. Biederman rcu_read_unlock(); 146228a6d671SEric W. Biederman return 0; 146328a6d671SEric W. Biederman } 146428a6d671SEric W. Biederman 146528a6d671SEric W. Biederman /* dentry stuff */ 146628a6d671SEric W. Biederman 146728a6d671SEric W. Biederman /* 146828a6d671SEric W. Biederman * Exceptional case: normally we are not allowed to unhash a busy 146928a6d671SEric W. Biederman * directory. In this case, however, we can do it - no aliasing problems 147028a6d671SEric W. Biederman * due to the way we treat inodes. 147128a6d671SEric W. Biederman * 147228a6d671SEric W. Biederman * Rewrite the inode's ownerships here because the owning task may have 147328a6d671SEric W. Biederman * performed a setuid(), etc. 147428a6d671SEric W. Biederman * 147528a6d671SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 147628a6d671SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 147728a6d671SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 147828a6d671SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 147928a6d671SEric W. Biederman * made this apply to all per process world readable and executable 148028a6d671SEric W. Biederman * directories. 148128a6d671SEric W. Biederman */ 148228a6d671SEric W. Biederman static int pid_revalidate(struct dentry *dentry, struct nameidata *nd) 148328a6d671SEric W. Biederman { 148428a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 148528a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 1486c69e8d9cSDavid Howells const struct cred *cred; 1487c69e8d9cSDavid Howells 148828a6d671SEric W. Biederman if (task) { 148928a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 149028a6d671SEric W. Biederman task_dumpable(task)) { 1491c69e8d9cSDavid Howells rcu_read_lock(); 1492c69e8d9cSDavid Howells cred = __task_cred(task); 1493c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1494c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1495c69e8d9cSDavid Howells rcu_read_unlock(); 149628a6d671SEric W. Biederman } else { 149728a6d671SEric W. Biederman inode->i_uid = 0; 149828a6d671SEric W. Biederman inode->i_gid = 0; 149928a6d671SEric W. Biederman } 150028a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 150128a6d671SEric W. Biederman security_task_to_inode(task, inode); 150228a6d671SEric W. Biederman put_task_struct(task); 150328a6d671SEric W. Biederman return 1; 150428a6d671SEric W. Biederman } 150528a6d671SEric W. Biederman d_drop(dentry); 150628a6d671SEric W. Biederman return 0; 150728a6d671SEric W. Biederman } 150828a6d671SEric W. Biederman 150928a6d671SEric W. Biederman static int pid_delete_dentry(struct dentry * dentry) 151028a6d671SEric W. Biederman { 151128a6d671SEric W. Biederman /* Is the task we represent dead? 151228a6d671SEric W. Biederman * If so, then don't put the dentry on the lru list, 151328a6d671SEric W. Biederman * kill it immediately. 151428a6d671SEric W. Biederman */ 151528a6d671SEric W. Biederman return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first; 151628a6d671SEric W. Biederman } 151728a6d671SEric W. Biederman 151828a6d671SEric W. Biederman static struct dentry_operations pid_dentry_operations = 151928a6d671SEric W. Biederman { 152028a6d671SEric W. Biederman .d_revalidate = pid_revalidate, 152128a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 152228a6d671SEric W. Biederman }; 152328a6d671SEric W. Biederman 152428a6d671SEric W. Biederman /* Lookups */ 152528a6d671SEric W. Biederman 1526c5141e6dSEric Dumazet typedef struct dentry *instantiate_t(struct inode *, struct dentry *, 1527c5141e6dSEric Dumazet struct task_struct *, const void *); 152861a28784SEric W. Biederman 15291c0d04c9SEric W. Biederman /* 15301c0d04c9SEric W. Biederman * Fill a directory entry. 15311c0d04c9SEric W. Biederman * 15321c0d04c9SEric W. Biederman * If possible create the dcache entry and derive our inode number and 15331c0d04c9SEric W. Biederman * file type from dcache entry. 15341c0d04c9SEric W. Biederman * 15351c0d04c9SEric W. Biederman * Since all of the proc inode numbers are dynamically generated, the inode 15361c0d04c9SEric W. Biederman * numbers do not exist until the inode is cache. This means creating the 15371c0d04c9SEric W. Biederman * the dcache entry in readdir is necessary to keep the inode numbers 15381c0d04c9SEric W. Biederman * reported by readdir in sync with the inode numbers reported 15391c0d04c9SEric W. Biederman * by stat. 15401c0d04c9SEric W. Biederman */ 154161a28784SEric W. Biederman static int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir, 154261a28784SEric W. Biederman char *name, int len, 1543c5141e6dSEric Dumazet instantiate_t instantiate, struct task_struct *task, const void *ptr) 154461a28784SEric W. Biederman { 15452fddfeefSJosef "Jeff" Sipek struct dentry *child, *dir = filp->f_path.dentry; 154661a28784SEric W. Biederman struct inode *inode; 154761a28784SEric W. Biederman struct qstr qname; 154861a28784SEric W. Biederman ino_t ino = 0; 154961a28784SEric W. Biederman unsigned type = DT_UNKNOWN; 155061a28784SEric W. Biederman 155161a28784SEric W. Biederman qname.name = name; 155261a28784SEric W. Biederman qname.len = len; 155361a28784SEric W. Biederman qname.hash = full_name_hash(name, len); 155461a28784SEric W. Biederman 155561a28784SEric W. Biederman child = d_lookup(dir, &qname); 155661a28784SEric W. Biederman if (!child) { 155761a28784SEric W. Biederman struct dentry *new; 155861a28784SEric W. Biederman new = d_alloc(dir, &qname); 155961a28784SEric W. Biederman if (new) { 156061a28784SEric W. Biederman child = instantiate(dir->d_inode, new, task, ptr); 156161a28784SEric W. Biederman if (child) 156261a28784SEric W. Biederman dput(new); 156361a28784SEric W. Biederman else 156461a28784SEric W. Biederman child = new; 156561a28784SEric W. Biederman } 156661a28784SEric W. Biederman } 156761a28784SEric W. Biederman if (!child || IS_ERR(child) || !child->d_inode) 156861a28784SEric W. Biederman goto end_instantiate; 156961a28784SEric W. Biederman inode = child->d_inode; 157061a28784SEric W. Biederman if (inode) { 157161a28784SEric W. Biederman ino = inode->i_ino; 157261a28784SEric W. Biederman type = inode->i_mode >> 12; 157361a28784SEric W. Biederman } 157461a28784SEric W. Biederman dput(child); 157561a28784SEric W. Biederman end_instantiate: 157661a28784SEric W. Biederman if (!ino) 157761a28784SEric W. Biederman ino = find_inode_number(dir, &qname); 157861a28784SEric W. Biederman if (!ino) 157961a28784SEric W. Biederman ino = 1; 158061a28784SEric W. Biederman return filldir(dirent, name, len, filp->f_pos, ino, type); 158161a28784SEric W. Biederman } 158261a28784SEric W. Biederman 158328a6d671SEric W. Biederman static unsigned name_to_int(struct dentry *dentry) 158428a6d671SEric W. Biederman { 158528a6d671SEric W. Biederman const char *name = dentry->d_name.name; 158628a6d671SEric W. Biederman int len = dentry->d_name.len; 158728a6d671SEric W. Biederman unsigned n = 0; 158828a6d671SEric W. Biederman 158928a6d671SEric W. Biederman if (len > 1 && *name == '0') 159028a6d671SEric W. Biederman goto out; 159128a6d671SEric W. Biederman while (len-- > 0) { 159228a6d671SEric W. Biederman unsigned c = *name++ - '0'; 159328a6d671SEric W. Biederman if (c > 9) 159428a6d671SEric W. Biederman goto out; 159528a6d671SEric W. Biederman if (n >= (~0U-9)/10) 159628a6d671SEric W. Biederman goto out; 159728a6d671SEric W. Biederman n *= 10; 159828a6d671SEric W. Biederman n += c; 159928a6d671SEric W. Biederman } 160028a6d671SEric W. Biederman return n; 160128a6d671SEric W. Biederman out: 160228a6d671SEric W. Biederman return ~0U; 160328a6d671SEric W. Biederman } 160428a6d671SEric W. Biederman 160527932742SMiklos Szeredi #define PROC_FDINFO_MAX 64 160627932742SMiklos Szeredi 16073dcd25f3SJan Blunck static int proc_fd_info(struct inode *inode, struct path *path, char *info) 160828a6d671SEric W. Biederman { 160928a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 161028a6d671SEric W. Biederman struct files_struct *files = NULL; 161128a6d671SEric W. Biederman struct file *file; 161228a6d671SEric W. Biederman int fd = proc_fd(inode); 161328a6d671SEric W. Biederman 161428a6d671SEric W. Biederman if (task) { 161528a6d671SEric W. Biederman files = get_files_struct(task); 161628a6d671SEric W. Biederman put_task_struct(task); 161728a6d671SEric W. Biederman } 161828a6d671SEric W. Biederman if (files) { 161928a6d671SEric W. Biederman /* 162028a6d671SEric W. Biederman * We are not taking a ref to the file structure, so we must 162128a6d671SEric W. Biederman * hold ->file_lock. 162228a6d671SEric W. Biederman */ 162328a6d671SEric W. Biederman spin_lock(&files->file_lock); 162428a6d671SEric W. Biederman file = fcheck_files(files, fd); 162528a6d671SEric W. Biederman if (file) { 16263dcd25f3SJan Blunck if (path) { 16273dcd25f3SJan Blunck *path = file->f_path; 16283dcd25f3SJan Blunck path_get(&file->f_path); 16293dcd25f3SJan Blunck } 163027932742SMiklos Szeredi if (info) 163127932742SMiklos Szeredi snprintf(info, PROC_FDINFO_MAX, 163227932742SMiklos Szeredi "pos:\t%lli\n" 163327932742SMiklos Szeredi "flags:\t0%o\n", 163427932742SMiklos Szeredi (long long) file->f_pos, 163527932742SMiklos Szeredi file->f_flags); 163628a6d671SEric W. Biederman spin_unlock(&files->file_lock); 163728a6d671SEric W. Biederman put_files_struct(files); 163828a6d671SEric W. Biederman return 0; 163928a6d671SEric W. Biederman } 164028a6d671SEric W. Biederman spin_unlock(&files->file_lock); 164128a6d671SEric W. Biederman put_files_struct(files); 164228a6d671SEric W. Biederman } 164328a6d671SEric W. Biederman return -ENOENT; 164428a6d671SEric W. Biederman } 164528a6d671SEric W. Biederman 16463dcd25f3SJan Blunck static int proc_fd_link(struct inode *inode, struct path *path) 164727932742SMiklos Szeredi { 16483dcd25f3SJan Blunck return proc_fd_info(inode, path, NULL); 164927932742SMiklos Szeredi } 165027932742SMiklos Szeredi 165128a6d671SEric W. Biederman static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd) 165228a6d671SEric W. Biederman { 165328a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 165428a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 165528a6d671SEric W. Biederman int fd = proc_fd(inode); 165628a6d671SEric W. Biederman struct files_struct *files; 1657c69e8d9cSDavid Howells const struct cred *cred; 165828a6d671SEric W. Biederman 165928a6d671SEric W. Biederman if (task) { 166028a6d671SEric W. Biederman files = get_files_struct(task); 166128a6d671SEric W. Biederman if (files) { 166228a6d671SEric W. Biederman rcu_read_lock(); 166328a6d671SEric W. Biederman if (fcheck_files(files, fd)) { 166428a6d671SEric W. Biederman rcu_read_unlock(); 166528a6d671SEric W. Biederman put_files_struct(files); 166628a6d671SEric W. Biederman if (task_dumpable(task)) { 1667c69e8d9cSDavid Howells rcu_read_lock(); 1668c69e8d9cSDavid Howells cred = __task_cred(task); 1669c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1670c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1671c69e8d9cSDavid Howells rcu_read_unlock(); 167228a6d671SEric W. Biederman } else { 167328a6d671SEric W. Biederman inode->i_uid = 0; 167428a6d671SEric W. Biederman inode->i_gid = 0; 167528a6d671SEric W. Biederman } 167628a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 167728a6d671SEric W. Biederman security_task_to_inode(task, inode); 167828a6d671SEric W. Biederman put_task_struct(task); 167928a6d671SEric W. Biederman return 1; 168028a6d671SEric W. Biederman } 168128a6d671SEric W. Biederman rcu_read_unlock(); 168228a6d671SEric W. Biederman put_files_struct(files); 168328a6d671SEric W. Biederman } 168428a6d671SEric W. Biederman put_task_struct(task); 168528a6d671SEric W. Biederman } 168628a6d671SEric W. Biederman d_drop(dentry); 168728a6d671SEric W. Biederman return 0; 168828a6d671SEric W. Biederman } 168928a6d671SEric W. Biederman 169028a6d671SEric W. Biederman static struct dentry_operations tid_fd_dentry_operations = 169128a6d671SEric W. Biederman { 169228a6d671SEric W. Biederman .d_revalidate = tid_fd_revalidate, 169328a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 169428a6d671SEric W. Biederman }; 169528a6d671SEric W. Biederman 1696444ceed8SEric W. Biederman static struct dentry *proc_fd_instantiate(struct inode *dir, 1697c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 169828a6d671SEric W. Biederman { 1699c5141e6dSEric Dumazet unsigned fd = *(const unsigned *)ptr; 170028a6d671SEric W. Biederman struct file *file; 170128a6d671SEric W. Biederman struct files_struct *files; 170228a6d671SEric W. Biederman struct inode *inode; 170328a6d671SEric W. Biederman struct proc_inode *ei; 1704444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-ENOENT); 170528a6d671SEric W. Biederman 170661a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 170728a6d671SEric W. Biederman if (!inode) 170828a6d671SEric W. Biederman goto out; 170928a6d671SEric W. Biederman ei = PROC_I(inode); 171028a6d671SEric W. Biederman ei->fd = fd; 171128a6d671SEric W. Biederman files = get_files_struct(task); 171228a6d671SEric W. Biederman if (!files) 1713444ceed8SEric W. Biederman goto out_iput; 171428a6d671SEric W. Biederman inode->i_mode = S_IFLNK; 171528a6d671SEric W. Biederman 171628a6d671SEric W. Biederman /* 171728a6d671SEric W. Biederman * We are not taking a ref to the file structure, so we must 171828a6d671SEric W. Biederman * hold ->file_lock. 171928a6d671SEric W. Biederman */ 172028a6d671SEric W. Biederman spin_lock(&files->file_lock); 172128a6d671SEric W. Biederman file = fcheck_files(files, fd); 172228a6d671SEric W. Biederman if (!file) 1723444ceed8SEric W. Biederman goto out_unlock; 1724aeb5d727SAl Viro if (file->f_mode & FMODE_READ) 172528a6d671SEric W. Biederman inode->i_mode |= S_IRUSR | S_IXUSR; 1726aeb5d727SAl Viro if (file->f_mode & FMODE_WRITE) 172728a6d671SEric W. Biederman inode->i_mode |= S_IWUSR | S_IXUSR; 172828a6d671SEric W. Biederman spin_unlock(&files->file_lock); 172928a6d671SEric W. Biederman put_files_struct(files); 1730444ceed8SEric W. Biederman 173128a6d671SEric W. Biederman inode->i_op = &proc_pid_link_inode_operations; 173228a6d671SEric W. Biederman inode->i_size = 64; 173328a6d671SEric W. Biederman ei->op.proc_get_link = proc_fd_link; 173428a6d671SEric W. Biederman dentry->d_op = &tid_fd_dentry_operations; 173528a6d671SEric W. Biederman d_add(dentry, inode); 173628a6d671SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 173728a6d671SEric W. Biederman if (tid_fd_revalidate(dentry, NULL)) 1738444ceed8SEric W. Biederman error = NULL; 1739444ceed8SEric W. Biederman 1740444ceed8SEric W. Biederman out: 1741444ceed8SEric W. Biederman return error; 1742444ceed8SEric W. Biederman out_unlock: 1743444ceed8SEric W. Biederman spin_unlock(&files->file_lock); 1744444ceed8SEric W. Biederman put_files_struct(files); 1745444ceed8SEric W. Biederman out_iput: 1746444ceed8SEric W. Biederman iput(inode); 1747444ceed8SEric W. Biederman goto out; 1748444ceed8SEric W. Biederman } 1749444ceed8SEric W. Biederman 175027932742SMiklos Szeredi static struct dentry *proc_lookupfd_common(struct inode *dir, 175127932742SMiklos Szeredi struct dentry *dentry, 175227932742SMiklos Szeredi instantiate_t instantiate) 1753444ceed8SEric W. Biederman { 1754444ceed8SEric W. Biederman struct task_struct *task = get_proc_task(dir); 1755444ceed8SEric W. Biederman unsigned fd = name_to_int(dentry); 1756444ceed8SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 1757444ceed8SEric W. Biederman 1758444ceed8SEric W. Biederman if (!task) 1759444ceed8SEric W. Biederman goto out_no_task; 1760444ceed8SEric W. Biederman if (fd == ~0U) 1761444ceed8SEric W. Biederman goto out; 1762444ceed8SEric W. Biederman 176327932742SMiklos Szeredi result = instantiate(dir, dentry, task, &fd); 176428a6d671SEric W. Biederman out: 176528a6d671SEric W. Biederman put_task_struct(task); 176628a6d671SEric W. Biederman out_no_task: 176728a6d671SEric W. Biederman return result; 176828a6d671SEric W. Biederman } 176928a6d671SEric W. Biederman 177027932742SMiklos Szeredi static int proc_readfd_common(struct file * filp, void * dirent, 177127932742SMiklos Szeredi filldir_t filldir, instantiate_t instantiate) 17721da177e4SLinus Torvalds { 17732fddfeefSJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 17745634708bSEric W. Biederman struct inode *inode = dentry->d_inode; 177599f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 1776457c2510SPavel Emelyanov unsigned int fd, ino; 17771da177e4SLinus Torvalds int retval; 17781da177e4SLinus Torvalds struct files_struct * files; 17791da177e4SLinus Torvalds 17801da177e4SLinus Torvalds retval = -ENOENT; 178199f89551SEric W. Biederman if (!p) 178299f89551SEric W. Biederman goto out_no_task; 17831da177e4SLinus Torvalds retval = 0; 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds fd = filp->f_pos; 17861da177e4SLinus Torvalds switch (fd) { 17871da177e4SLinus Torvalds case 0: 17881da177e4SLinus Torvalds if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 17891da177e4SLinus Torvalds goto out; 17901da177e4SLinus Torvalds filp->f_pos++; 17911da177e4SLinus Torvalds case 1: 17925634708bSEric W. Biederman ino = parent_ino(dentry); 17931da177e4SLinus Torvalds if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0) 17941da177e4SLinus Torvalds goto out; 17951da177e4SLinus Torvalds filp->f_pos++; 17961da177e4SLinus Torvalds default: 17971da177e4SLinus Torvalds files = get_files_struct(p); 17981da177e4SLinus Torvalds if (!files) 17991da177e4SLinus Torvalds goto out; 1800b835996fSDipankar Sarma rcu_read_lock(); 18011da177e4SLinus Torvalds for (fd = filp->f_pos-2; 18029b4f526cSAl Viro fd < files_fdtable(files)->max_fds; 18031da177e4SLinus Torvalds fd++, filp->f_pos++) { 180427932742SMiklos Szeredi char name[PROC_NUMBUF]; 180527932742SMiklos Szeredi int len; 18061da177e4SLinus Torvalds 18071da177e4SLinus Torvalds if (!fcheck_files(files, fd)) 18081da177e4SLinus Torvalds continue; 1809b835996fSDipankar Sarma rcu_read_unlock(); 18101da177e4SLinus Torvalds 181127932742SMiklos Szeredi len = snprintf(name, sizeof(name), "%d", fd); 181227932742SMiklos Szeredi if (proc_fill_cache(filp, dirent, filldir, 181327932742SMiklos Szeredi name, len, instantiate, 181427932742SMiklos Szeredi p, &fd) < 0) { 1815b835996fSDipankar Sarma rcu_read_lock(); 18161da177e4SLinus Torvalds break; 18171da177e4SLinus Torvalds } 1818b835996fSDipankar Sarma rcu_read_lock(); 18191da177e4SLinus Torvalds } 1820b835996fSDipankar Sarma rcu_read_unlock(); 18211da177e4SLinus Torvalds put_files_struct(files); 18221da177e4SLinus Torvalds } 18231da177e4SLinus Torvalds out: 182499f89551SEric W. Biederman put_task_struct(p); 182599f89551SEric W. Biederman out_no_task: 18261da177e4SLinus Torvalds return retval; 18271da177e4SLinus Torvalds } 18281da177e4SLinus Torvalds 182927932742SMiklos Szeredi static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry, 183027932742SMiklos Szeredi struct nameidata *nd) 183127932742SMiklos Szeredi { 183227932742SMiklos Szeredi return proc_lookupfd_common(dir, dentry, proc_fd_instantiate); 183327932742SMiklos Szeredi } 183427932742SMiklos Szeredi 183527932742SMiklos Szeredi static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir) 183627932742SMiklos Szeredi { 183727932742SMiklos Szeredi return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate); 183827932742SMiklos Szeredi } 183927932742SMiklos Szeredi 184027932742SMiklos Szeredi static ssize_t proc_fdinfo_read(struct file *file, char __user *buf, 184127932742SMiklos Szeredi size_t len, loff_t *ppos) 184227932742SMiklos Szeredi { 184327932742SMiklos Szeredi char tmp[PROC_FDINFO_MAX]; 18443dcd25f3SJan Blunck int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, tmp); 184527932742SMiklos Szeredi if (!err) 184627932742SMiklos Szeredi err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp)); 184727932742SMiklos Szeredi return err; 184827932742SMiklos Szeredi } 184927932742SMiklos Szeredi 185027932742SMiklos Szeredi static const struct file_operations proc_fdinfo_file_operations = { 185127932742SMiklos Szeredi .open = nonseekable_open, 185227932742SMiklos Szeredi .read = proc_fdinfo_read, 185327932742SMiklos Szeredi }; 185427932742SMiklos Szeredi 185500977a59SArjan van de Ven static const struct file_operations proc_fd_operations = { 18561da177e4SLinus Torvalds .read = generic_read_dir, 18571da177e4SLinus Torvalds .readdir = proc_readfd, 18581da177e4SLinus Torvalds }; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds /* 18618948e11fSAlexey Dobriyan * /proc/pid/fd needs a special permission handler so that a process can still 18628948e11fSAlexey Dobriyan * access /proc/self/fd after it has executed a setuid(). 18638948e11fSAlexey Dobriyan */ 1864e6305c43SAl Viro static int proc_fd_permission(struct inode *inode, int mask) 18658948e11fSAlexey Dobriyan { 18668948e11fSAlexey Dobriyan int rv; 18678948e11fSAlexey Dobriyan 18688948e11fSAlexey Dobriyan rv = generic_permission(inode, mask, NULL); 18698948e11fSAlexey Dobriyan if (rv == 0) 18708948e11fSAlexey Dobriyan return 0; 18718948e11fSAlexey Dobriyan if (task_pid(current) == proc_pid(inode)) 18728948e11fSAlexey Dobriyan rv = 0; 18738948e11fSAlexey Dobriyan return rv; 18748948e11fSAlexey Dobriyan } 18758948e11fSAlexey Dobriyan 18768948e11fSAlexey Dobriyan /* 18771da177e4SLinus Torvalds * proc directories can do almost nothing.. 18781da177e4SLinus Torvalds */ 1879c5ef1c42SArjan van de Ven static const struct inode_operations proc_fd_inode_operations = { 18801da177e4SLinus Torvalds .lookup = proc_lookupfd, 18818948e11fSAlexey Dobriyan .permission = proc_fd_permission, 18826d76fa58SLinus Torvalds .setattr = proc_setattr, 18831da177e4SLinus Torvalds }; 18841da177e4SLinus Torvalds 188527932742SMiklos Szeredi static struct dentry *proc_fdinfo_instantiate(struct inode *dir, 188627932742SMiklos Szeredi struct dentry *dentry, struct task_struct *task, const void *ptr) 188727932742SMiklos Szeredi { 188827932742SMiklos Szeredi unsigned fd = *(unsigned *)ptr; 188927932742SMiklos Szeredi struct inode *inode; 189027932742SMiklos Szeredi struct proc_inode *ei; 189127932742SMiklos Szeredi struct dentry *error = ERR_PTR(-ENOENT); 189227932742SMiklos Szeredi 189327932742SMiklos Szeredi inode = proc_pid_make_inode(dir->i_sb, task); 189427932742SMiklos Szeredi if (!inode) 189527932742SMiklos Szeredi goto out; 189627932742SMiklos Szeredi ei = PROC_I(inode); 189727932742SMiklos Szeredi ei->fd = fd; 189827932742SMiklos Szeredi inode->i_mode = S_IFREG | S_IRUSR; 189927932742SMiklos Szeredi inode->i_fop = &proc_fdinfo_file_operations; 190027932742SMiklos Szeredi dentry->d_op = &tid_fd_dentry_operations; 190127932742SMiklos Szeredi d_add(dentry, inode); 190227932742SMiklos Szeredi /* Close the race of the process dying before we return the dentry */ 190327932742SMiklos Szeredi if (tid_fd_revalidate(dentry, NULL)) 190427932742SMiklos Szeredi error = NULL; 190527932742SMiklos Szeredi 190627932742SMiklos Szeredi out: 190727932742SMiklos Szeredi return error; 190827932742SMiklos Szeredi } 190927932742SMiklos Szeredi 191027932742SMiklos Szeredi static struct dentry *proc_lookupfdinfo(struct inode *dir, 191127932742SMiklos Szeredi struct dentry *dentry, 191227932742SMiklos Szeredi struct nameidata *nd) 191327932742SMiklos Szeredi { 191427932742SMiklos Szeredi return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate); 191527932742SMiklos Szeredi } 191627932742SMiklos Szeredi 191727932742SMiklos Szeredi static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir) 191827932742SMiklos Szeredi { 191927932742SMiklos Szeredi return proc_readfd_common(filp, dirent, filldir, 192027932742SMiklos Szeredi proc_fdinfo_instantiate); 192127932742SMiklos Szeredi } 192227932742SMiklos Szeredi 192327932742SMiklos Szeredi static const struct file_operations proc_fdinfo_operations = { 192427932742SMiklos Szeredi .read = generic_read_dir, 192527932742SMiklos Szeredi .readdir = proc_readfdinfo, 192627932742SMiklos Szeredi }; 192727932742SMiklos Szeredi 192827932742SMiklos Szeredi /* 192927932742SMiklos Szeredi * proc directories can do almost nothing.. 193027932742SMiklos Szeredi */ 193127932742SMiklos Szeredi static const struct inode_operations proc_fdinfo_inode_operations = { 193227932742SMiklos Szeredi .lookup = proc_lookupfdinfo, 193327932742SMiklos Szeredi .setattr = proc_setattr, 193427932742SMiklos Szeredi }; 193527932742SMiklos Szeredi 193627932742SMiklos Szeredi 1937444ceed8SEric W. Biederman static struct dentry *proc_pident_instantiate(struct inode *dir, 1938c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 1939444ceed8SEric W. Biederman { 1940c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 1941444ceed8SEric W. Biederman struct inode *inode; 1942444ceed8SEric W. Biederman struct proc_inode *ei; 1943444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-EINVAL); 1944444ceed8SEric W. Biederman 194561a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 1946444ceed8SEric W. Biederman if (!inode) 1947444ceed8SEric W. Biederman goto out; 1948444ceed8SEric W. Biederman 1949444ceed8SEric W. Biederman ei = PROC_I(inode); 1950444ceed8SEric W. Biederman inode->i_mode = p->mode; 1951444ceed8SEric W. Biederman if (S_ISDIR(inode->i_mode)) 1952444ceed8SEric W. Biederman inode->i_nlink = 2; /* Use getattr to fix if necessary */ 1953444ceed8SEric W. Biederman if (p->iop) 1954444ceed8SEric W. Biederman inode->i_op = p->iop; 1955444ceed8SEric W. Biederman if (p->fop) 1956444ceed8SEric W. Biederman inode->i_fop = p->fop; 1957444ceed8SEric W. Biederman ei->op = p->op; 1958444ceed8SEric W. Biederman dentry->d_op = &pid_dentry_operations; 1959444ceed8SEric W. Biederman d_add(dentry, inode); 1960444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 1961444ceed8SEric W. Biederman if (pid_revalidate(dentry, NULL)) 1962444ceed8SEric W. Biederman error = NULL; 1963444ceed8SEric W. Biederman out: 1964444ceed8SEric W. Biederman return error; 1965444ceed8SEric W. Biederman } 1966444ceed8SEric W. Biederman 19671da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 19681da177e4SLinus Torvalds struct dentry *dentry, 1969c5141e6dSEric Dumazet const struct pid_entry *ents, 19707bcd6b0eSEric W. Biederman unsigned int nents) 19711da177e4SLinus Torvalds { 19721da177e4SLinus Torvalds struct inode *inode; 1973cd6a3ce9SEric W. Biederman struct dentry *error; 197499f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 1975c5141e6dSEric Dumazet const struct pid_entry *p, *last; 19761da177e4SLinus Torvalds 1977cd6a3ce9SEric W. Biederman error = ERR_PTR(-ENOENT); 19781da177e4SLinus Torvalds inode = NULL; 19791da177e4SLinus Torvalds 198099f89551SEric W. Biederman if (!task) 198199f89551SEric W. Biederman goto out_no_task; 19821da177e4SLinus Torvalds 198320cdc894SEric W. Biederman /* 198420cdc894SEric W. Biederman * Yes, it does not scale. And it should not. Don't add 198520cdc894SEric W. Biederman * new entries into /proc/<tgid>/ without very good reasons. 198620cdc894SEric W. Biederman */ 19877bcd6b0eSEric W. Biederman last = &ents[nents - 1]; 19887bcd6b0eSEric W. Biederman for (p = ents; p <= last; p++) { 19891da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 19901da177e4SLinus Torvalds continue; 19911da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 19921da177e4SLinus Torvalds break; 19931da177e4SLinus Torvalds } 19947bcd6b0eSEric W. Biederman if (p > last) 19951da177e4SLinus Torvalds goto out; 19961da177e4SLinus Torvalds 1997444ceed8SEric W. Biederman error = proc_pident_instantiate(dir, dentry, task, p); 19981da177e4SLinus Torvalds out: 199999f89551SEric W. Biederman put_task_struct(task); 200099f89551SEric W. Biederman out_no_task: 2001cd6a3ce9SEric W. Biederman return error; 20021da177e4SLinus Torvalds } 20031da177e4SLinus Torvalds 2004c5141e6dSEric Dumazet static int proc_pident_fill_cache(struct file *filp, void *dirent, 2005c5141e6dSEric Dumazet filldir_t filldir, struct task_struct *task, const struct pid_entry *p) 200661a28784SEric W. Biederman { 200761a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, p->name, p->len, 200861a28784SEric W. Biederman proc_pident_instantiate, task, p); 200961a28784SEric W. Biederman } 201061a28784SEric W. Biederman 201128a6d671SEric W. Biederman static int proc_pident_readdir(struct file *filp, 201228a6d671SEric W. Biederman void *dirent, filldir_t filldir, 2013c5141e6dSEric Dumazet const struct pid_entry *ents, unsigned int nents) 201428a6d671SEric W. Biederman { 201528a6d671SEric W. Biederman int i; 20162fddfeefSJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 201728a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 201828a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 2019c5141e6dSEric Dumazet const struct pid_entry *p, *last; 202028a6d671SEric W. Biederman ino_t ino; 202128a6d671SEric W. Biederman int ret; 202228a6d671SEric W. Biederman 202328a6d671SEric W. Biederman ret = -ENOENT; 202428a6d671SEric W. Biederman if (!task) 202561a28784SEric W. Biederman goto out_no_task; 202628a6d671SEric W. Biederman 202728a6d671SEric W. Biederman ret = 0; 202828a6d671SEric W. Biederman i = filp->f_pos; 202928a6d671SEric W. Biederman switch (i) { 203028a6d671SEric W. Biederman case 0: 203128a6d671SEric W. Biederman ino = inode->i_ino; 203228a6d671SEric W. Biederman if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 203328a6d671SEric W. Biederman goto out; 203428a6d671SEric W. Biederman i++; 203528a6d671SEric W. Biederman filp->f_pos++; 203628a6d671SEric W. Biederman /* fall through */ 203728a6d671SEric W. Biederman case 1: 203828a6d671SEric W. Biederman ino = parent_ino(dentry); 203928a6d671SEric W. Biederman if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 204028a6d671SEric W. Biederman goto out; 204128a6d671SEric W. Biederman i++; 204228a6d671SEric W. Biederman filp->f_pos++; 204328a6d671SEric W. Biederman /* fall through */ 204428a6d671SEric W. Biederman default: 204528a6d671SEric W. Biederman i -= 2; 204628a6d671SEric W. Biederman if (i >= nents) { 204728a6d671SEric W. Biederman ret = 1; 204828a6d671SEric W. Biederman goto out; 204928a6d671SEric W. Biederman } 205028a6d671SEric W. Biederman p = ents + i; 20517bcd6b0eSEric W. Biederman last = &ents[nents - 1]; 20527bcd6b0eSEric W. Biederman while (p <= last) { 205361a28784SEric W. Biederman if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0) 205428a6d671SEric W. Biederman goto out; 205528a6d671SEric W. Biederman filp->f_pos++; 205628a6d671SEric W. Biederman p++; 205728a6d671SEric W. Biederman } 20581da177e4SLinus Torvalds } 20591da177e4SLinus Torvalds 206028a6d671SEric W. Biederman ret = 1; 206128a6d671SEric W. Biederman out: 206261a28784SEric W. Biederman put_task_struct(task); 206361a28784SEric W. Biederman out_no_task: 206428a6d671SEric W. Biederman return ret; 20651da177e4SLinus Torvalds } 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 206828a6d671SEric W. Biederman static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 206928a6d671SEric W. Biederman size_t count, loff_t *ppos) 207028a6d671SEric W. Biederman { 20712fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 207204ff9708SAl Viro char *p = NULL; 207328a6d671SEric W. Biederman ssize_t length; 207428a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 207528a6d671SEric W. Biederman 207628a6d671SEric W. Biederman if (!task) 207704ff9708SAl Viro return -ESRCH; 207828a6d671SEric W. Biederman 207928a6d671SEric W. Biederman length = security_getprocattr(task, 20802fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 208104ff9708SAl Viro &p); 208228a6d671SEric W. Biederman put_task_struct(task); 208304ff9708SAl Viro if (length > 0) 208404ff9708SAl Viro length = simple_read_from_buffer(buf, count, ppos, p, length); 208504ff9708SAl Viro kfree(p); 208628a6d671SEric W. Biederman return length; 208728a6d671SEric W. Biederman } 208828a6d671SEric W. Biederman 208928a6d671SEric W. Biederman static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 209028a6d671SEric W. Biederman size_t count, loff_t *ppos) 209128a6d671SEric W. Biederman { 20922fddfeefSJosef "Jeff" Sipek struct inode * inode = file->f_path.dentry->d_inode; 209328a6d671SEric W. Biederman char *page; 209428a6d671SEric W. Biederman ssize_t length; 209528a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 209628a6d671SEric W. Biederman 209728a6d671SEric W. Biederman length = -ESRCH; 209828a6d671SEric W. Biederman if (!task) 209928a6d671SEric W. Biederman goto out_no_task; 210028a6d671SEric W. Biederman if (count > PAGE_SIZE) 210128a6d671SEric W. Biederman count = PAGE_SIZE; 210228a6d671SEric W. Biederman 210328a6d671SEric W. Biederman /* No partial writes. */ 210428a6d671SEric W. Biederman length = -EINVAL; 210528a6d671SEric W. Biederman if (*ppos != 0) 210628a6d671SEric W. Biederman goto out; 210728a6d671SEric W. Biederman 210828a6d671SEric W. Biederman length = -ENOMEM; 2109e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 211028a6d671SEric W. Biederman if (!page) 211128a6d671SEric W. Biederman goto out; 211228a6d671SEric W. Biederman 211328a6d671SEric W. Biederman length = -EFAULT; 211428a6d671SEric W. Biederman if (copy_from_user(page, buf, count)) 211528a6d671SEric W. Biederman goto out_free; 211628a6d671SEric W. Biederman 211728a6d671SEric W. Biederman length = security_setprocattr(task, 21182fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 211928a6d671SEric W. Biederman (void*)page, count); 212028a6d671SEric W. Biederman out_free: 212128a6d671SEric W. Biederman free_page((unsigned long) page); 212228a6d671SEric W. Biederman out: 212328a6d671SEric W. Biederman put_task_struct(task); 212428a6d671SEric W. Biederman out_no_task: 212528a6d671SEric W. Biederman return length; 212628a6d671SEric W. Biederman } 212728a6d671SEric W. Biederman 212800977a59SArjan van de Ven static const struct file_operations proc_pid_attr_operations = { 212928a6d671SEric W. Biederman .read = proc_pid_attr_read, 213028a6d671SEric W. Biederman .write = proc_pid_attr_write, 213128a6d671SEric W. Biederman }; 213228a6d671SEric W. Biederman 2133c5141e6dSEric Dumazet static const struct pid_entry attr_dir_stuff[] = { 2134*631f9c18SAlexey Dobriyan REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2135*631f9c18SAlexey Dobriyan REG("prev", S_IRUGO, proc_pid_attr_operations), 2136*631f9c18SAlexey Dobriyan REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2137*631f9c18SAlexey Dobriyan REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2138*631f9c18SAlexey Dobriyan REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2139*631f9c18SAlexey Dobriyan REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 214028a6d671SEric W. Biederman }; 214128a6d671SEric W. Biederman 214272d9dcfcSEric W. Biederman static int proc_attr_dir_readdir(struct file * filp, 21431da177e4SLinus Torvalds void * dirent, filldir_t filldir) 21441da177e4SLinus Torvalds { 21451da177e4SLinus Torvalds return proc_pident_readdir(filp,dirent,filldir, 214672d9dcfcSEric W. Biederman attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff)); 21471da177e4SLinus Torvalds } 21481da177e4SLinus Torvalds 214900977a59SArjan van de Ven static const struct file_operations proc_attr_dir_operations = { 21501da177e4SLinus Torvalds .read = generic_read_dir, 215172d9dcfcSEric W. Biederman .readdir = proc_attr_dir_readdir, 21521da177e4SLinus Torvalds }; 21531da177e4SLinus Torvalds 215472d9dcfcSEric W. Biederman static struct dentry *proc_attr_dir_lookup(struct inode *dir, 21551da177e4SLinus Torvalds struct dentry *dentry, struct nameidata *nd) 21561da177e4SLinus Torvalds { 21577bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 21587bcd6b0eSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 21591da177e4SLinus Torvalds } 21601da177e4SLinus Torvalds 2161c5ef1c42SArjan van de Ven static const struct inode_operations proc_attr_dir_inode_operations = { 216272d9dcfcSEric W. Biederman .lookup = proc_attr_dir_lookup, 216399f89551SEric W. Biederman .getattr = pid_getattr, 21646d76fa58SLinus Torvalds .setattr = proc_setattr, 21651da177e4SLinus Torvalds }; 21661da177e4SLinus Torvalds 21671da177e4SLinus Torvalds #endif 21681da177e4SLinus Torvalds 21693cb4a0bbSKawai, Hidehiro #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE) 21703cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, 21713cb4a0bbSKawai, Hidehiro size_t count, loff_t *ppos) 21723cb4a0bbSKawai, Hidehiro { 21733cb4a0bbSKawai, Hidehiro struct task_struct *task = get_proc_task(file->f_dentry->d_inode); 21743cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 21753cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF]; 21763cb4a0bbSKawai, Hidehiro size_t len; 21773cb4a0bbSKawai, Hidehiro int ret; 21783cb4a0bbSKawai, Hidehiro 21793cb4a0bbSKawai, Hidehiro if (!task) 21803cb4a0bbSKawai, Hidehiro return -ESRCH; 21813cb4a0bbSKawai, Hidehiro 21823cb4a0bbSKawai, Hidehiro ret = 0; 21833cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 21843cb4a0bbSKawai, Hidehiro if (mm) { 21853cb4a0bbSKawai, Hidehiro len = snprintf(buffer, sizeof(buffer), "%08lx\n", 21863cb4a0bbSKawai, Hidehiro ((mm->flags & MMF_DUMP_FILTER_MASK) >> 21873cb4a0bbSKawai, Hidehiro MMF_DUMP_FILTER_SHIFT)); 21883cb4a0bbSKawai, Hidehiro mmput(mm); 21893cb4a0bbSKawai, Hidehiro ret = simple_read_from_buffer(buf, count, ppos, buffer, len); 21903cb4a0bbSKawai, Hidehiro } 21913cb4a0bbSKawai, Hidehiro 21923cb4a0bbSKawai, Hidehiro put_task_struct(task); 21933cb4a0bbSKawai, Hidehiro 21943cb4a0bbSKawai, Hidehiro return ret; 21953cb4a0bbSKawai, Hidehiro } 21963cb4a0bbSKawai, Hidehiro 21973cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_write(struct file *file, 21983cb4a0bbSKawai, Hidehiro const char __user *buf, 21993cb4a0bbSKawai, Hidehiro size_t count, 22003cb4a0bbSKawai, Hidehiro loff_t *ppos) 22013cb4a0bbSKawai, Hidehiro { 22023cb4a0bbSKawai, Hidehiro struct task_struct *task; 22033cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 22043cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF], *end; 22053cb4a0bbSKawai, Hidehiro unsigned int val; 22063cb4a0bbSKawai, Hidehiro int ret; 22073cb4a0bbSKawai, Hidehiro int i; 22083cb4a0bbSKawai, Hidehiro unsigned long mask; 22093cb4a0bbSKawai, Hidehiro 22103cb4a0bbSKawai, Hidehiro ret = -EFAULT; 22113cb4a0bbSKawai, Hidehiro memset(buffer, 0, sizeof(buffer)); 22123cb4a0bbSKawai, Hidehiro if (count > sizeof(buffer) - 1) 22133cb4a0bbSKawai, Hidehiro count = sizeof(buffer) - 1; 22143cb4a0bbSKawai, Hidehiro if (copy_from_user(buffer, buf, count)) 22153cb4a0bbSKawai, Hidehiro goto out_no_task; 22163cb4a0bbSKawai, Hidehiro 22173cb4a0bbSKawai, Hidehiro ret = -EINVAL; 22183cb4a0bbSKawai, Hidehiro val = (unsigned int)simple_strtoul(buffer, &end, 0); 22193cb4a0bbSKawai, Hidehiro if (*end == '\n') 22203cb4a0bbSKawai, Hidehiro end++; 22213cb4a0bbSKawai, Hidehiro if (end - buffer == 0) 22223cb4a0bbSKawai, Hidehiro goto out_no_task; 22233cb4a0bbSKawai, Hidehiro 22243cb4a0bbSKawai, Hidehiro ret = -ESRCH; 22253cb4a0bbSKawai, Hidehiro task = get_proc_task(file->f_dentry->d_inode); 22263cb4a0bbSKawai, Hidehiro if (!task) 22273cb4a0bbSKawai, Hidehiro goto out_no_task; 22283cb4a0bbSKawai, Hidehiro 22293cb4a0bbSKawai, Hidehiro ret = end - buffer; 22303cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 22313cb4a0bbSKawai, Hidehiro if (!mm) 22323cb4a0bbSKawai, Hidehiro goto out_no_mm; 22333cb4a0bbSKawai, Hidehiro 22343cb4a0bbSKawai, Hidehiro for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) { 22353cb4a0bbSKawai, Hidehiro if (val & mask) 22363cb4a0bbSKawai, Hidehiro set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 22373cb4a0bbSKawai, Hidehiro else 22383cb4a0bbSKawai, Hidehiro clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 22393cb4a0bbSKawai, Hidehiro } 22403cb4a0bbSKawai, Hidehiro 22413cb4a0bbSKawai, Hidehiro mmput(mm); 22423cb4a0bbSKawai, Hidehiro out_no_mm: 22433cb4a0bbSKawai, Hidehiro put_task_struct(task); 22443cb4a0bbSKawai, Hidehiro out_no_task: 22453cb4a0bbSKawai, Hidehiro return ret; 22463cb4a0bbSKawai, Hidehiro } 22473cb4a0bbSKawai, Hidehiro 22483cb4a0bbSKawai, Hidehiro static const struct file_operations proc_coredump_filter_operations = { 22493cb4a0bbSKawai, Hidehiro .read = proc_coredump_filter_read, 22503cb4a0bbSKawai, Hidehiro .write = proc_coredump_filter_write, 22513cb4a0bbSKawai, Hidehiro }; 22523cb4a0bbSKawai, Hidehiro #endif 22533cb4a0bbSKawai, Hidehiro 22541da177e4SLinus Torvalds /* 22551da177e4SLinus Torvalds * /proc/self: 22561da177e4SLinus Torvalds */ 22571da177e4SLinus Torvalds static int proc_self_readlink(struct dentry *dentry, char __user *buffer, 22581da177e4SLinus Torvalds int buflen) 22591da177e4SLinus Torvalds { 2260488e5bc4SEric W. Biederman struct pid_namespace *ns = dentry->d_sb->s_fs_info; 2261b55fcb22SAndrew Morton pid_t tgid = task_tgid_nr_ns(current, ns); 22628578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 2263b55fcb22SAndrew Morton if (!tgid) 2264488e5bc4SEric W. Biederman return -ENOENT; 2265b55fcb22SAndrew Morton sprintf(tmp, "%d", tgid); 22661da177e4SLinus Torvalds return vfs_readlink(dentry,buffer,buflen,tmp); 22671da177e4SLinus Torvalds } 22681da177e4SLinus Torvalds 2269008b150aSAl Viro static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd) 22701da177e4SLinus Torvalds { 2271488e5bc4SEric W. Biederman struct pid_namespace *ns = dentry->d_sb->s_fs_info; 2272b55fcb22SAndrew Morton pid_t tgid = task_tgid_nr_ns(current, ns); 22738578cea7SEric W. Biederman char tmp[PROC_NUMBUF]; 2274b55fcb22SAndrew Morton if (!tgid) 2275488e5bc4SEric W. Biederman return ERR_PTR(-ENOENT); 2276b55fcb22SAndrew Morton sprintf(tmp, "%d", task_tgid_nr_ns(current, ns)); 2277008b150aSAl Viro return ERR_PTR(vfs_follow_link(nd,tmp)); 22781da177e4SLinus Torvalds } 22791da177e4SLinus Torvalds 2280c5ef1c42SArjan van de Ven static const struct inode_operations proc_self_inode_operations = { 22811da177e4SLinus Torvalds .readlink = proc_self_readlink, 22821da177e4SLinus Torvalds .follow_link = proc_self_follow_link, 22831da177e4SLinus Torvalds }; 22841da177e4SLinus Torvalds 228528a6d671SEric W. Biederman /* 2286801199ceSEric W. Biederman * proc base 2287801199ceSEric W. Biederman * 2288801199ceSEric W. Biederman * These are the directory entries in the root directory of /proc 2289801199ceSEric W. Biederman * that properly belong to the /proc filesystem, as they describe 2290801199ceSEric W. Biederman * describe something that is process related. 2291801199ceSEric W. Biederman */ 2292c5141e6dSEric Dumazet static const struct pid_entry proc_base_stuff[] = { 229361a28784SEric W. Biederman NOD("self", S_IFLNK|S_IRWXUGO, 2294801199ceSEric W. Biederman &proc_self_inode_operations, NULL, {}), 2295801199ceSEric W. Biederman }; 2296801199ceSEric W. Biederman 2297801199ceSEric W. Biederman /* 2298801199ceSEric W. Biederman * Exceptional case: normally we are not allowed to unhash a busy 2299801199ceSEric W. Biederman * directory. In this case, however, we can do it - no aliasing problems 2300801199ceSEric W. Biederman * due to the way we treat inodes. 2301801199ceSEric W. Biederman */ 2302801199ceSEric W. Biederman static int proc_base_revalidate(struct dentry *dentry, struct nameidata *nd) 2303801199ceSEric W. Biederman { 2304801199ceSEric W. Biederman struct inode *inode = dentry->d_inode; 2305801199ceSEric W. Biederman struct task_struct *task = get_proc_task(inode); 2306801199ceSEric W. Biederman if (task) { 2307801199ceSEric W. Biederman put_task_struct(task); 2308801199ceSEric W. Biederman return 1; 2309801199ceSEric W. Biederman } 2310801199ceSEric W. Biederman d_drop(dentry); 2311801199ceSEric W. Biederman return 0; 2312801199ceSEric W. Biederman } 2313801199ceSEric W. Biederman 2314801199ceSEric W. Biederman static struct dentry_operations proc_base_dentry_operations = 2315801199ceSEric W. Biederman { 2316801199ceSEric W. Biederman .d_revalidate = proc_base_revalidate, 2317801199ceSEric W. Biederman .d_delete = pid_delete_dentry, 2318801199ceSEric W. Biederman }; 2319801199ceSEric W. Biederman 2320444ceed8SEric W. Biederman static struct dentry *proc_base_instantiate(struct inode *dir, 2321c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2322801199ceSEric W. Biederman { 2323c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2324801199ceSEric W. Biederman struct inode *inode; 2325801199ceSEric W. Biederman struct proc_inode *ei; 2326444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-EINVAL); 2327801199ceSEric W. Biederman 2328801199ceSEric W. Biederman /* Allocate the inode */ 2329801199ceSEric W. Biederman error = ERR_PTR(-ENOMEM); 2330801199ceSEric W. Biederman inode = new_inode(dir->i_sb); 2331801199ceSEric W. Biederman if (!inode) 2332801199ceSEric W. Biederman goto out; 2333801199ceSEric W. Biederman 2334801199ceSEric W. Biederman /* Initialize the inode */ 2335801199ceSEric W. Biederman ei = PROC_I(inode); 2336801199ceSEric W. Biederman inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 2337801199ceSEric W. Biederman 2338801199ceSEric W. Biederman /* 2339801199ceSEric W. Biederman * grab the reference to the task. 2340801199ceSEric W. Biederman */ 23411a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 2342801199ceSEric W. Biederman if (!ei->pid) 2343801199ceSEric W. Biederman goto out_iput; 2344801199ceSEric W. Biederman 2345801199ceSEric W. Biederman inode->i_uid = 0; 2346801199ceSEric W. Biederman inode->i_gid = 0; 2347801199ceSEric W. Biederman inode->i_mode = p->mode; 2348801199ceSEric W. Biederman if (S_ISDIR(inode->i_mode)) 2349801199ceSEric W. Biederman inode->i_nlink = 2; 2350801199ceSEric W. Biederman if (S_ISLNK(inode->i_mode)) 2351801199ceSEric W. Biederman inode->i_size = 64; 2352801199ceSEric W. Biederman if (p->iop) 2353801199ceSEric W. Biederman inode->i_op = p->iop; 2354801199ceSEric W. Biederman if (p->fop) 2355801199ceSEric W. Biederman inode->i_fop = p->fop; 2356801199ceSEric W. Biederman ei->op = p->op; 2357801199ceSEric W. Biederman dentry->d_op = &proc_base_dentry_operations; 2358801199ceSEric W. Biederman d_add(dentry, inode); 2359801199ceSEric W. Biederman error = NULL; 2360801199ceSEric W. Biederman out: 2361801199ceSEric W. Biederman return error; 2362801199ceSEric W. Biederman out_iput: 2363801199ceSEric W. Biederman iput(inode); 2364801199ceSEric W. Biederman goto out; 2365801199ceSEric W. Biederman } 2366801199ceSEric W. Biederman 2367444ceed8SEric W. Biederman static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry) 2368444ceed8SEric W. Biederman { 2369444ceed8SEric W. Biederman struct dentry *error; 2370444ceed8SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2371c5141e6dSEric Dumazet const struct pid_entry *p, *last; 2372444ceed8SEric W. Biederman 2373444ceed8SEric W. Biederman error = ERR_PTR(-ENOENT); 2374444ceed8SEric W. Biederman 2375444ceed8SEric W. Biederman if (!task) 2376444ceed8SEric W. Biederman goto out_no_task; 2377444ceed8SEric W. Biederman 2378444ceed8SEric W. Biederman /* Lookup the directory entry */ 23797bcd6b0eSEric W. Biederman last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1]; 23807bcd6b0eSEric W. Biederman for (p = proc_base_stuff; p <= last; p++) { 2381444ceed8SEric W. Biederman if (p->len != dentry->d_name.len) 2382444ceed8SEric W. Biederman continue; 2383444ceed8SEric W. Biederman if (!memcmp(dentry->d_name.name, p->name, p->len)) 2384444ceed8SEric W. Biederman break; 2385444ceed8SEric W. Biederman } 23867bcd6b0eSEric W. Biederman if (p > last) 2387444ceed8SEric W. Biederman goto out; 2388444ceed8SEric W. Biederman 2389444ceed8SEric W. Biederman error = proc_base_instantiate(dir, dentry, task, p); 2390444ceed8SEric W. Biederman 2391444ceed8SEric W. Biederman out: 2392444ceed8SEric W. Biederman put_task_struct(task); 2393444ceed8SEric W. Biederman out_no_task: 2394444ceed8SEric W. Biederman return error; 2395444ceed8SEric W. Biederman } 2396444ceed8SEric W. Biederman 2397c5141e6dSEric Dumazet static int proc_base_fill_cache(struct file *filp, void *dirent, 2398c5141e6dSEric Dumazet filldir_t filldir, struct task_struct *task, const struct pid_entry *p) 239961a28784SEric W. Biederman { 240061a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, p->name, p->len, 240161a28784SEric W. Biederman proc_base_instantiate, task, p); 240261a28784SEric W. Biederman } 240361a28784SEric W. Biederman 2404aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 2405297c5d92SAndrea Righi static int do_io_accounting(struct task_struct *task, char *buffer, int whole) 2406aba76fdbSAndrew Morton { 2407940389b8SAndrea Righi struct task_io_accounting acct = task->ioac; 2408297c5d92SAndrea Righi unsigned long flags; 2409297c5d92SAndrea Righi 24105995477aSAndrea Righi if (whole && lock_task_sighand(task, &flags)) { 2411b2d002dbSAndrea Righi struct task_struct *t = task; 2412297c5d92SAndrea Righi 24135995477aSAndrea Righi task_io_accounting_add(&acct, &task->signal->ioac); 24145995477aSAndrea Righi while_each_thread(task, t) 24155995477aSAndrea Righi task_io_accounting_add(&acct, &t->ioac); 2416297c5d92SAndrea Righi 2417297c5d92SAndrea Righi unlock_task_sighand(task, &flags); 2418297c5d92SAndrea Righi } 2419aba76fdbSAndrew Morton return sprintf(buffer, 2420aba76fdbSAndrew Morton "rchar: %llu\n" 2421aba76fdbSAndrew Morton "wchar: %llu\n" 2422aba76fdbSAndrew Morton "syscr: %llu\n" 2423aba76fdbSAndrew Morton "syscw: %llu\n" 2424aba76fdbSAndrew Morton "read_bytes: %llu\n" 2425aba76fdbSAndrew Morton "write_bytes: %llu\n" 2426aba76fdbSAndrew Morton "cancelled_write_bytes: %llu\n", 24277c44319dSAlexander Beregalov (unsigned long long)acct.rchar, 24287c44319dSAlexander Beregalov (unsigned long long)acct.wchar, 24297c44319dSAlexander Beregalov (unsigned long long)acct.syscr, 24307c44319dSAlexander Beregalov (unsigned long long)acct.syscw, 24317c44319dSAlexander Beregalov (unsigned long long)acct.read_bytes, 24327c44319dSAlexander Beregalov (unsigned long long)acct.write_bytes, 24337c44319dSAlexander Beregalov (unsigned long long)acct.cancelled_write_bytes); 2434aba76fdbSAndrew Morton } 2435297c5d92SAndrea Righi 2436297c5d92SAndrea Righi static int proc_tid_io_accounting(struct task_struct *task, char *buffer) 2437297c5d92SAndrea Righi { 2438297c5d92SAndrea Righi return do_io_accounting(task, buffer, 0); 2439297c5d92SAndrea Righi } 2440297c5d92SAndrea Righi 2441297c5d92SAndrea Righi static int proc_tgid_io_accounting(struct task_struct *task, char *buffer) 2442297c5d92SAndrea Righi { 2443297c5d92SAndrea Righi return do_io_accounting(task, buffer, 1); 2444297c5d92SAndrea Righi } 2445297c5d92SAndrea Righi #endif /* CONFIG_TASK_IO_ACCOUNTING */ 2446aba76fdbSAndrew Morton 244747830723SKees Cook static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns, 244847830723SKees Cook struct pid *pid, struct task_struct *task) 244947830723SKees Cook { 245047830723SKees Cook seq_printf(m, "%08x\n", task->personality); 245147830723SKees Cook return 0; 245247830723SKees Cook } 245347830723SKees Cook 2454801199ceSEric W. Biederman /* 245528a6d671SEric W. Biederman * Thread groups 245628a6d671SEric W. Biederman */ 245700977a59SArjan van de Ven static const struct file_operations proc_task_operations; 2458c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations; 245920cdc894SEric W. Biederman 2460c5141e6dSEric Dumazet static const struct pid_entry tgid_base_stuff[] = { 2461*631f9c18SAlexey Dobriyan DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations), 2462*631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 2463*631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 2464b2211a36SAndrew Morton #ifdef CONFIG_NET 2465*631f9c18SAlexey Dobriyan DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 2466b2211a36SAndrew Morton #endif 2467*631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2468*631f9c18SAlexey Dobriyan INF("auxv", S_IRUSR, proc_pid_auxv), 2469*631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 2470*631f9c18SAlexey Dobriyan ONE("personality", S_IRUSR, proc_pid_personality), 2471*631f9c18SAlexey Dobriyan INF("limits", S_IRUSR, proc_pid_limits), 247243ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2473*631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 247443ae34cbSIngo Molnar #endif 2475ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 2476*631f9c18SAlexey Dobriyan INF("syscall", S_IRUSR, proc_pid_syscall), 2477ebcb6734SRoland McGrath #endif 2478*631f9c18SAlexey Dobriyan INF("cmdline", S_IRUGO, proc_pid_cmdline), 2479*631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tgid_stat), 2480*631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2481*631f9c18SAlexey Dobriyan REG("maps", S_IRUGO, proc_maps_operations), 248228a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2483*631f9c18SAlexey Dobriyan REG("numa_maps", S_IRUGO, proc_numa_maps_operations), 248428a6d671SEric W. Biederman #endif 2485*631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2486*631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2487*631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2488*631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2489*631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2490*631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 2491*631f9c18SAlexey Dobriyan REG("mountstats", S_IRUSR, proc_mountstats_operations), 24921e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2493*631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2494*631f9c18SAlexey Dobriyan REG("smaps", S_IRUGO, proc_smaps_operations), 2495*631f9c18SAlexey Dobriyan REG("pagemap", S_IRUSR, proc_pagemap_operations), 249628a6d671SEric W. Biederman #endif 249728a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2498*631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 249928a6d671SEric W. Biederman #endif 250028a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2501*631f9c18SAlexey Dobriyan INF("wchan", S_IRUGO, proc_pid_wchan), 250228a6d671SEric W. Biederman #endif 250328a6d671SEric W. Biederman #ifdef CONFIG_SCHEDSTATS 2504*631f9c18SAlexey Dobriyan INF("schedstat", S_IRUGO, proc_pid_schedstat), 250528a6d671SEric W. Biederman #endif 25069745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2507*631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 25089745512cSArjan van de Ven #endif 25098793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 2510*631f9c18SAlexey Dobriyan REG("cpuset", S_IRUGO, proc_cpuset_operations), 251128a6d671SEric W. Biederman #endif 2512a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2513*631f9c18SAlexey Dobriyan REG("cgroup", S_IRUGO, proc_cgroup_operations), 2514a424316cSPaul Menage #endif 2515*631f9c18SAlexey Dobriyan INF("oom_score", S_IRUGO, proc_oom_score), 2516*631f9c18SAlexey Dobriyan REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adjust_operations), 251728a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2518*631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 2519*631f9c18SAlexey Dobriyan REG("sessionid", S_IRUGO, proc_sessionid_operations), 252028a6d671SEric W. Biederman #endif 2521f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2522*631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2523f4f154fdSAkinobu Mita #endif 25243cb4a0bbSKawai, Hidehiro #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE) 2525*631f9c18SAlexey Dobriyan REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations), 25263cb4a0bbSKawai, Hidehiro #endif 2527aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 2528*631f9c18SAlexey Dobriyan INF("io", S_IRUGO, proc_tgid_io_accounting), 2529aba76fdbSAndrew Morton #endif 253028a6d671SEric W. Biederman }; 253128a6d671SEric W. Biederman 253228a6d671SEric W. Biederman static int proc_tgid_base_readdir(struct file * filp, 253328a6d671SEric W. Biederman void * dirent, filldir_t filldir) 253428a6d671SEric W. Biederman { 253528a6d671SEric W. Biederman return proc_pident_readdir(filp,dirent,filldir, 253628a6d671SEric W. Biederman tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff)); 253728a6d671SEric W. Biederman } 253828a6d671SEric W. Biederman 253900977a59SArjan van de Ven static const struct file_operations proc_tgid_base_operations = { 254028a6d671SEric W. Biederman .read = generic_read_dir, 254128a6d671SEric W. Biederman .readdir = proc_tgid_base_readdir, 254228a6d671SEric W. Biederman }; 254328a6d671SEric W. Biederman 254428a6d671SEric W. Biederman static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 25457bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 25467bcd6b0eSEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 254728a6d671SEric W. Biederman } 254828a6d671SEric W. Biederman 2549c5ef1c42SArjan van de Ven static const struct inode_operations proc_tgid_base_inode_operations = { 255028a6d671SEric W. Biederman .lookup = proc_tgid_base_lookup, 255128a6d671SEric W. Biederman .getattr = pid_getattr, 255228a6d671SEric W. Biederman .setattr = proc_setattr, 255328a6d671SEric W. Biederman }; 255428a6d671SEric W. Biederman 255560347f67SPavel Emelyanov static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid) 25561da177e4SLinus Torvalds { 255748e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 25588578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 255948e6484dSEric W. Biederman struct qstr name; 25601da177e4SLinus Torvalds 256148e6484dSEric W. Biederman name.name = buf; 256260347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 256360347f67SPavel Emelyanov dentry = d_hash_and_lookup(mnt->mnt_root, &name); 256448e6484dSEric W. Biederman if (dentry) { 25657766755aSAndrea Arcangeli if (!(current->flags & PF_EXITING)) 256648e6484dSEric W. Biederman shrink_dcache_parent(dentry); 256748e6484dSEric W. Biederman d_drop(dentry); 256848e6484dSEric W. Biederman dput(dentry); 25691da177e4SLinus Torvalds } 25701da177e4SLinus Torvalds 257160347f67SPavel Emelyanov if (tgid == 0) 257248e6484dSEric W. Biederman goto out; 25731da177e4SLinus Torvalds 257448e6484dSEric W. Biederman name.name = buf; 257560347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", tgid); 257660347f67SPavel Emelyanov leader = d_hash_and_lookup(mnt->mnt_root, &name); 257748e6484dSEric W. Biederman if (!leader) 257848e6484dSEric W. Biederman goto out; 257948e6484dSEric W. Biederman 258048e6484dSEric W. Biederman name.name = "task"; 258148e6484dSEric W. Biederman name.len = strlen(name.name); 258248e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 258348e6484dSEric W. Biederman if (!dir) 258448e6484dSEric W. Biederman goto out_put_leader; 258548e6484dSEric W. Biederman 258648e6484dSEric W. Biederman name.name = buf; 258760347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 258848e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 258948e6484dSEric W. Biederman if (dentry) { 259048e6484dSEric W. Biederman shrink_dcache_parent(dentry); 259148e6484dSEric W. Biederman d_drop(dentry); 259248e6484dSEric W. Biederman dput(dentry); 25931da177e4SLinus Torvalds } 259448e6484dSEric W. Biederman 259548e6484dSEric W. Biederman dput(dir); 259648e6484dSEric W. Biederman out_put_leader: 259748e6484dSEric W. Biederman dput(leader); 259848e6484dSEric W. Biederman out: 259948e6484dSEric W. Biederman return; 26001da177e4SLinus Torvalds } 26011da177e4SLinus Torvalds 26020895e91dSRandy Dunlap /** 26030895e91dSRandy Dunlap * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 26040895e91dSRandy Dunlap * @task: task that should be flushed. 26050895e91dSRandy Dunlap * 26060895e91dSRandy Dunlap * When flushing dentries from proc, one needs to flush them from global 260760347f67SPavel Emelyanov * proc (proc_mnt) and from all the namespaces' procs this task was seen 26080895e91dSRandy Dunlap * in. This call is supposed to do all of this job. 26090895e91dSRandy Dunlap * 26100895e91dSRandy Dunlap * Looks in the dcache for 26110895e91dSRandy Dunlap * /proc/@pid 26120895e91dSRandy Dunlap * /proc/@tgid/task/@pid 26130895e91dSRandy Dunlap * if either directory is present flushes it and all of it'ts children 26140895e91dSRandy Dunlap * from the dcache. 26150895e91dSRandy Dunlap * 26160895e91dSRandy Dunlap * It is safe and reasonable to cache /proc entries for a task until 26170895e91dSRandy Dunlap * that task exits. After that they just clog up the dcache with 26180895e91dSRandy Dunlap * useless entries, possibly causing useful dcache entries to be 26190895e91dSRandy Dunlap * flushed instead. This routine is proved to flush those useless 26200895e91dSRandy Dunlap * dcache entries at process exit time. 26210895e91dSRandy Dunlap * 26220895e91dSRandy Dunlap * NOTE: This routine is just an optimization so it does not guarantee 26230895e91dSRandy Dunlap * that no dcache entries will exist at process exit time it 26240895e91dSRandy Dunlap * just makes it very unlikely that any will persist. 262560347f67SPavel Emelyanov */ 262660347f67SPavel Emelyanov 262760347f67SPavel Emelyanov void proc_flush_task(struct task_struct *task) 262860347f67SPavel Emelyanov { 26299fcc2d15SEric W. Biederman int i; 26309fcc2d15SEric W. Biederman struct pid *pid, *tgid = NULL; 2631130f77ecSPavel Emelyanov struct upid *upid; 2632130f77ecSPavel Emelyanov 2633130f77ecSPavel Emelyanov pid = task_pid(task); 26349fcc2d15SEric W. Biederman if (thread_group_leader(task)) 2635130f77ecSPavel Emelyanov tgid = task_tgid(task); 26369fcc2d15SEric W. Biederman 26379fcc2d15SEric W. Biederman for (i = 0; i <= pid->level; i++) { 2638130f77ecSPavel Emelyanov upid = &pid->numbers[i]; 2639130f77ecSPavel Emelyanov proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr, 26409fcc2d15SEric W. Biederman tgid ? tgid->numbers[i].nr : 0); 2641130f77ecSPavel Emelyanov } 26426f4e6433SPavel Emelyanov 26436f4e6433SPavel Emelyanov upid = &pid->numbers[pid->level]; 26446f4e6433SPavel Emelyanov if (upid->nr == 1) 26456f4e6433SPavel Emelyanov pid_ns_release_proc(upid->ns); 264660347f67SPavel Emelyanov } 264760347f67SPavel Emelyanov 26489711ef99SAdrian Bunk static struct dentry *proc_pid_instantiate(struct inode *dir, 26499711ef99SAdrian Bunk struct dentry * dentry, 2650c5141e6dSEric Dumazet struct task_struct *task, const void *ptr) 2651444ceed8SEric W. Biederman { 2652444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-ENOENT); 2653444ceed8SEric W. Biederman struct inode *inode; 2654444ceed8SEric W. Biederman 265561a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2656444ceed8SEric W. Biederman if (!inode) 2657444ceed8SEric W. Biederman goto out; 2658444ceed8SEric W. Biederman 2659444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 2660444ceed8SEric W. Biederman inode->i_op = &proc_tgid_base_inode_operations; 2661444ceed8SEric W. Biederman inode->i_fop = &proc_tgid_base_operations; 2662444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 2663aed54175SVegard Nossum 2664aed54175SVegard Nossum inode->i_nlink = 2 + pid_entry_count_dirs(tgid_base_stuff, 2665aed54175SVegard Nossum ARRAY_SIZE(tgid_base_stuff)); 2666444ceed8SEric W. Biederman 2667444ceed8SEric W. Biederman dentry->d_op = &pid_dentry_operations; 2668444ceed8SEric W. Biederman 2669444ceed8SEric W. Biederman d_add(dentry, inode); 2670444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2671444ceed8SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2672444ceed8SEric W. Biederman error = NULL; 2673444ceed8SEric W. Biederman out: 2674444ceed8SEric W. Biederman return error; 2675444ceed8SEric W. Biederman } 2676444ceed8SEric W. Biederman 26771da177e4SLinus Torvalds struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 26781da177e4SLinus Torvalds { 2679cd6a3ce9SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 26801da177e4SLinus Torvalds struct task_struct *task; 26811da177e4SLinus Torvalds unsigned tgid; 2682b488893aSPavel Emelyanov struct pid_namespace *ns; 26831da177e4SLinus Torvalds 2684801199ceSEric W. Biederman result = proc_base_lookup(dir, dentry); 2685801199ceSEric W. Biederman if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT) 2686801199ceSEric W. Biederman goto out; 2687801199ceSEric W. Biederman 26881da177e4SLinus Torvalds tgid = name_to_int(dentry); 26891da177e4SLinus Torvalds if (tgid == ~0U) 26901da177e4SLinus Torvalds goto out; 26911da177e4SLinus Torvalds 2692b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 2693de758734SEric W. Biederman rcu_read_lock(); 2694b488893aSPavel Emelyanov task = find_task_by_pid_ns(tgid, ns); 26951da177e4SLinus Torvalds if (task) 26961da177e4SLinus Torvalds get_task_struct(task); 2697de758734SEric W. Biederman rcu_read_unlock(); 26981da177e4SLinus Torvalds if (!task) 26991da177e4SLinus Torvalds goto out; 27001da177e4SLinus Torvalds 2701444ceed8SEric W. Biederman result = proc_pid_instantiate(dir, dentry, task, NULL); 270248e6484dSEric W. Biederman put_task_struct(task); 27031da177e4SLinus Torvalds out: 2704cd6a3ce9SEric W. Biederman return result; 27051da177e4SLinus Torvalds } 27061da177e4SLinus Torvalds 27071da177e4SLinus Torvalds /* 27080804ef4bSEric W. Biederman * Find the first task with tgid >= tgid 27090bc58a91SEric W. Biederman * 27101da177e4SLinus Torvalds */ 271119fd4bb2SEric W. Biederman struct tgid_iter { 271219fd4bb2SEric W. Biederman unsigned int tgid; 27130804ef4bSEric W. Biederman struct task_struct *task; 271419fd4bb2SEric W. Biederman }; 271519fd4bb2SEric W. Biederman static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter) 271619fd4bb2SEric W. Biederman { 27170804ef4bSEric W. Biederman struct pid *pid; 27181da177e4SLinus Torvalds 271919fd4bb2SEric W. Biederman if (iter.task) 272019fd4bb2SEric W. Biederman put_task_struct(iter.task); 27210804ef4bSEric W. Biederman rcu_read_lock(); 27220804ef4bSEric W. Biederman retry: 272319fd4bb2SEric W. Biederman iter.task = NULL; 272419fd4bb2SEric W. Biederman pid = find_ge_pid(iter.tgid, ns); 27250804ef4bSEric W. Biederman if (pid) { 272619fd4bb2SEric W. Biederman iter.tgid = pid_nr_ns(pid, ns); 272719fd4bb2SEric W. Biederman iter.task = pid_task(pid, PIDTYPE_PID); 27280804ef4bSEric W. Biederman /* What we to know is if the pid we have find is the 27290804ef4bSEric W. Biederman * pid of a thread_group_leader. Testing for task 27300804ef4bSEric W. Biederman * being a thread_group_leader is the obvious thing 27310804ef4bSEric W. Biederman * todo but there is a window when it fails, due to 27320804ef4bSEric W. Biederman * the pid transfer logic in de_thread. 27330804ef4bSEric W. Biederman * 27340804ef4bSEric W. Biederman * So we perform the straight forward test of seeing 27350804ef4bSEric W. Biederman * if the pid we have found is the pid of a thread 27360804ef4bSEric W. Biederman * group leader, and don't worry if the task we have 27370804ef4bSEric W. Biederman * found doesn't happen to be a thread group leader. 27380804ef4bSEric W. Biederman * As we don't care in the case of readdir. 27390bc58a91SEric W. Biederman */ 274019fd4bb2SEric W. Biederman if (!iter.task || !has_group_leader_pid(iter.task)) { 274119fd4bb2SEric W. Biederman iter.tgid += 1; 27420804ef4bSEric W. Biederman goto retry; 274319fd4bb2SEric W. Biederman } 274419fd4bb2SEric W. Biederman get_task_struct(iter.task); 27451da177e4SLinus Torvalds } 2746454cc105SEric W. Biederman rcu_read_unlock(); 274719fd4bb2SEric W. Biederman return iter; 27481da177e4SLinus Torvalds } 27491da177e4SLinus Torvalds 27507bcd6b0eSEric W. Biederman #define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff)) 27511da177e4SLinus Torvalds 275261a28784SEric W. Biederman static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir, 275319fd4bb2SEric W. Biederman struct tgid_iter iter) 275461a28784SEric W. Biederman { 275561a28784SEric W. Biederman char name[PROC_NUMBUF]; 275619fd4bb2SEric W. Biederman int len = snprintf(name, sizeof(name), "%d", iter.tgid); 275761a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, name, len, 275819fd4bb2SEric W. Biederman proc_pid_instantiate, iter.task, NULL); 275961a28784SEric W. Biederman } 276061a28784SEric W. Biederman 27611da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 27621da177e4SLinus Torvalds int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir) 27631da177e4SLinus Torvalds { 27641da177e4SLinus Torvalds unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY; 27652fddfeefSJosef "Jeff" Sipek struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode); 276619fd4bb2SEric W. Biederman struct tgid_iter iter; 2767b488893aSPavel Emelyanov struct pid_namespace *ns; 27681da177e4SLinus Torvalds 276961a28784SEric W. Biederman if (!reaper) 277061a28784SEric W. Biederman goto out_no_task; 277161a28784SEric W. Biederman 27727bcd6b0eSEric W. Biederman for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) { 2773c5141e6dSEric Dumazet const struct pid_entry *p = &proc_base_stuff[nr]; 277461a28784SEric W. Biederman if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0) 2775801199ceSEric W. Biederman goto out; 27761da177e4SLinus Torvalds } 27771da177e4SLinus Torvalds 2778b488893aSPavel Emelyanov ns = filp->f_dentry->d_sb->s_fs_info; 277919fd4bb2SEric W. Biederman iter.task = NULL; 278019fd4bb2SEric W. Biederman iter.tgid = filp->f_pos - TGID_OFFSET; 278119fd4bb2SEric W. Biederman for (iter = next_tgid(ns, iter); 278219fd4bb2SEric W. Biederman iter.task; 278319fd4bb2SEric W. Biederman iter.tgid += 1, iter = next_tgid(ns, iter)) { 278419fd4bb2SEric W. Biederman filp->f_pos = iter.tgid + TGID_OFFSET; 278519fd4bb2SEric W. Biederman if (proc_pid_fill_cache(filp, dirent, filldir, iter) < 0) { 278619fd4bb2SEric W. Biederman put_task_struct(iter.task); 27870804ef4bSEric W. Biederman goto out; 27881da177e4SLinus Torvalds } 27891da177e4SLinus Torvalds } 27900804ef4bSEric W. Biederman filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET; 27910804ef4bSEric W. Biederman out: 279261a28784SEric W. Biederman put_task_struct(reaper); 279361a28784SEric W. Biederman out_no_task: 27941da177e4SLinus Torvalds return 0; 27951da177e4SLinus Torvalds } 27961da177e4SLinus Torvalds 27970bc58a91SEric W. Biederman /* 279828a6d671SEric W. Biederman * Tasks 279928a6d671SEric W. Biederman */ 2800c5141e6dSEric Dumazet static const struct pid_entry tid_base_stuff[] = { 2801*631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 2802*631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fd_operations), 2803*631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2804*631f9c18SAlexey Dobriyan INF("auxv", S_IRUSR, proc_pid_auxv), 2805*631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 2806*631f9c18SAlexey Dobriyan ONE("personality", S_IRUSR, proc_pid_personality), 2807*631f9c18SAlexey Dobriyan INF("limits", S_IRUSR, proc_pid_limits), 280843ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2809*631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 281043ae34cbSIngo Molnar #endif 2811ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 2812*631f9c18SAlexey Dobriyan INF("syscall", S_IRUSR, proc_pid_syscall), 2813ebcb6734SRoland McGrath #endif 2814*631f9c18SAlexey Dobriyan INF("cmdline", S_IRUGO, proc_pid_cmdline), 2815*631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tid_stat), 2816*631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2817*631f9c18SAlexey Dobriyan REG("maps", S_IRUGO, proc_maps_operations), 281828a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2819*631f9c18SAlexey Dobriyan REG("numa_maps", S_IRUGO, proc_numa_maps_operations), 282028a6d671SEric W. Biederman #endif 2821*631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2822*631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2823*631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2824*631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2825*631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2826*631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 28271e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2828*631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2829*631f9c18SAlexey Dobriyan REG("smaps", S_IRUGO, proc_smaps_operations), 2830*631f9c18SAlexey Dobriyan REG("pagemap", S_IRUSR, proc_pagemap_operations), 283128a6d671SEric W. Biederman #endif 283228a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2833*631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 283428a6d671SEric W. Biederman #endif 283528a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2836*631f9c18SAlexey Dobriyan INF("wchan", S_IRUGO, proc_pid_wchan), 283728a6d671SEric W. Biederman #endif 283828a6d671SEric W. Biederman #ifdef CONFIG_SCHEDSTATS 2839*631f9c18SAlexey Dobriyan INF("schedstat", S_IRUGO, proc_pid_schedstat), 284028a6d671SEric W. Biederman #endif 28419745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2842*631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 28439745512cSArjan van de Ven #endif 28448793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 2845*631f9c18SAlexey Dobriyan REG("cpuset", S_IRUGO, proc_cpuset_operations), 284628a6d671SEric W. Biederman #endif 2847a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2848*631f9c18SAlexey Dobriyan REG("cgroup", S_IRUGO, proc_cgroup_operations), 2849a424316cSPaul Menage #endif 2850*631f9c18SAlexey Dobriyan INF("oom_score", S_IRUGO, proc_oom_score), 2851*631f9c18SAlexey Dobriyan REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adjust_operations), 285228a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2853*631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 2854*631f9c18SAlexey Dobriyan REG("sessionid", S_IRUSR, proc_sessionid_operations), 285528a6d671SEric W. Biederman #endif 2856f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2857*631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2858f4f154fdSAkinobu Mita #endif 2859297c5d92SAndrea Righi #ifdef CONFIG_TASK_IO_ACCOUNTING 2860*631f9c18SAlexey Dobriyan INF("io", S_IRUGO, proc_tid_io_accounting), 2861297c5d92SAndrea Righi #endif 286228a6d671SEric W. Biederman }; 286328a6d671SEric W. Biederman 286428a6d671SEric W. Biederman static int proc_tid_base_readdir(struct file * filp, 286528a6d671SEric W. Biederman void * dirent, filldir_t filldir) 286628a6d671SEric W. Biederman { 286728a6d671SEric W. Biederman return proc_pident_readdir(filp,dirent,filldir, 286828a6d671SEric W. Biederman tid_base_stuff,ARRAY_SIZE(tid_base_stuff)); 286928a6d671SEric W. Biederman } 287028a6d671SEric W. Biederman 287128a6d671SEric W. Biederman static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){ 28727bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 28737bcd6b0eSEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 287428a6d671SEric W. Biederman } 287528a6d671SEric W. Biederman 287600977a59SArjan van de Ven static const struct file_operations proc_tid_base_operations = { 287728a6d671SEric W. Biederman .read = generic_read_dir, 287828a6d671SEric W. Biederman .readdir = proc_tid_base_readdir, 287928a6d671SEric W. Biederman }; 288028a6d671SEric W. Biederman 2881c5ef1c42SArjan van de Ven static const struct inode_operations proc_tid_base_inode_operations = { 288228a6d671SEric W. Biederman .lookup = proc_tid_base_lookup, 288328a6d671SEric W. Biederman .getattr = pid_getattr, 288428a6d671SEric W. Biederman .setattr = proc_setattr, 288528a6d671SEric W. Biederman }; 288628a6d671SEric W. Biederman 2887444ceed8SEric W. Biederman static struct dentry *proc_task_instantiate(struct inode *dir, 2888c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2889444ceed8SEric W. Biederman { 2890444ceed8SEric W. Biederman struct dentry *error = ERR_PTR(-ENOENT); 2891444ceed8SEric W. Biederman struct inode *inode; 289261a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2893444ceed8SEric W. Biederman 2894444ceed8SEric W. Biederman if (!inode) 2895444ceed8SEric W. Biederman goto out; 2896444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 2897444ceed8SEric W. Biederman inode->i_op = &proc_tid_base_inode_operations; 2898444ceed8SEric W. Biederman inode->i_fop = &proc_tid_base_operations; 2899444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 2900aed54175SVegard Nossum 2901aed54175SVegard Nossum inode->i_nlink = 2 + pid_entry_count_dirs(tid_base_stuff, 2902aed54175SVegard Nossum ARRAY_SIZE(tid_base_stuff)); 2903444ceed8SEric W. Biederman 2904444ceed8SEric W. Biederman dentry->d_op = &pid_dentry_operations; 2905444ceed8SEric W. Biederman 2906444ceed8SEric W. Biederman d_add(dentry, inode); 2907444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 2908444ceed8SEric W. Biederman if (pid_revalidate(dentry, NULL)) 2909444ceed8SEric W. Biederman error = NULL; 2910444ceed8SEric W. Biederman out: 2911444ceed8SEric W. Biederman return error; 2912444ceed8SEric W. Biederman } 2913444ceed8SEric W. Biederman 291428a6d671SEric W. Biederman static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 291528a6d671SEric W. Biederman { 291628a6d671SEric W. Biederman struct dentry *result = ERR_PTR(-ENOENT); 291728a6d671SEric W. Biederman struct task_struct *task; 291828a6d671SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 291928a6d671SEric W. Biederman unsigned tid; 2920b488893aSPavel Emelyanov struct pid_namespace *ns; 292128a6d671SEric W. Biederman 292228a6d671SEric W. Biederman if (!leader) 292328a6d671SEric W. Biederman goto out_no_task; 292428a6d671SEric W. Biederman 292528a6d671SEric W. Biederman tid = name_to_int(dentry); 292628a6d671SEric W. Biederman if (tid == ~0U) 292728a6d671SEric W. Biederman goto out; 292828a6d671SEric W. Biederman 2929b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 293028a6d671SEric W. Biederman rcu_read_lock(); 2931b488893aSPavel Emelyanov task = find_task_by_pid_ns(tid, ns); 293228a6d671SEric W. Biederman if (task) 293328a6d671SEric W. Biederman get_task_struct(task); 293428a6d671SEric W. Biederman rcu_read_unlock(); 293528a6d671SEric W. Biederman if (!task) 293628a6d671SEric W. Biederman goto out; 2937bac0abd6SPavel Emelyanov if (!same_thread_group(leader, task)) 293828a6d671SEric W. Biederman goto out_drop_task; 293928a6d671SEric W. Biederman 2940444ceed8SEric W. Biederman result = proc_task_instantiate(dir, dentry, task, NULL); 294128a6d671SEric W. Biederman out_drop_task: 294228a6d671SEric W. Biederman put_task_struct(task); 294328a6d671SEric W. Biederman out: 294428a6d671SEric W. Biederman put_task_struct(leader); 294528a6d671SEric W. Biederman out_no_task: 294628a6d671SEric W. Biederman return result; 294728a6d671SEric W. Biederman } 294828a6d671SEric W. Biederman 294928a6d671SEric W. Biederman /* 29500bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 29510bc58a91SEric W. Biederman * 29520bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 29530bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 29540bc58a91SEric W. Biederman * directory we have more work todo. 29550bc58a91SEric W. Biederman * 29560bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 29570bc58a91SEric W. Biederman * 29580bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 29590bc58a91SEric W. Biederman * threads past it. 29600bc58a91SEric W. Biederman */ 2961cc288738SEric W. Biederman static struct task_struct *first_tid(struct task_struct *leader, 2962b488893aSPavel Emelyanov int tid, int nr, struct pid_namespace *ns) 29630bc58a91SEric W. Biederman { 2964a872ff0cSOleg Nesterov struct task_struct *pos; 29650bc58a91SEric W. Biederman 2966cc288738SEric W. Biederman rcu_read_lock(); 29670bc58a91SEric W. Biederman /* Attempt to start with the pid of a thread */ 29680bc58a91SEric W. Biederman if (tid && (nr > 0)) { 2969b488893aSPavel Emelyanov pos = find_task_by_pid_ns(tid, ns); 2970a872ff0cSOleg Nesterov if (pos && (pos->group_leader == leader)) 2971a872ff0cSOleg Nesterov goto found; 29720bc58a91SEric W. Biederman } 29730bc58a91SEric W. Biederman 29740bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 29750bc58a91SEric W. Biederman pos = NULL; 2976a872ff0cSOleg Nesterov if (nr && nr >= get_nr_threads(leader)) 2977a872ff0cSOleg Nesterov goto out; 2978a872ff0cSOleg Nesterov 2979a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 2980a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 2981a872ff0cSOleg Nesterov */ 2982a872ff0cSOleg Nesterov for (pos = leader; nr > 0; --nr) { 2983a872ff0cSOleg Nesterov pos = next_thread(pos); 2984a872ff0cSOleg Nesterov if (pos == leader) { 2985a872ff0cSOleg Nesterov pos = NULL; 2986a872ff0cSOleg Nesterov goto out; 2987a872ff0cSOleg Nesterov } 2988a872ff0cSOleg Nesterov } 2989a872ff0cSOleg Nesterov found: 2990a872ff0cSOleg Nesterov get_task_struct(pos); 2991a872ff0cSOleg Nesterov out: 2992cc288738SEric W. Biederman rcu_read_unlock(); 29930bc58a91SEric W. Biederman return pos; 29940bc58a91SEric W. Biederman } 29950bc58a91SEric W. Biederman 29960bc58a91SEric W. Biederman /* 29970bc58a91SEric W. Biederman * Find the next thread in the thread list. 29980bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 29990bc58a91SEric W. Biederman * 30000bc58a91SEric W. Biederman * The reference to the input task_struct is released. 30010bc58a91SEric W. Biederman */ 30020bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 30030bc58a91SEric W. Biederman { 3004c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 3005cc288738SEric W. Biederman rcu_read_lock(); 3006c1df7fb8SOleg Nesterov if (pid_alive(start)) { 30070bc58a91SEric W. Biederman pos = next_thread(start); 3008c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 30090bc58a91SEric W. Biederman pos = NULL; 3010c1df7fb8SOleg Nesterov else 3011c1df7fb8SOleg Nesterov get_task_struct(pos); 3012c1df7fb8SOleg Nesterov } 3013cc288738SEric W. Biederman rcu_read_unlock(); 30140bc58a91SEric W. Biederman put_task_struct(start); 30150bc58a91SEric W. Biederman return pos; 30160bc58a91SEric W. Biederman } 30170bc58a91SEric W. Biederman 301861a28784SEric W. Biederman static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir, 301961a28784SEric W. Biederman struct task_struct *task, int tid) 302061a28784SEric W. Biederman { 302161a28784SEric W. Biederman char name[PROC_NUMBUF]; 302261a28784SEric W. Biederman int len = snprintf(name, sizeof(name), "%d", tid); 302361a28784SEric W. Biederman return proc_fill_cache(filp, dirent, filldir, name, len, 302461a28784SEric W. Biederman proc_task_instantiate, task, NULL); 302561a28784SEric W. Biederman } 302661a28784SEric W. Biederman 30271da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 30281da177e4SLinus Torvalds static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir) 30291da177e4SLinus Torvalds { 30302fddfeefSJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 30311da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 30327d895244SGuillaume Chazarain struct task_struct *leader = NULL; 30330bc58a91SEric W. Biederman struct task_struct *task; 30341da177e4SLinus Torvalds int retval = -ENOENT; 30351da177e4SLinus Torvalds ino_t ino; 30360bc58a91SEric W. Biederman int tid; 30371da177e4SLinus Torvalds unsigned long pos = filp->f_pos; /* avoiding "long long" filp->f_pos */ 3038b488893aSPavel Emelyanov struct pid_namespace *ns; 30391da177e4SLinus Torvalds 30407d895244SGuillaume Chazarain task = get_proc_task(inode); 30417d895244SGuillaume Chazarain if (!task) 30427d895244SGuillaume Chazarain goto out_no_task; 30437d895244SGuillaume Chazarain rcu_read_lock(); 30447d895244SGuillaume Chazarain if (pid_alive(task)) { 30457d895244SGuillaume Chazarain leader = task->group_leader; 30467d895244SGuillaume Chazarain get_task_struct(leader); 30477d895244SGuillaume Chazarain } 30487d895244SGuillaume Chazarain rcu_read_unlock(); 30497d895244SGuillaume Chazarain put_task_struct(task); 305099f89551SEric W. Biederman if (!leader) 305199f89551SEric W. Biederman goto out_no_task; 30521da177e4SLinus Torvalds retval = 0; 30531da177e4SLinus Torvalds 30541da177e4SLinus Torvalds switch (pos) { 30551da177e4SLinus Torvalds case 0: 30561da177e4SLinus Torvalds ino = inode->i_ino; 30571da177e4SLinus Torvalds if (filldir(dirent, ".", 1, pos, ino, DT_DIR) < 0) 30581da177e4SLinus Torvalds goto out; 30591da177e4SLinus Torvalds pos++; 30601da177e4SLinus Torvalds /* fall through */ 30611da177e4SLinus Torvalds case 1: 30621da177e4SLinus Torvalds ino = parent_ino(dentry); 30631da177e4SLinus Torvalds if (filldir(dirent, "..", 2, pos, ino, DT_DIR) < 0) 30641da177e4SLinus Torvalds goto out; 30651da177e4SLinus Torvalds pos++; 30661da177e4SLinus Torvalds /* fall through */ 30671da177e4SLinus Torvalds } 30681da177e4SLinus Torvalds 30690bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 30700bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 30710bc58a91SEric W. Biederman */ 3072b488893aSPavel Emelyanov ns = filp->f_dentry->d_sb->s_fs_info; 30732b47c361SMathieu Desnoyers tid = (int)filp->f_version; 30740bc58a91SEric W. Biederman filp->f_version = 0; 3075b488893aSPavel Emelyanov for (task = first_tid(leader, tid, pos - 2, ns); 30760bc58a91SEric W. Biederman task; 30770bc58a91SEric W. Biederman task = next_tid(task), pos++) { 3078b488893aSPavel Emelyanov tid = task_pid_nr_ns(task, ns); 307961a28784SEric W. Biederman if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) { 30800bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 30810bc58a91SEric W. Biederman * pid for the next readir call */ 30822b47c361SMathieu Desnoyers filp->f_version = (u64)tid; 30830bc58a91SEric W. Biederman put_task_struct(task); 30841da177e4SLinus Torvalds break; 30850bc58a91SEric W. Biederman } 30861da177e4SLinus Torvalds } 30871da177e4SLinus Torvalds out: 30881da177e4SLinus Torvalds filp->f_pos = pos; 308999f89551SEric W. Biederman put_task_struct(leader); 309099f89551SEric W. Biederman out_no_task: 30911da177e4SLinus Torvalds return retval; 30921da177e4SLinus Torvalds } 30936e66b52bSEric W. Biederman 30946e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 30956e66b52bSEric W. Biederman { 30966e66b52bSEric W. Biederman struct inode *inode = dentry->d_inode; 309799f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 30986e66b52bSEric W. Biederman generic_fillattr(inode, stat); 30996e66b52bSEric W. Biederman 310099f89551SEric W. Biederman if (p) { 310199f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 310299f89551SEric W. Biederman put_task_struct(p); 31036e66b52bSEric W. Biederman } 31046e66b52bSEric W. Biederman 31056e66b52bSEric W. Biederman return 0; 31066e66b52bSEric W. Biederman } 310728a6d671SEric W. Biederman 3108c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations = { 310928a6d671SEric W. Biederman .lookup = proc_task_lookup, 311028a6d671SEric W. Biederman .getattr = proc_task_getattr, 311128a6d671SEric W. Biederman .setattr = proc_setattr, 311228a6d671SEric W. Biederman }; 311328a6d671SEric W. Biederman 311400977a59SArjan van de Ven static const struct file_operations proc_task_operations = { 311528a6d671SEric W. Biederman .read = generic_read_dir, 311628a6d671SEric W. Biederman .readdir = proc_task_readdir, 311728a6d671SEric W. Biederman }; 3118