11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/proc/base.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * proc base directory handling functions 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * 1999, Al Viro. Rewritten. Now it covers the whole per-process part. 91da177e4SLinus Torvalds * Instead of using magical inumbers to determine the kind of object 101da177e4SLinus Torvalds * we allocate and fill in-core inodes upon lookup. They don't even 111da177e4SLinus Torvalds * go into icache. We cache the reference to task_struct upon lookup too. 121da177e4SLinus Torvalds * Eventually it should become a filesystem in its own. We don't use the 131da177e4SLinus Torvalds * rest of procfs anymore. 14e070ad49SMauricio Lin * 15e070ad49SMauricio Lin * 16e070ad49SMauricio Lin * Changelog: 17e070ad49SMauricio Lin * 17-Jan-2005 18e070ad49SMauricio Lin * Allan Bezerra 19e070ad49SMauricio Lin * Bruna Moreira <bruna.moreira@indt.org.br> 20e070ad49SMauricio Lin * Edjard Mota <edjard.mota@indt.org.br> 21e070ad49SMauricio Lin * Ilias Biris <ilias.biris@indt.org.br> 22e070ad49SMauricio Lin * Mauricio Lin <mauricio.lin@indt.org.br> 23e070ad49SMauricio Lin * 24e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 25e070ad49SMauricio Lin * 26e070ad49SMauricio Lin * A new process specific entry (smaps) included in /proc. It shows the 27e070ad49SMauricio Lin * size of rss for each memory area. The maps entry lacks information 28e070ad49SMauricio Lin * about physical memory size (rss) for each mapped file, i.e., 29e070ad49SMauricio Lin * rss information for executables and library files. 30e070ad49SMauricio Lin * This additional information is useful for any tools that need to know 31e070ad49SMauricio Lin * about physical memory consumption for a process specific library. 32e070ad49SMauricio Lin * 33e070ad49SMauricio Lin * Changelog: 34e070ad49SMauricio Lin * 21-Feb-2005 35e070ad49SMauricio Lin * Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT 36e070ad49SMauricio Lin * Pud inclusion in the page table walking. 37e070ad49SMauricio Lin * 38e070ad49SMauricio Lin * ChangeLog: 39e070ad49SMauricio Lin * 10-Mar-2005 40e070ad49SMauricio Lin * 10LE Instituto Nokia de Tecnologia - INdT: 41e070ad49SMauricio Lin * A better way to walks through the page table as suggested by Hugh Dickins. 42e070ad49SMauricio Lin * 43e070ad49SMauricio Lin * Simo Piiroinen <simo.piiroinen@nokia.com>: 44e070ad49SMauricio Lin * Smaps information related to shared, private, clean and dirty pages. 45e070ad49SMauricio Lin * 46e070ad49SMauricio Lin * Paul Mundt <paul.mundt@nokia.com>: 47e070ad49SMauricio Lin * Overall revision about smaps. 481da177e4SLinus Torvalds */ 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include <asm/uaccess.h> 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #include <linux/errno.h> 531da177e4SLinus Torvalds #include <linux/time.h> 541da177e4SLinus Torvalds #include <linux/proc_fs.h> 551da177e4SLinus Torvalds #include <linux/stat.h> 565995477aSAndrea Righi #include <linux/task_io_accounting_ops.h> 571da177e4SLinus Torvalds #include <linux/init.h> 5816f7e0feSRandy Dunlap #include <linux/capability.h> 591da177e4SLinus Torvalds #include <linux/file.h> 609f3acc31SAl Viro #include <linux/fdtable.h> 611da177e4SLinus Torvalds #include <linux/string.h> 621da177e4SLinus Torvalds #include <linux/seq_file.h> 631da177e4SLinus Torvalds #include <linux/namei.h> 646b3286edSKirill Korotaev #include <linux/mnt_namespace.h> 651da177e4SLinus Torvalds #include <linux/mm.h> 66a63d83f4SDavid Rientjes #include <linux/swap.h> 67b835996fSDipankar Sarma #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/kallsyms.h> 692ec220e2SKen Chen #include <linux/stacktrace.h> 70d85f50d5SNeil Horman #include <linux/resource.h> 715096add8SKees Cook #include <linux/module.h> 721da177e4SLinus Torvalds #include <linux/mount.h> 731da177e4SLinus Torvalds #include <linux/security.h> 741da177e4SLinus Torvalds #include <linux/ptrace.h> 750d094efeSRoland McGrath #include <linux/tracehook.h> 7687ebdc00SAndrew Morton #include <linux/printk.h> 77a424316cSPaul Menage #include <linux/cgroup.h> 781da177e4SLinus Torvalds #include <linux/cpuset.h> 791da177e4SLinus Torvalds #include <linux/audit.h> 805addc5ddSAl Viro #include <linux/poll.h> 811651e14eSSerge E. Hallyn #include <linux/nsproxy.h> 828ac773b4SAlexey Dobriyan #include <linux/oom.h> 833cb4a0bbSKawai, Hidehiro #include <linux/elf.h> 8460347f67SPavel Emelyanov #include <linux/pid_namespace.h> 8522d917d8SEric W. Biederman #include <linux/user_namespace.h> 865ad4e53bSAl Viro #include <linux/fs_struct.h> 875a0e3ad6STejun Heo #include <linux/slab.h> 88640708a2SPavel Emelyanov #include <linux/flex_array.h> 8948f6a7a5SPavel Emelyanov #include <linux/posix-timers.h> 90f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 91f133eccaSChris Metcalf #include <asm/hardwall.h> 92f133eccaSChris Metcalf #endif 9343d2b113SKAMEZAWA Hiroyuki #include <trace/events/oom.h> 941da177e4SLinus Torvalds #include "internal.h" 95faf60af1SCyrill Gorcunov #include "fd.h" 961da177e4SLinus Torvalds 970f2fe20fSEric W. Biederman /* NOTE: 980f2fe20fSEric W. Biederman * Implementing inode permission operations in /proc is almost 990f2fe20fSEric W. Biederman * certainly an error. Permission checks need to happen during 1000f2fe20fSEric W. Biederman * each system call not at open time. The reason is that most of 1010f2fe20fSEric W. Biederman * what we wish to check for permissions in /proc varies at runtime. 1020f2fe20fSEric W. Biederman * 1030f2fe20fSEric W. Biederman * The classic example of a problem is opening file descriptors 1040f2fe20fSEric W. Biederman * in /proc for a task before it execs a suid executable. 1050f2fe20fSEric W. Biederman */ 1060f2fe20fSEric W. Biederman 1071da177e4SLinus Torvalds struct pid_entry { 108cedbccabSAlexey Dobriyan const char *name; 109c5141e6dSEric Dumazet int len; 110d161a13fSAl Viro umode_t mode; 111c5ef1c42SArjan van de Ven const struct inode_operations *iop; 11200977a59SArjan van de Ven const struct file_operations *fop; 11320cdc894SEric W. Biederman union proc_op op; 1141da177e4SLinus Torvalds }; 1151da177e4SLinus Torvalds 11661a28784SEric W. Biederman #define NOD(NAME, MODE, IOP, FOP, OP) { \ 11720cdc894SEric W. Biederman .name = (NAME), \ 118c5141e6dSEric Dumazet .len = sizeof(NAME) - 1, \ 11920cdc894SEric W. Biederman .mode = MODE, \ 12020cdc894SEric W. Biederman .iop = IOP, \ 12120cdc894SEric W. Biederman .fop = FOP, \ 12220cdc894SEric W. Biederman .op = OP, \ 12320cdc894SEric W. Biederman } 12420cdc894SEric W. Biederman 125631f9c18SAlexey Dobriyan #define DIR(NAME, MODE, iops, fops) \ 126631f9c18SAlexey Dobriyan NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} ) 127631f9c18SAlexey Dobriyan #define LNK(NAME, get_link) \ 12861a28784SEric W. Biederman NOD(NAME, (S_IFLNK|S_IRWXUGO), \ 12920cdc894SEric W. Biederman &proc_pid_link_inode_operations, NULL, \ 130631f9c18SAlexey Dobriyan { .proc_get_link = get_link } ) 131631f9c18SAlexey Dobriyan #define REG(NAME, MODE, fops) \ 132631f9c18SAlexey Dobriyan NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {}) 133631f9c18SAlexey Dobriyan #define INF(NAME, MODE, read) \ 13461a28784SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 13520cdc894SEric W. Biederman NULL, &proc_info_file_operations, \ 136631f9c18SAlexey Dobriyan { .proc_read = read } ) 137631f9c18SAlexey Dobriyan #define ONE(NAME, MODE, show) \ 138be614086SEric W. Biederman NOD(NAME, (S_IFREG|(MODE)), \ 139be614086SEric W. Biederman NULL, &proc_single_file_operations, \ 140631f9c18SAlexey Dobriyan { .proc_show = show } ) 1411da177e4SLinus Torvalds 142aed54175SVegard Nossum /* 143aed54175SVegard Nossum * Count the number of hardlinks for the pid_entry table, excluding the . 144aed54175SVegard Nossum * and .. links. 145aed54175SVegard Nossum */ 146aed54175SVegard Nossum static unsigned int pid_entry_count_dirs(const struct pid_entry *entries, 147aed54175SVegard Nossum unsigned int n) 148aed54175SVegard Nossum { 149aed54175SVegard Nossum unsigned int i; 150aed54175SVegard Nossum unsigned int count; 151aed54175SVegard Nossum 152aed54175SVegard Nossum count = 0; 153aed54175SVegard Nossum for (i = 0; i < n; ++i) { 154aed54175SVegard Nossum if (S_ISDIR(entries[i].mode)) 155aed54175SVegard Nossum ++count; 156aed54175SVegard Nossum } 157aed54175SVegard Nossum 158aed54175SVegard Nossum return count; 159aed54175SVegard Nossum } 160aed54175SVegard Nossum 161f7ad3c6bSMiklos Szeredi static int get_task_root(struct task_struct *task, struct path *root) 1621da177e4SLinus Torvalds { 1637c2c7d99SHugh Dickins int result = -ENOENT; 1647c2c7d99SHugh Dickins 1650494f6ecSMiklos Szeredi task_lock(task); 166f7ad3c6bSMiklos Szeredi if (task->fs) { 167f7ad3c6bSMiklos Szeredi get_fs_root(task->fs, root); 1687c2c7d99SHugh Dickins result = 0; 1697c2c7d99SHugh Dickins } 1700494f6ecSMiklos Szeredi task_unlock(task); 1717c2c7d99SHugh Dickins return result; 1720494f6ecSMiklos Szeredi } 1730494f6ecSMiklos Szeredi 1747773fbc5SCyrill Gorcunov static int proc_cwd_link(struct dentry *dentry, struct path *path) 1750494f6ecSMiklos Szeredi { 1767773fbc5SCyrill Gorcunov struct task_struct *task = get_proc_task(dentry->d_inode); 1770494f6ecSMiklos Szeredi int result = -ENOENT; 17899f89551SEric W. Biederman 17999f89551SEric W. Biederman if (task) { 180f7ad3c6bSMiklos Szeredi task_lock(task); 181f7ad3c6bSMiklos Szeredi if (task->fs) { 182f7ad3c6bSMiklos Szeredi get_fs_pwd(task->fs, path); 183f7ad3c6bSMiklos Szeredi result = 0; 184f7ad3c6bSMiklos Szeredi } 185f7ad3c6bSMiklos Szeredi task_unlock(task); 18699f89551SEric W. Biederman put_task_struct(task); 18799f89551SEric W. Biederman } 1881da177e4SLinus Torvalds return result; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1917773fbc5SCyrill Gorcunov static int proc_root_link(struct dentry *dentry, struct path *path) 1921da177e4SLinus Torvalds { 1937773fbc5SCyrill Gorcunov struct task_struct *task = get_proc_task(dentry->d_inode); 1941da177e4SLinus Torvalds int result = -ENOENT; 19599f89551SEric W. Biederman 19699f89551SEric W. Biederman if (task) { 197f7ad3c6bSMiklos Szeredi result = get_task_root(task, path); 19899f89551SEric W. Biederman put_task_struct(task); 19999f89551SEric W. Biederman } 2001da177e4SLinus Torvalds return result; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2032ca66ff7SAlexey Dobriyan static int proc_pid_cmdline(struct seq_file *m, struct pid_namespace *ns, 2042ca66ff7SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2051da177e4SLinus Torvalds { 2062ca66ff7SAlexey Dobriyan /* 2072ca66ff7SAlexey Dobriyan * Rely on struct seq_operations::show() being called once 2082ca66ff7SAlexey Dobriyan * per internal buffer allocation. See single_open(), traverse(). 2092ca66ff7SAlexey Dobriyan */ 2102ca66ff7SAlexey Dobriyan BUG_ON(m->size < PAGE_SIZE); 2112ca66ff7SAlexey Dobriyan m->count += get_cmdline(task, m->buf, PAGE_SIZE); 2122ca66ff7SAlexey Dobriyan return 0; 2131da177e4SLinus Torvalds } 2141da177e4SLinus Torvalds 215f9ea536eSAlexey Dobriyan static int proc_pid_auxv(struct seq_file *m, struct pid_namespace *ns, 216f9ea536eSAlexey Dobriyan struct pid *pid, struct task_struct *task) 2171da177e4SLinus Torvalds { 218e7dcd999SCong Wang struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ); 2192fadaef4SAl Viro if (mm && !IS_ERR(mm)) { 2201da177e4SLinus Torvalds unsigned int nwords = 0; 221dfe6b7d9SHannes Eder do { 2221da177e4SLinus Torvalds nwords += 2; 223dfe6b7d9SHannes Eder } while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */ 224f9ea536eSAlexey Dobriyan seq_write(m, mm->saved_auxv, nwords * sizeof(mm->saved_auxv[0])); 2251da177e4SLinus Torvalds mmput(mm); 226f9ea536eSAlexey Dobriyan return 0; 227f9ea536eSAlexey Dobriyan } else 228f9ea536eSAlexey Dobriyan return PTR_ERR(mm); 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds #ifdef CONFIG_KALLSYMS 2331da177e4SLinus Torvalds /* 2341da177e4SLinus Torvalds * Provides a wchan file via kallsyms in a proper one-value-per-file format. 2351da177e4SLinus Torvalds * Returns the resolved symbol. If that fails, simply return the address. 2361da177e4SLinus Torvalds */ 237*edfcd606SAlexey Dobriyan static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns, 238*edfcd606SAlexey Dobriyan struct pid *pid, struct task_struct *task) 2391da177e4SLinus Torvalds { 240ffb45122SAlexey Dobriyan unsigned long wchan; 2419281aceaSTejun Heo char symname[KSYM_NAME_LEN]; 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds wchan = get_wchan(task); 2441da177e4SLinus Torvalds 2459d65cb4aSAlexey Dobriyan if (lookup_symbol_name(wchan, symname) < 0) 246f83ce3e6SJake Edge if (!ptrace_may_access(task, PTRACE_MODE_READ)) 247f83ce3e6SJake Edge return 0; 248f83ce3e6SJake Edge else 249*edfcd606SAlexey Dobriyan return seq_printf(m, "%lu", wchan); 2509d65cb4aSAlexey Dobriyan else 251*edfcd606SAlexey Dobriyan return seq_printf(m, "%s", symname); 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds #endif /* CONFIG_KALLSYMS */ 2541da177e4SLinus Torvalds 255a9712bc1SAl Viro static int lock_trace(struct task_struct *task) 256a9712bc1SAl Viro { 257a9712bc1SAl Viro int err = mutex_lock_killable(&task->signal->cred_guard_mutex); 258a9712bc1SAl Viro if (err) 259a9712bc1SAl Viro return err; 260a9712bc1SAl Viro if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) { 261a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 262a9712bc1SAl Viro return -EPERM; 263a9712bc1SAl Viro } 264a9712bc1SAl Viro return 0; 265a9712bc1SAl Viro } 266a9712bc1SAl Viro 267a9712bc1SAl Viro static void unlock_trace(struct task_struct *task) 268a9712bc1SAl Viro { 269a9712bc1SAl Viro mutex_unlock(&task->signal->cred_guard_mutex); 270a9712bc1SAl Viro } 271a9712bc1SAl Viro 2722ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 2732ec220e2SKen Chen 2742ec220e2SKen Chen #define MAX_STACK_TRACE_DEPTH 64 2752ec220e2SKen Chen 2762ec220e2SKen Chen static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns, 2772ec220e2SKen Chen struct pid *pid, struct task_struct *task) 2782ec220e2SKen Chen { 2792ec220e2SKen Chen struct stack_trace trace; 2802ec220e2SKen Chen unsigned long *entries; 281a9712bc1SAl Viro int err; 2822ec220e2SKen Chen int i; 2832ec220e2SKen Chen 2842ec220e2SKen Chen entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL); 2852ec220e2SKen Chen if (!entries) 2862ec220e2SKen Chen return -ENOMEM; 2872ec220e2SKen Chen 2882ec220e2SKen Chen trace.nr_entries = 0; 2892ec220e2SKen Chen trace.max_entries = MAX_STACK_TRACE_DEPTH; 2902ec220e2SKen Chen trace.entries = entries; 2912ec220e2SKen Chen trace.skip = 0; 292a9712bc1SAl Viro 293a9712bc1SAl Viro err = lock_trace(task); 294a9712bc1SAl Viro if (!err) { 2952ec220e2SKen Chen save_stack_trace_tsk(task, &trace); 2962ec220e2SKen Chen 2972ec220e2SKen Chen for (i = 0; i < trace.nr_entries; i++) { 29851e03149SKonstantin Khlebnikov seq_printf(m, "[<%pK>] %pS\n", 2992ec220e2SKen Chen (void *)entries[i], (void *)entries[i]); 3002ec220e2SKen Chen } 301a9712bc1SAl Viro unlock_trace(task); 302a9712bc1SAl Viro } 3032ec220e2SKen Chen kfree(entries); 3042ec220e2SKen Chen 305a9712bc1SAl Viro return err; 3062ec220e2SKen Chen } 3072ec220e2SKen Chen #endif 3082ec220e2SKen Chen 3091da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 3101da177e4SLinus Torvalds /* 3111da177e4SLinus Torvalds * Provides /proc/PID/schedstat 3121da177e4SLinus Torvalds */ 3131da177e4SLinus Torvalds static int proc_pid_schedstat(struct task_struct *task, char *buffer) 3141da177e4SLinus Torvalds { 315172ba844SBalbir Singh return sprintf(buffer, "%llu %llu %lu\n", 316826e08b0SIngo Molnar (unsigned long long)task->se.sum_exec_runtime, 317826e08b0SIngo Molnar (unsigned long long)task->sched_info.run_delay, 3182d72376bSIngo Molnar task->sched_info.pcount); 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds #endif 3211da177e4SLinus Torvalds 3229745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 3239745512cSArjan van de Ven static int lstats_show_proc(struct seq_file *m, void *v) 3249745512cSArjan van de Ven { 3259745512cSArjan van de Ven int i; 32613d77c37SHiroshi Shimamoto struct inode *inode = m->private; 32713d77c37SHiroshi Shimamoto struct task_struct *task = get_proc_task(inode); 3289745512cSArjan van de Ven 32913d77c37SHiroshi Shimamoto if (!task) 33013d77c37SHiroshi Shimamoto return -ESRCH; 33113d77c37SHiroshi Shimamoto seq_puts(m, "Latency Top version : v0.1\n"); 3329745512cSArjan van de Ven for (i = 0; i < 32; i++) { 33334e49d4fSJoe Perches struct latency_record *lr = &task->latency_record[i]; 33434e49d4fSJoe Perches if (lr->backtrace[0]) { 3359745512cSArjan van de Ven int q; 3369745512cSArjan van de Ven seq_printf(m, "%i %li %li", 33734e49d4fSJoe Perches lr->count, lr->time, lr->max); 3389745512cSArjan van de Ven for (q = 0; q < LT_BACKTRACEDEPTH; q++) { 33934e49d4fSJoe Perches unsigned long bt = lr->backtrace[q]; 34034e49d4fSJoe Perches if (!bt) 3419745512cSArjan van de Ven break; 34234e49d4fSJoe Perches if (bt == ULONG_MAX) 3439745512cSArjan van de Ven break; 34434e49d4fSJoe Perches seq_printf(m, " %ps", (void *)bt); 3459745512cSArjan van de Ven } 3469d6de12fSAlexey Dobriyan seq_putc(m, '\n'); 3479745512cSArjan van de Ven } 3489745512cSArjan van de Ven 3499745512cSArjan van de Ven } 35013d77c37SHiroshi Shimamoto put_task_struct(task); 3519745512cSArjan van de Ven return 0; 3529745512cSArjan van de Ven } 3539745512cSArjan van de Ven 3549745512cSArjan van de Ven static int lstats_open(struct inode *inode, struct file *file) 3559745512cSArjan van de Ven { 35613d77c37SHiroshi Shimamoto return single_open(file, lstats_show_proc, inode); 357d6643d12SHiroshi Shimamoto } 358d6643d12SHiroshi Shimamoto 3599745512cSArjan van de Ven static ssize_t lstats_write(struct file *file, const char __user *buf, 3609745512cSArjan van de Ven size_t count, loff_t *offs) 3619745512cSArjan van de Ven { 362496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 3639745512cSArjan van de Ven 36413d77c37SHiroshi Shimamoto if (!task) 36513d77c37SHiroshi Shimamoto return -ESRCH; 3669745512cSArjan van de Ven clear_all_latency_tracing(task); 36713d77c37SHiroshi Shimamoto put_task_struct(task); 3689745512cSArjan van de Ven 3699745512cSArjan van de Ven return count; 3709745512cSArjan van de Ven } 3719745512cSArjan van de Ven 3729745512cSArjan van de Ven static const struct file_operations proc_lstats_operations = { 3739745512cSArjan van de Ven .open = lstats_open, 3749745512cSArjan van de Ven .read = seq_read, 3759745512cSArjan van de Ven .write = lstats_write, 3769745512cSArjan van de Ven .llseek = seq_lseek, 37713d77c37SHiroshi Shimamoto .release = single_release, 3789745512cSArjan van de Ven }; 3799745512cSArjan van de Ven 3809745512cSArjan van de Ven #endif 3819745512cSArjan van de Ven 3828d8b97baSAl Viro #ifdef CONFIG_CGROUPS 3838d8b97baSAl Viro static int cgroup_open(struct inode *inode, struct file *file) 3848d8b97baSAl Viro { 3858d8b97baSAl Viro struct pid *pid = PROC_I(inode)->pid; 3868d8b97baSAl Viro return single_open(file, proc_cgroup_show, pid); 3878d8b97baSAl Viro } 3888d8b97baSAl Viro 3898d8b97baSAl Viro static const struct file_operations proc_cgroup_operations = { 3908d8b97baSAl Viro .open = cgroup_open, 3918d8b97baSAl Viro .read = seq_read, 3928d8b97baSAl Viro .llseek = seq_lseek, 3938d8b97baSAl Viro .release = single_release, 3948d8b97baSAl Viro }; 3958d8b97baSAl Viro #endif 3968d8b97baSAl Viro 3978d8b97baSAl Viro #ifdef CONFIG_PROC_PID_CPUSET 3988d8b97baSAl Viro 3998d8b97baSAl Viro static int cpuset_open(struct inode *inode, struct file *file) 4008d8b97baSAl Viro { 4018d8b97baSAl Viro struct pid *pid = PROC_I(inode)->pid; 4028d8b97baSAl Viro return single_open(file, proc_cpuset_show, pid); 4038d8b97baSAl Viro } 4048d8b97baSAl Viro 4058d8b97baSAl Viro static const struct file_operations proc_cpuset_operations = { 4068d8b97baSAl Viro .open = cpuset_open, 4078d8b97baSAl Viro .read = seq_read, 4088d8b97baSAl Viro .llseek = seq_lseek, 4098d8b97baSAl Viro .release = single_release, 4108d8b97baSAl Viro }; 4118d8b97baSAl Viro #endif 4128d8b97baSAl Viro 4131da177e4SLinus Torvalds static int proc_oom_score(struct task_struct *task, char *buffer) 4141da177e4SLinus Torvalds { 415a7f638f9SDavid Rientjes unsigned long totalpages = totalram_pages + total_swap_pages; 416b95c35e7SOleg Nesterov unsigned long points = 0; 4171da177e4SLinus Torvalds 41819c5d45aSAlexey Dobriyan read_lock(&tasklist_lock); 419b95c35e7SOleg Nesterov if (pid_alive(task)) 420a7f638f9SDavid Rientjes points = oom_badness(task, NULL, NULL, totalpages) * 421a7f638f9SDavid Rientjes 1000 / totalpages; 42219c5d45aSAlexey Dobriyan read_unlock(&tasklist_lock); 4231da177e4SLinus Torvalds return sprintf(buffer, "%lu\n", points); 4241da177e4SLinus Torvalds } 4251da177e4SLinus Torvalds 426d85f50d5SNeil Horman struct limit_names { 427cedbccabSAlexey Dobriyan const char *name; 428cedbccabSAlexey Dobriyan const char *unit; 429d85f50d5SNeil Horman }; 430d85f50d5SNeil Horman 431d85f50d5SNeil Horman static const struct limit_names lnames[RLIM_NLIMITS] = { 432cff4edb5SKees Cook [RLIMIT_CPU] = {"Max cpu time", "seconds"}, 433d85f50d5SNeil Horman [RLIMIT_FSIZE] = {"Max file size", "bytes"}, 434d85f50d5SNeil Horman [RLIMIT_DATA] = {"Max data size", "bytes"}, 435d85f50d5SNeil Horman [RLIMIT_STACK] = {"Max stack size", "bytes"}, 436d85f50d5SNeil Horman [RLIMIT_CORE] = {"Max core file size", "bytes"}, 437d85f50d5SNeil Horman [RLIMIT_RSS] = {"Max resident set", "bytes"}, 438d85f50d5SNeil Horman [RLIMIT_NPROC] = {"Max processes", "processes"}, 439d85f50d5SNeil Horman [RLIMIT_NOFILE] = {"Max open files", "files"}, 440d85f50d5SNeil Horman [RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"}, 441d85f50d5SNeil Horman [RLIMIT_AS] = {"Max address space", "bytes"}, 442d85f50d5SNeil Horman [RLIMIT_LOCKS] = {"Max file locks", "locks"}, 443d85f50d5SNeil Horman [RLIMIT_SIGPENDING] = {"Max pending signals", "signals"}, 444d85f50d5SNeil Horman [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"}, 445d85f50d5SNeil Horman [RLIMIT_NICE] = {"Max nice priority", NULL}, 446d85f50d5SNeil Horman [RLIMIT_RTPRIO] = {"Max realtime priority", NULL}, 4478808117cSEugene Teo [RLIMIT_RTTIME] = {"Max realtime timeout", "us"}, 448d85f50d5SNeil Horman }; 449d85f50d5SNeil Horman 450d85f50d5SNeil Horman /* Display limits for a process */ 4511c963eb1SAlexey Dobriyan static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns, 4521c963eb1SAlexey Dobriyan struct pid *pid, struct task_struct *task) 453d85f50d5SNeil Horman { 454d85f50d5SNeil Horman unsigned int i; 455d85f50d5SNeil Horman unsigned long flags; 456d85f50d5SNeil Horman 457d85f50d5SNeil Horman struct rlimit rlim[RLIM_NLIMITS]; 458d85f50d5SNeil Horman 459a6bebbc8SLai Jiangshan if (!lock_task_sighand(task, &flags)) 460d85f50d5SNeil Horman return 0; 461d85f50d5SNeil Horman memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS); 462d85f50d5SNeil Horman unlock_task_sighand(task, &flags); 463d85f50d5SNeil Horman 464d85f50d5SNeil Horman /* 465d85f50d5SNeil Horman * print the file header 466d85f50d5SNeil Horman */ 4671c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s %-20s %-10s\n", 468d85f50d5SNeil Horman "Limit", "Soft Limit", "Hard Limit", "Units"); 469d85f50d5SNeil Horman 470d85f50d5SNeil Horman for (i = 0; i < RLIM_NLIMITS; i++) { 471d85f50d5SNeil Horman if (rlim[i].rlim_cur == RLIM_INFINITY) 4721c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20s ", 473d85f50d5SNeil Horman lnames[i].name, "unlimited"); 474d85f50d5SNeil Horman else 4751c963eb1SAlexey Dobriyan seq_printf(m, "%-25s %-20lu ", 476d85f50d5SNeil Horman lnames[i].name, rlim[i].rlim_cur); 477d85f50d5SNeil Horman 478d85f50d5SNeil Horman if (rlim[i].rlim_max == RLIM_INFINITY) 4791c963eb1SAlexey Dobriyan seq_printf(m, "%-20s ", "unlimited"); 480d85f50d5SNeil Horman else 4811c963eb1SAlexey Dobriyan seq_printf(m, "%-20lu ", rlim[i].rlim_max); 482d85f50d5SNeil Horman 483d85f50d5SNeil Horman if (lnames[i].unit) 4841c963eb1SAlexey Dobriyan seq_printf(m, "%-10s\n", lnames[i].unit); 485d85f50d5SNeil Horman else 4861c963eb1SAlexey Dobriyan seq_putc(m, '\n'); 487d85f50d5SNeil Horman } 488d85f50d5SNeil Horman 4891c963eb1SAlexey Dobriyan return 0; 490d85f50d5SNeil Horman } 491d85f50d5SNeil Horman 492ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 49309d93bd6SAlexey Dobriyan static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns, 49409d93bd6SAlexey Dobriyan struct pid *pid, struct task_struct *task) 495ebcb6734SRoland McGrath { 496ebcb6734SRoland McGrath long nr; 497ebcb6734SRoland McGrath unsigned long args[6], sp, pc; 498a9712bc1SAl Viro int res = lock_trace(task); 499a9712bc1SAl Viro if (res) 500a9712bc1SAl Viro return res; 501ebcb6734SRoland McGrath 502ebcb6734SRoland McGrath if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) 50309d93bd6SAlexey Dobriyan seq_puts(m, "running\n"); 504a9712bc1SAl Viro else if (nr < 0) 50509d93bd6SAlexey Dobriyan seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc); 506a9712bc1SAl Viro else 50709d93bd6SAlexey Dobriyan seq_printf(m, 508ebcb6734SRoland McGrath "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 509ebcb6734SRoland McGrath nr, 510ebcb6734SRoland McGrath args[0], args[1], args[2], args[3], args[4], args[5], 511ebcb6734SRoland McGrath sp, pc); 512a9712bc1SAl Viro unlock_trace(task); 513a9712bc1SAl Viro return res; 514ebcb6734SRoland McGrath } 515ebcb6734SRoland McGrath #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */ 516ebcb6734SRoland McGrath 5171da177e4SLinus Torvalds /************************************************************************/ 5181da177e4SLinus Torvalds /* Here the fs part begins */ 5191da177e4SLinus Torvalds /************************************************************************/ 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds /* permission checks */ 522778c1144SEric W. Biederman static int proc_fd_access_allowed(struct inode *inode) 5231da177e4SLinus Torvalds { 524778c1144SEric W. Biederman struct task_struct *task; 525778c1144SEric W. Biederman int allowed = 0; 526df26c40eSEric W. Biederman /* Allow access to a task's file descriptors if it is us or we 527df26c40eSEric W. Biederman * may use ptrace attach to the process and find out that 528df26c40eSEric W. Biederman * information. 529778c1144SEric W. Biederman */ 530778c1144SEric W. Biederman task = get_proc_task(inode); 531df26c40eSEric W. Biederman if (task) { 532006ebb40SStephen Smalley allowed = ptrace_may_access(task, PTRACE_MODE_READ); 533778c1144SEric W. Biederman put_task_struct(task); 534df26c40eSEric W. Biederman } 535778c1144SEric W. Biederman return allowed; 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds 5386b4e306aSEric W. Biederman int proc_setattr(struct dentry *dentry, struct iattr *attr) 5396d76fa58SLinus Torvalds { 5406d76fa58SLinus Torvalds int error; 5416d76fa58SLinus Torvalds struct inode *inode = dentry->d_inode; 5426d76fa58SLinus Torvalds 5436d76fa58SLinus Torvalds if (attr->ia_valid & ATTR_MODE) 5446d76fa58SLinus Torvalds return -EPERM; 5456d76fa58SLinus Torvalds 5466d76fa58SLinus Torvalds error = inode_change_ok(inode, attr); 5471025774cSChristoph Hellwig if (error) 5486d76fa58SLinus Torvalds return error; 5491025774cSChristoph Hellwig 5501025774cSChristoph Hellwig setattr_copy(inode, attr); 5511025774cSChristoph Hellwig mark_inode_dirty(inode); 5521025774cSChristoph Hellwig return 0; 5536d76fa58SLinus Torvalds } 5546d76fa58SLinus Torvalds 5550499680aSVasiliy Kulikov /* 5560499680aSVasiliy Kulikov * May current process learn task's sched/cmdline info (for hide_pid_min=1) 5570499680aSVasiliy Kulikov * or euid/egid (for hide_pid_min=2)? 5580499680aSVasiliy Kulikov */ 5590499680aSVasiliy Kulikov static bool has_pid_permissions(struct pid_namespace *pid, 5600499680aSVasiliy Kulikov struct task_struct *task, 5610499680aSVasiliy Kulikov int hide_pid_min) 5620499680aSVasiliy Kulikov { 5630499680aSVasiliy Kulikov if (pid->hide_pid < hide_pid_min) 5640499680aSVasiliy Kulikov return true; 5650499680aSVasiliy Kulikov if (in_group_p(pid->pid_gid)) 5660499680aSVasiliy Kulikov return true; 5670499680aSVasiliy Kulikov return ptrace_may_access(task, PTRACE_MODE_READ); 5680499680aSVasiliy Kulikov } 5690499680aSVasiliy Kulikov 5700499680aSVasiliy Kulikov 5710499680aSVasiliy Kulikov static int proc_pid_permission(struct inode *inode, int mask) 5720499680aSVasiliy Kulikov { 5730499680aSVasiliy Kulikov struct pid_namespace *pid = inode->i_sb->s_fs_info; 5740499680aSVasiliy Kulikov struct task_struct *task; 5750499680aSVasiliy Kulikov bool has_perms; 5760499680aSVasiliy Kulikov 5770499680aSVasiliy Kulikov task = get_proc_task(inode); 578a2ef990aSXiaotian Feng if (!task) 579a2ef990aSXiaotian Feng return -ESRCH; 5800499680aSVasiliy Kulikov has_perms = has_pid_permissions(pid, task, 1); 5810499680aSVasiliy Kulikov put_task_struct(task); 5820499680aSVasiliy Kulikov 5830499680aSVasiliy Kulikov if (!has_perms) { 5840499680aSVasiliy Kulikov if (pid->hide_pid == 2) { 5850499680aSVasiliy Kulikov /* 5860499680aSVasiliy Kulikov * Let's make getdents(), stat(), and open() 5870499680aSVasiliy Kulikov * consistent with each other. If a process 5880499680aSVasiliy Kulikov * may not stat() a file, it shouldn't be seen 5890499680aSVasiliy Kulikov * in procfs at all. 5900499680aSVasiliy Kulikov */ 5910499680aSVasiliy Kulikov return -ENOENT; 5920499680aSVasiliy Kulikov } 5930499680aSVasiliy Kulikov 5940499680aSVasiliy Kulikov return -EPERM; 5950499680aSVasiliy Kulikov } 5960499680aSVasiliy Kulikov return generic_permission(inode, mask); 5970499680aSVasiliy Kulikov } 5980499680aSVasiliy Kulikov 5990499680aSVasiliy Kulikov 6000499680aSVasiliy Kulikov 601c5ef1c42SArjan van de Ven static const struct inode_operations proc_def_inode_operations = { 6026d76fa58SLinus Torvalds .setattr = proc_setattr, 6036d76fa58SLinus Torvalds }; 6046d76fa58SLinus Torvalds 6051da177e4SLinus Torvalds #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */ 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds static ssize_t proc_info_read(struct file * file, char __user * buf, 6081da177e4SLinus Torvalds size_t count, loff_t *ppos) 6091da177e4SLinus Torvalds { 610496ad9aaSAl Viro struct inode * inode = file_inode(file); 6111da177e4SLinus Torvalds unsigned long page; 6121da177e4SLinus Torvalds ssize_t length; 61399f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 61499f89551SEric W. Biederman 61599f89551SEric W. Biederman length = -ESRCH; 61699f89551SEric W. Biederman if (!task) 61799f89551SEric W. Biederman goto out_no_task; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds if (count > PROC_BLOCK_SIZE) 6201da177e4SLinus Torvalds count = PROC_BLOCK_SIZE; 62199f89551SEric W. Biederman 62299f89551SEric W. Biederman length = -ENOMEM; 623e12ba74dSMel Gorman if (!(page = __get_free_page(GFP_TEMPORARY))) 62499f89551SEric W. Biederman goto out; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds length = PROC_I(inode)->op.proc_read(task, (char*)page); 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds if (length >= 0) 6291da177e4SLinus Torvalds length = simple_read_from_buffer(buf, count, ppos, (char *)page, length); 6301da177e4SLinus Torvalds free_page(page); 63199f89551SEric W. Biederman out: 63299f89551SEric W. Biederman put_task_struct(task); 63399f89551SEric W. Biederman out_no_task: 6341da177e4SLinus Torvalds return length; 6351da177e4SLinus Torvalds } 6361da177e4SLinus Torvalds 63700977a59SArjan van de Ven static const struct file_operations proc_info_file_operations = { 6381da177e4SLinus Torvalds .read = proc_info_read, 63987df8424SArnd Bergmann .llseek = generic_file_llseek, 6401da177e4SLinus Torvalds }; 6411da177e4SLinus Torvalds 642be614086SEric W. Biederman static int proc_single_show(struct seq_file *m, void *v) 643be614086SEric W. Biederman { 644be614086SEric W. Biederman struct inode *inode = m->private; 645be614086SEric W. Biederman struct pid_namespace *ns; 646be614086SEric W. Biederman struct pid *pid; 647be614086SEric W. Biederman struct task_struct *task; 648be614086SEric W. Biederman int ret; 649be614086SEric W. Biederman 650be614086SEric W. Biederman ns = inode->i_sb->s_fs_info; 651be614086SEric W. Biederman pid = proc_pid(inode); 652be614086SEric W. Biederman task = get_pid_task(pid, PIDTYPE_PID); 653be614086SEric W. Biederman if (!task) 654be614086SEric W. Biederman return -ESRCH; 655be614086SEric W. Biederman 656be614086SEric W. Biederman ret = PROC_I(inode)->op.proc_show(m, ns, pid, task); 657be614086SEric W. Biederman 658be614086SEric W. Biederman put_task_struct(task); 659be614086SEric W. Biederman return ret; 660be614086SEric W. Biederman } 661be614086SEric W. Biederman 662be614086SEric W. Biederman static int proc_single_open(struct inode *inode, struct file *filp) 663be614086SEric W. Biederman { 664c6a34058SJovi Zhang return single_open(filp, proc_single_show, inode); 665be614086SEric W. Biederman } 666be614086SEric W. Biederman 667be614086SEric W. Biederman static const struct file_operations proc_single_file_operations = { 668be614086SEric W. Biederman .open = proc_single_open, 669be614086SEric W. Biederman .read = seq_read, 670be614086SEric W. Biederman .llseek = seq_lseek, 671be614086SEric W. Biederman .release = single_release, 672be614086SEric W. Biederman }; 673be614086SEric W. Biederman 674b409e578SCong Wang static int __mem_open(struct inode *inode, struct file *file, unsigned int mode) 6751da177e4SLinus Torvalds { 676496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 677e268337dSLinus Torvalds struct mm_struct *mm; 678e268337dSLinus Torvalds 679e268337dSLinus Torvalds if (!task) 680e268337dSLinus Torvalds return -ESRCH; 681e268337dSLinus Torvalds 682b409e578SCong Wang mm = mm_access(task, mode); 683e268337dSLinus Torvalds put_task_struct(task); 684e268337dSLinus Torvalds 685e268337dSLinus Torvalds if (IS_ERR(mm)) 686e268337dSLinus Torvalds return PTR_ERR(mm); 687e268337dSLinus Torvalds 6886d08f2c7SOleg Nesterov if (mm) { 6896d08f2c7SOleg Nesterov /* ensure this mm_struct can't be freed */ 6906d08f2c7SOleg Nesterov atomic_inc(&mm->mm_count); 6916d08f2c7SOleg Nesterov /* but do not pin its memory */ 6926d08f2c7SOleg Nesterov mmput(mm); 6936d08f2c7SOleg Nesterov } 6946d08f2c7SOleg Nesterov 695e268337dSLinus Torvalds file->private_data = mm; 696e268337dSLinus Torvalds 6971da177e4SLinus Torvalds return 0; 6981da177e4SLinus Torvalds } 6991da177e4SLinus Torvalds 700b409e578SCong Wang static int mem_open(struct inode *inode, struct file *file) 701b409e578SCong Wang { 702bc452b4bSDjalal Harouni int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH); 703bc452b4bSDjalal Harouni 704bc452b4bSDjalal Harouni /* OK to pass negative loff_t, we can catch out-of-range */ 705bc452b4bSDjalal Harouni file->f_mode |= FMODE_UNSIGNED_OFFSET; 706bc452b4bSDjalal Harouni 707bc452b4bSDjalal Harouni return ret; 708b409e578SCong Wang } 709b409e578SCong Wang 710572d34b9SOleg Nesterov static ssize_t mem_rw(struct file *file, char __user *buf, 711572d34b9SOleg Nesterov size_t count, loff_t *ppos, int write) 7121da177e4SLinus Torvalds { 713e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 714572d34b9SOleg Nesterov unsigned long addr = *ppos; 715572d34b9SOleg Nesterov ssize_t copied; 7161da177e4SLinus Torvalds char *page; 7171da177e4SLinus Torvalds 718e268337dSLinus Torvalds if (!mm) 719e268337dSLinus Torvalds return 0; 7201da177e4SLinus Torvalds 721e12ba74dSMel Gorman page = (char *)__get_free_page(GFP_TEMPORARY); 7221da177e4SLinus Torvalds if (!page) 723e268337dSLinus Torvalds return -ENOMEM; 7241da177e4SLinus Torvalds 725f7ca54f4SFrederik Deweerdt copied = 0; 7266d08f2c7SOleg Nesterov if (!atomic_inc_not_zero(&mm->mm_users)) 7276d08f2c7SOleg Nesterov goto free; 7286d08f2c7SOleg Nesterov 7291da177e4SLinus Torvalds while (count > 0) { 730572d34b9SOleg Nesterov int this_len = min_t(int, count, PAGE_SIZE); 7311da177e4SLinus Torvalds 732572d34b9SOleg Nesterov if (write && copy_from_user(page, buf, this_len)) { 7331da177e4SLinus Torvalds copied = -EFAULT; 7341da177e4SLinus Torvalds break; 7351da177e4SLinus Torvalds } 736572d34b9SOleg Nesterov 737572d34b9SOleg Nesterov this_len = access_remote_vm(mm, addr, page, this_len, write); 738572d34b9SOleg Nesterov if (!this_len) { 7391da177e4SLinus Torvalds if (!copied) 7401da177e4SLinus Torvalds copied = -EIO; 7411da177e4SLinus Torvalds break; 7421da177e4SLinus Torvalds } 743572d34b9SOleg Nesterov 744572d34b9SOleg Nesterov if (!write && copy_to_user(buf, page, this_len)) { 745572d34b9SOleg Nesterov copied = -EFAULT; 746572d34b9SOleg Nesterov break; 7471da177e4SLinus Torvalds } 748572d34b9SOleg Nesterov 749572d34b9SOleg Nesterov buf += this_len; 750572d34b9SOleg Nesterov addr += this_len; 751572d34b9SOleg Nesterov copied += this_len; 752572d34b9SOleg Nesterov count -= this_len; 753572d34b9SOleg Nesterov } 754572d34b9SOleg Nesterov *ppos = addr; 75530cd8903SKOSAKI Motohiro 7566d08f2c7SOleg Nesterov mmput(mm); 7576d08f2c7SOleg Nesterov free: 75830cd8903SKOSAKI Motohiro free_page((unsigned long) page); 7591da177e4SLinus Torvalds return copied; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 762572d34b9SOleg Nesterov static ssize_t mem_read(struct file *file, char __user *buf, 763572d34b9SOleg Nesterov size_t count, loff_t *ppos) 764572d34b9SOleg Nesterov { 765572d34b9SOleg Nesterov return mem_rw(file, buf, count, ppos, 0); 766572d34b9SOleg Nesterov } 767572d34b9SOleg Nesterov 768572d34b9SOleg Nesterov static ssize_t mem_write(struct file *file, const char __user *buf, 769572d34b9SOleg Nesterov size_t count, loff_t *ppos) 770572d34b9SOleg Nesterov { 771572d34b9SOleg Nesterov return mem_rw(file, (char __user*)buf, count, ppos, 1); 772572d34b9SOleg Nesterov } 773572d34b9SOleg Nesterov 77485863e47SMatt Mackall loff_t mem_lseek(struct file *file, loff_t offset, int orig) 7751da177e4SLinus Torvalds { 7761da177e4SLinus Torvalds switch (orig) { 7771da177e4SLinus Torvalds case 0: 7781da177e4SLinus Torvalds file->f_pos = offset; 7791da177e4SLinus Torvalds break; 7801da177e4SLinus Torvalds case 1: 7811da177e4SLinus Torvalds file->f_pos += offset; 7821da177e4SLinus Torvalds break; 7831da177e4SLinus Torvalds default: 7841da177e4SLinus Torvalds return -EINVAL; 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds force_successful_syscall_return(); 7871da177e4SLinus Torvalds return file->f_pos; 7881da177e4SLinus Torvalds } 7891da177e4SLinus Torvalds 790e268337dSLinus Torvalds static int mem_release(struct inode *inode, struct file *file) 791e268337dSLinus Torvalds { 792e268337dSLinus Torvalds struct mm_struct *mm = file->private_data; 79371879d3cSOleg Nesterov if (mm) 7946d08f2c7SOleg Nesterov mmdrop(mm); 795e268337dSLinus Torvalds return 0; 796e268337dSLinus Torvalds } 797e268337dSLinus Torvalds 79800977a59SArjan van de Ven static const struct file_operations proc_mem_operations = { 7991da177e4SLinus Torvalds .llseek = mem_lseek, 8001da177e4SLinus Torvalds .read = mem_read, 8011da177e4SLinus Torvalds .write = mem_write, 8021da177e4SLinus Torvalds .open = mem_open, 803e268337dSLinus Torvalds .release = mem_release, 8041da177e4SLinus Torvalds }; 8051da177e4SLinus Torvalds 806b409e578SCong Wang static int environ_open(struct inode *inode, struct file *file) 807b409e578SCong Wang { 808b409e578SCong Wang return __mem_open(inode, file, PTRACE_MODE_READ); 809b409e578SCong Wang } 810b409e578SCong Wang 811315e28c8SJames Pearson static ssize_t environ_read(struct file *file, char __user *buf, 812315e28c8SJames Pearson size_t count, loff_t *ppos) 813315e28c8SJames Pearson { 814315e28c8SJames Pearson char *page; 815315e28c8SJames Pearson unsigned long src = *ppos; 816b409e578SCong Wang int ret = 0; 817b409e578SCong Wang struct mm_struct *mm = file->private_data; 818315e28c8SJames Pearson 819b409e578SCong Wang if (!mm) 820b409e578SCong Wang return 0; 821315e28c8SJames Pearson 822315e28c8SJames Pearson page = (char *)__get_free_page(GFP_TEMPORARY); 823315e28c8SJames Pearson if (!page) 824b409e578SCong Wang return -ENOMEM; 825315e28c8SJames Pearson 826d6f64b89SAl Viro ret = 0; 827b409e578SCong Wang if (!atomic_inc_not_zero(&mm->mm_users)) 828b409e578SCong Wang goto free; 829315e28c8SJames Pearson while (count > 0) { 830e8905ec2SDjalal Harouni size_t this_len, max_len; 831e8905ec2SDjalal Harouni int retval; 832e8905ec2SDjalal Harouni 833e8905ec2SDjalal Harouni if (src >= (mm->env_end - mm->env_start)) 834e8905ec2SDjalal Harouni break; 835315e28c8SJames Pearson 836315e28c8SJames Pearson this_len = mm->env_end - (mm->env_start + src); 837315e28c8SJames Pearson 838e8905ec2SDjalal Harouni max_len = min_t(size_t, PAGE_SIZE, count); 839e8905ec2SDjalal Harouni this_len = min(max_len, this_len); 840315e28c8SJames Pearson 841b409e578SCong Wang retval = access_remote_vm(mm, (mm->env_start + src), 842315e28c8SJames Pearson page, this_len, 0); 843315e28c8SJames Pearson 844315e28c8SJames Pearson if (retval <= 0) { 845315e28c8SJames Pearson ret = retval; 846315e28c8SJames Pearson break; 847315e28c8SJames Pearson } 848315e28c8SJames Pearson 849315e28c8SJames Pearson if (copy_to_user(buf, page, retval)) { 850315e28c8SJames Pearson ret = -EFAULT; 851315e28c8SJames Pearson break; 852315e28c8SJames Pearson } 853315e28c8SJames Pearson 854315e28c8SJames Pearson ret += retval; 855315e28c8SJames Pearson src += retval; 856315e28c8SJames Pearson buf += retval; 857315e28c8SJames Pearson count -= retval; 858315e28c8SJames Pearson } 859315e28c8SJames Pearson *ppos = src; 860315e28c8SJames Pearson mmput(mm); 861b409e578SCong Wang 862b409e578SCong Wang free: 863315e28c8SJames Pearson free_page((unsigned long) page); 864315e28c8SJames Pearson return ret; 865315e28c8SJames Pearson } 866315e28c8SJames Pearson 867315e28c8SJames Pearson static const struct file_operations proc_environ_operations = { 868b409e578SCong Wang .open = environ_open, 869315e28c8SJames Pearson .read = environ_read, 87087df8424SArnd Bergmann .llseek = generic_file_llseek, 871b409e578SCong Wang .release = mem_release, 872315e28c8SJames Pearson }; 873315e28c8SJames Pearson 874fa0cbbf1SDavid Rientjes static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count, 875fa0cbbf1SDavid Rientjes loff_t *ppos) 876fa0cbbf1SDavid Rientjes { 877496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 878fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 879fa0cbbf1SDavid Rientjes int oom_adj = OOM_ADJUST_MIN; 880fa0cbbf1SDavid Rientjes size_t len; 881fa0cbbf1SDavid Rientjes unsigned long flags; 882fa0cbbf1SDavid Rientjes 883fa0cbbf1SDavid Rientjes if (!task) 884fa0cbbf1SDavid Rientjes return -ESRCH; 885fa0cbbf1SDavid Rientjes if (lock_task_sighand(task, &flags)) { 886fa0cbbf1SDavid Rientjes if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX) 887fa0cbbf1SDavid Rientjes oom_adj = OOM_ADJUST_MAX; 888fa0cbbf1SDavid Rientjes else 889fa0cbbf1SDavid Rientjes oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) / 890fa0cbbf1SDavid Rientjes OOM_SCORE_ADJ_MAX; 891fa0cbbf1SDavid Rientjes unlock_task_sighand(task, &flags); 892fa0cbbf1SDavid Rientjes } 893fa0cbbf1SDavid Rientjes put_task_struct(task); 894fa0cbbf1SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj); 895fa0cbbf1SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 896fa0cbbf1SDavid Rientjes } 897fa0cbbf1SDavid Rientjes 898fa0cbbf1SDavid Rientjes static ssize_t oom_adj_write(struct file *file, const char __user *buf, 899fa0cbbf1SDavid Rientjes size_t count, loff_t *ppos) 900fa0cbbf1SDavid Rientjes { 901fa0cbbf1SDavid Rientjes struct task_struct *task; 902fa0cbbf1SDavid Rientjes char buffer[PROC_NUMBUF]; 903fa0cbbf1SDavid Rientjes int oom_adj; 904fa0cbbf1SDavid Rientjes unsigned long flags; 905fa0cbbf1SDavid Rientjes int err; 906fa0cbbf1SDavid Rientjes 907fa0cbbf1SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 908fa0cbbf1SDavid Rientjes if (count > sizeof(buffer) - 1) 909fa0cbbf1SDavid Rientjes count = sizeof(buffer) - 1; 910fa0cbbf1SDavid Rientjes if (copy_from_user(buffer, buf, count)) { 911fa0cbbf1SDavid Rientjes err = -EFAULT; 912fa0cbbf1SDavid Rientjes goto out; 913fa0cbbf1SDavid Rientjes } 914fa0cbbf1SDavid Rientjes 915fa0cbbf1SDavid Rientjes err = kstrtoint(strstrip(buffer), 0, &oom_adj); 916fa0cbbf1SDavid Rientjes if (err) 917fa0cbbf1SDavid Rientjes goto out; 918fa0cbbf1SDavid Rientjes if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) && 919fa0cbbf1SDavid Rientjes oom_adj != OOM_DISABLE) { 920fa0cbbf1SDavid Rientjes err = -EINVAL; 921fa0cbbf1SDavid Rientjes goto out; 922fa0cbbf1SDavid Rientjes } 923fa0cbbf1SDavid Rientjes 924496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 925fa0cbbf1SDavid Rientjes if (!task) { 926fa0cbbf1SDavid Rientjes err = -ESRCH; 927fa0cbbf1SDavid Rientjes goto out; 928fa0cbbf1SDavid Rientjes } 929fa0cbbf1SDavid Rientjes 930fa0cbbf1SDavid Rientjes task_lock(task); 931fa0cbbf1SDavid Rientjes if (!task->mm) { 932fa0cbbf1SDavid Rientjes err = -EINVAL; 933fa0cbbf1SDavid Rientjes goto err_task_lock; 934fa0cbbf1SDavid Rientjes } 935fa0cbbf1SDavid Rientjes 936fa0cbbf1SDavid Rientjes if (!lock_task_sighand(task, &flags)) { 937fa0cbbf1SDavid Rientjes err = -ESRCH; 938fa0cbbf1SDavid Rientjes goto err_task_lock; 939fa0cbbf1SDavid Rientjes } 940fa0cbbf1SDavid Rientjes 941fa0cbbf1SDavid Rientjes /* 942fa0cbbf1SDavid Rientjes * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum 943fa0cbbf1SDavid Rientjes * value is always attainable. 944fa0cbbf1SDavid Rientjes */ 945fa0cbbf1SDavid Rientjes if (oom_adj == OOM_ADJUST_MAX) 946fa0cbbf1SDavid Rientjes oom_adj = OOM_SCORE_ADJ_MAX; 947fa0cbbf1SDavid Rientjes else 948fa0cbbf1SDavid Rientjes oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE; 949fa0cbbf1SDavid Rientjes 950fa0cbbf1SDavid Rientjes if (oom_adj < task->signal->oom_score_adj && 951fa0cbbf1SDavid Rientjes !capable(CAP_SYS_RESOURCE)) { 952fa0cbbf1SDavid Rientjes err = -EACCES; 953fa0cbbf1SDavid Rientjes goto err_sighand; 954fa0cbbf1SDavid Rientjes } 955fa0cbbf1SDavid Rientjes 956fa0cbbf1SDavid Rientjes /* 957fa0cbbf1SDavid Rientjes * /proc/pid/oom_adj is provided for legacy purposes, ask users to use 958fa0cbbf1SDavid Rientjes * /proc/pid/oom_score_adj instead. 959fa0cbbf1SDavid Rientjes */ 96087ebdc00SAndrew Morton pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n", 961fa0cbbf1SDavid Rientjes current->comm, task_pid_nr(current), task_pid_nr(task), 962fa0cbbf1SDavid Rientjes task_pid_nr(task)); 963fa0cbbf1SDavid Rientjes 964fa0cbbf1SDavid Rientjes task->signal->oom_score_adj = oom_adj; 965fa0cbbf1SDavid Rientjes trace_oom_score_adj_update(task); 966fa0cbbf1SDavid Rientjes err_sighand: 967fa0cbbf1SDavid Rientjes unlock_task_sighand(task, &flags); 968fa0cbbf1SDavid Rientjes err_task_lock: 969fa0cbbf1SDavid Rientjes task_unlock(task); 970fa0cbbf1SDavid Rientjes put_task_struct(task); 971fa0cbbf1SDavid Rientjes out: 972fa0cbbf1SDavid Rientjes return err < 0 ? err : count; 973fa0cbbf1SDavid Rientjes } 974fa0cbbf1SDavid Rientjes 975fa0cbbf1SDavid Rientjes static const struct file_operations proc_oom_adj_operations = { 976fa0cbbf1SDavid Rientjes .read = oom_adj_read, 977fa0cbbf1SDavid Rientjes .write = oom_adj_write, 978fa0cbbf1SDavid Rientjes .llseek = generic_file_llseek, 979fa0cbbf1SDavid Rientjes }; 980fa0cbbf1SDavid Rientjes 981a63d83f4SDavid Rientjes static ssize_t oom_score_adj_read(struct file *file, char __user *buf, 982a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 983a63d83f4SDavid Rientjes { 984496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 985a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 986a9c58b90SDavid Rientjes short oom_score_adj = OOM_SCORE_ADJ_MIN; 987a63d83f4SDavid Rientjes unsigned long flags; 988a63d83f4SDavid Rientjes size_t len; 989a63d83f4SDavid Rientjes 990a63d83f4SDavid Rientjes if (!task) 991a63d83f4SDavid Rientjes return -ESRCH; 992a63d83f4SDavid Rientjes if (lock_task_sighand(task, &flags)) { 993a63d83f4SDavid Rientjes oom_score_adj = task->signal->oom_score_adj; 994a63d83f4SDavid Rientjes unlock_task_sighand(task, &flags); 995a63d83f4SDavid Rientjes } 996a63d83f4SDavid Rientjes put_task_struct(task); 997a9c58b90SDavid Rientjes len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj); 998a63d83f4SDavid Rientjes return simple_read_from_buffer(buf, count, ppos, buffer, len); 999a63d83f4SDavid Rientjes } 1000a63d83f4SDavid Rientjes 1001a63d83f4SDavid Rientjes static ssize_t oom_score_adj_write(struct file *file, const char __user *buf, 1002a63d83f4SDavid Rientjes size_t count, loff_t *ppos) 1003a63d83f4SDavid Rientjes { 1004a63d83f4SDavid Rientjes struct task_struct *task; 1005a63d83f4SDavid Rientjes char buffer[PROC_NUMBUF]; 1006a63d83f4SDavid Rientjes unsigned long flags; 10070a8cb8e3SAlexey Dobriyan int oom_score_adj; 1008a63d83f4SDavid Rientjes int err; 1009a63d83f4SDavid Rientjes 1010a63d83f4SDavid Rientjes memset(buffer, 0, sizeof(buffer)); 1011a63d83f4SDavid Rientjes if (count > sizeof(buffer) - 1) 1012a63d83f4SDavid Rientjes count = sizeof(buffer) - 1; 1013723548bfSDavid Rientjes if (copy_from_user(buffer, buf, count)) { 1014723548bfSDavid Rientjes err = -EFAULT; 1015723548bfSDavid Rientjes goto out; 1016723548bfSDavid Rientjes } 1017a63d83f4SDavid Rientjes 10180a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &oom_score_adj); 1019a63d83f4SDavid Rientjes if (err) 1020723548bfSDavid Rientjes goto out; 1021a63d83f4SDavid Rientjes if (oom_score_adj < OOM_SCORE_ADJ_MIN || 1022723548bfSDavid Rientjes oom_score_adj > OOM_SCORE_ADJ_MAX) { 1023723548bfSDavid Rientjes err = -EINVAL; 1024723548bfSDavid Rientjes goto out; 1025723548bfSDavid Rientjes } 1026a63d83f4SDavid Rientjes 1027496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1028723548bfSDavid Rientjes if (!task) { 1029723548bfSDavid Rientjes err = -ESRCH; 1030723548bfSDavid Rientjes goto out; 1031723548bfSDavid Rientjes } 1032a63d83f4SDavid Rientjes 10333d5992d2SYing Han task_lock(task); 10343d5992d2SYing Han if (!task->mm) { 1035723548bfSDavid Rientjes err = -EINVAL; 1036723548bfSDavid Rientjes goto err_task_lock; 10373d5992d2SYing Han } 1038d19d5476SDavid Rientjes 1039d19d5476SDavid Rientjes if (!lock_task_sighand(task, &flags)) { 1040d19d5476SDavid Rientjes err = -ESRCH; 1041d19d5476SDavid Rientjes goto err_task_lock; 1042d19d5476SDavid Rientjes } 1043d19d5476SDavid Rientjes 1044a9c58b90SDavid Rientjes if ((short)oom_score_adj < task->signal->oom_score_adj_min && 1045d19d5476SDavid Rientjes !capable(CAP_SYS_RESOURCE)) { 1046d19d5476SDavid Rientjes err = -EACCES; 1047d19d5476SDavid Rientjes goto err_sighand; 1048d19d5476SDavid Rientjes } 1049d19d5476SDavid Rientjes 1050a9c58b90SDavid Rientjes task->signal->oom_score_adj = (short)oom_score_adj; 1051dabb16f6SMandeep Singh Baines if (has_capability_noaudit(current, CAP_SYS_RESOURCE)) 1052a9c58b90SDavid Rientjes task->signal->oom_score_adj_min = (short)oom_score_adj; 105343d2b113SKAMEZAWA Hiroyuki trace_oom_score_adj_update(task); 105401dc52ebSDavidlohr Bueso 1055723548bfSDavid Rientjes err_sighand: 1056a63d83f4SDavid Rientjes unlock_task_sighand(task, &flags); 1057d19d5476SDavid Rientjes err_task_lock: 1058d19d5476SDavid Rientjes task_unlock(task); 1059a63d83f4SDavid Rientjes put_task_struct(task); 1060723548bfSDavid Rientjes out: 1061723548bfSDavid Rientjes return err < 0 ? err : count; 1062a63d83f4SDavid Rientjes } 1063a63d83f4SDavid Rientjes 1064a63d83f4SDavid Rientjes static const struct file_operations proc_oom_score_adj_operations = { 1065a63d83f4SDavid Rientjes .read = oom_score_adj_read, 1066a63d83f4SDavid Rientjes .write = oom_score_adj_write, 10676038f373SArnd Bergmann .llseek = default_llseek, 1068a63d83f4SDavid Rientjes }; 1069a63d83f4SDavid Rientjes 10701da177e4SLinus Torvalds #ifdef CONFIG_AUDITSYSCALL 10711da177e4SLinus Torvalds #define TMPBUFLEN 21 10721da177e4SLinus Torvalds static ssize_t proc_loginuid_read(struct file * file, char __user * buf, 10731da177e4SLinus Torvalds size_t count, loff_t *ppos) 10741da177e4SLinus Torvalds { 1075496ad9aaSAl Viro struct inode * inode = file_inode(file); 107699f89551SEric W. Biederman struct task_struct *task = get_proc_task(inode); 10771da177e4SLinus Torvalds ssize_t length; 10781da177e4SLinus Torvalds char tmpbuf[TMPBUFLEN]; 10791da177e4SLinus Torvalds 108099f89551SEric W. Biederman if (!task) 108199f89551SEric W. Biederman return -ESRCH; 10821da177e4SLinus Torvalds length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 1083e1760bd5SEric W. Biederman from_kuid(file->f_cred->user_ns, 1084e1760bd5SEric W. Biederman audit_get_loginuid(task))); 108599f89551SEric W. Biederman put_task_struct(task); 10861da177e4SLinus Torvalds return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds static ssize_t proc_loginuid_write(struct file * file, const char __user * buf, 10901da177e4SLinus Torvalds size_t count, loff_t *ppos) 10911da177e4SLinus Torvalds { 1092496ad9aaSAl Viro struct inode * inode = file_inode(file); 10931da177e4SLinus Torvalds char *page, *tmp; 10941da177e4SLinus Torvalds ssize_t length; 10951da177e4SLinus Torvalds uid_t loginuid; 1096e1760bd5SEric W. Biederman kuid_t kloginuid; 10971da177e4SLinus Torvalds 10987dc52157SPaul E. McKenney rcu_read_lock(); 10997dc52157SPaul E. McKenney if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) { 11007dc52157SPaul E. McKenney rcu_read_unlock(); 11011da177e4SLinus Torvalds return -EPERM; 11027dc52157SPaul E. McKenney } 11037dc52157SPaul E. McKenney rcu_read_unlock(); 11041da177e4SLinus Torvalds 1105e0182909SAl Viro if (count >= PAGE_SIZE) 1106e0182909SAl Viro count = PAGE_SIZE - 1; 11071da177e4SLinus Torvalds 11081da177e4SLinus Torvalds if (*ppos != 0) { 11091da177e4SLinus Torvalds /* No partial writes. */ 11101da177e4SLinus Torvalds return -EINVAL; 11111da177e4SLinus Torvalds } 1112e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 11131da177e4SLinus Torvalds if (!page) 11141da177e4SLinus Torvalds return -ENOMEM; 11151da177e4SLinus Torvalds length = -EFAULT; 11161da177e4SLinus Torvalds if (copy_from_user(page, buf, count)) 11171da177e4SLinus Torvalds goto out_free_page; 11181da177e4SLinus Torvalds 1119e0182909SAl Viro page[count] = '\0'; 11201da177e4SLinus Torvalds loginuid = simple_strtoul(page, &tmp, 10); 11211da177e4SLinus Torvalds if (tmp == page) { 11221da177e4SLinus Torvalds length = -EINVAL; 11231da177e4SLinus Torvalds goto out_free_page; 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds } 112681407c84SEric Paris 112781407c84SEric Paris /* is userspace tring to explicitly UNSET the loginuid? */ 112881407c84SEric Paris if (loginuid == AUDIT_UID_UNSET) { 112981407c84SEric Paris kloginuid = INVALID_UID; 113081407c84SEric Paris } else { 1131e1760bd5SEric W. Biederman kloginuid = make_kuid(file->f_cred->user_ns, loginuid); 1132e1760bd5SEric W. Biederman if (!uid_valid(kloginuid)) { 1133e1760bd5SEric W. Biederman length = -EINVAL; 1134e1760bd5SEric W. Biederman goto out_free_page; 1135e1760bd5SEric W. Biederman } 113681407c84SEric Paris } 1137e1760bd5SEric W. Biederman 1138e1760bd5SEric W. Biederman length = audit_set_loginuid(kloginuid); 11391da177e4SLinus Torvalds if (likely(length == 0)) 11401da177e4SLinus Torvalds length = count; 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds out_free_page: 11431da177e4SLinus Torvalds free_page((unsigned long) page); 11441da177e4SLinus Torvalds return length; 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds 114700977a59SArjan van de Ven static const struct file_operations proc_loginuid_operations = { 11481da177e4SLinus Torvalds .read = proc_loginuid_read, 11491da177e4SLinus Torvalds .write = proc_loginuid_write, 115087df8424SArnd Bergmann .llseek = generic_file_llseek, 11511da177e4SLinus Torvalds }; 11521e0bd755SEric Paris 11531e0bd755SEric Paris static ssize_t proc_sessionid_read(struct file * file, char __user * buf, 11541e0bd755SEric Paris size_t count, loff_t *ppos) 11551e0bd755SEric Paris { 1156496ad9aaSAl Viro struct inode * inode = file_inode(file); 11571e0bd755SEric Paris struct task_struct *task = get_proc_task(inode); 11581e0bd755SEric Paris ssize_t length; 11591e0bd755SEric Paris char tmpbuf[TMPBUFLEN]; 11601e0bd755SEric Paris 11611e0bd755SEric Paris if (!task) 11621e0bd755SEric Paris return -ESRCH; 11631e0bd755SEric Paris length = scnprintf(tmpbuf, TMPBUFLEN, "%u", 11641e0bd755SEric Paris audit_get_sessionid(task)); 11651e0bd755SEric Paris put_task_struct(task); 11661e0bd755SEric Paris return simple_read_from_buffer(buf, count, ppos, tmpbuf, length); 11671e0bd755SEric Paris } 11681e0bd755SEric Paris 11691e0bd755SEric Paris static const struct file_operations proc_sessionid_operations = { 11701e0bd755SEric Paris .read = proc_sessionid_read, 117187df8424SArnd Bergmann .llseek = generic_file_llseek, 11721e0bd755SEric Paris }; 11731da177e4SLinus Torvalds #endif 11741da177e4SLinus Torvalds 1175f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1176f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_read(struct file * file, char __user * buf, 1177f4f154fdSAkinobu Mita size_t count, loff_t *ppos) 1178f4f154fdSAkinobu Mita { 1179496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 1180f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF]; 1181f4f154fdSAkinobu Mita size_t len; 1182f4f154fdSAkinobu Mita int make_it_fail; 1183f4f154fdSAkinobu Mita 1184f4f154fdSAkinobu Mita if (!task) 1185f4f154fdSAkinobu Mita return -ESRCH; 1186f4f154fdSAkinobu Mita make_it_fail = task->make_it_fail; 1187f4f154fdSAkinobu Mita put_task_struct(task); 1188f4f154fdSAkinobu Mita 1189f4f154fdSAkinobu Mita len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail); 11900c28f287SAkinobu Mita 11910c28f287SAkinobu Mita return simple_read_from_buffer(buf, count, ppos, buffer, len); 1192f4f154fdSAkinobu Mita } 1193f4f154fdSAkinobu Mita 1194f4f154fdSAkinobu Mita static ssize_t proc_fault_inject_write(struct file * file, 1195f4f154fdSAkinobu Mita const char __user * buf, size_t count, loff_t *ppos) 1196f4f154fdSAkinobu Mita { 1197f4f154fdSAkinobu Mita struct task_struct *task; 1198f4f154fdSAkinobu Mita char buffer[PROC_NUMBUF], *end; 1199f4f154fdSAkinobu Mita int make_it_fail; 1200f4f154fdSAkinobu Mita 1201f4f154fdSAkinobu Mita if (!capable(CAP_SYS_RESOURCE)) 1202f4f154fdSAkinobu Mita return -EPERM; 1203f4f154fdSAkinobu Mita memset(buffer, 0, sizeof(buffer)); 1204f4f154fdSAkinobu Mita if (count > sizeof(buffer) - 1) 1205f4f154fdSAkinobu Mita count = sizeof(buffer) - 1; 1206f4f154fdSAkinobu Mita if (copy_from_user(buffer, buf, count)) 1207f4f154fdSAkinobu Mita return -EFAULT; 1208cba8aafeSVincent Li make_it_fail = simple_strtol(strstrip(buffer), &end, 0); 1209cba8aafeSVincent Li if (*end) 1210cba8aafeSVincent Li return -EINVAL; 121116caed31SDave Jones if (make_it_fail < 0 || make_it_fail > 1) 121216caed31SDave Jones return -EINVAL; 121316caed31SDave Jones 1214496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 1215f4f154fdSAkinobu Mita if (!task) 1216f4f154fdSAkinobu Mita return -ESRCH; 1217f4f154fdSAkinobu Mita task->make_it_fail = make_it_fail; 1218f4f154fdSAkinobu Mita put_task_struct(task); 1219cba8aafeSVincent Li 1220cba8aafeSVincent Li return count; 1221f4f154fdSAkinobu Mita } 1222f4f154fdSAkinobu Mita 122300977a59SArjan van de Ven static const struct file_operations proc_fault_inject_operations = { 1224f4f154fdSAkinobu Mita .read = proc_fault_inject_read, 1225f4f154fdSAkinobu Mita .write = proc_fault_inject_write, 122687df8424SArnd Bergmann .llseek = generic_file_llseek, 1227f4f154fdSAkinobu Mita }; 1228f4f154fdSAkinobu Mita #endif 1229f4f154fdSAkinobu Mita 12309745512cSArjan van de Ven 123143ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 123243ae34cbSIngo Molnar /* 123343ae34cbSIngo Molnar * Print out various scheduling related per-task fields: 123443ae34cbSIngo Molnar */ 123543ae34cbSIngo Molnar static int sched_show(struct seq_file *m, void *v) 123643ae34cbSIngo Molnar { 123743ae34cbSIngo Molnar struct inode *inode = m->private; 123843ae34cbSIngo Molnar struct task_struct *p; 123943ae34cbSIngo Molnar 124043ae34cbSIngo Molnar p = get_proc_task(inode); 124143ae34cbSIngo Molnar if (!p) 124243ae34cbSIngo Molnar return -ESRCH; 124343ae34cbSIngo Molnar proc_sched_show_task(p, m); 124443ae34cbSIngo Molnar 124543ae34cbSIngo Molnar put_task_struct(p); 124643ae34cbSIngo Molnar 124743ae34cbSIngo Molnar return 0; 124843ae34cbSIngo Molnar } 124943ae34cbSIngo Molnar 125043ae34cbSIngo Molnar static ssize_t 125143ae34cbSIngo Molnar sched_write(struct file *file, const char __user *buf, 125243ae34cbSIngo Molnar size_t count, loff_t *offset) 125343ae34cbSIngo Molnar { 1254496ad9aaSAl Viro struct inode *inode = file_inode(file); 125543ae34cbSIngo Molnar struct task_struct *p; 125643ae34cbSIngo Molnar 125743ae34cbSIngo Molnar p = get_proc_task(inode); 125843ae34cbSIngo Molnar if (!p) 125943ae34cbSIngo Molnar return -ESRCH; 126043ae34cbSIngo Molnar proc_sched_set_task(p); 126143ae34cbSIngo Molnar 126243ae34cbSIngo Molnar put_task_struct(p); 126343ae34cbSIngo Molnar 126443ae34cbSIngo Molnar return count; 126543ae34cbSIngo Molnar } 126643ae34cbSIngo Molnar 126743ae34cbSIngo Molnar static int sched_open(struct inode *inode, struct file *filp) 126843ae34cbSIngo Molnar { 1269c6a34058SJovi Zhang return single_open(filp, sched_show, inode); 127043ae34cbSIngo Molnar } 127143ae34cbSIngo Molnar 127243ae34cbSIngo Molnar static const struct file_operations proc_pid_sched_operations = { 127343ae34cbSIngo Molnar .open = sched_open, 127443ae34cbSIngo Molnar .read = seq_read, 127543ae34cbSIngo Molnar .write = sched_write, 127643ae34cbSIngo Molnar .llseek = seq_lseek, 12775ea473a1SAlexey Dobriyan .release = single_release, 127843ae34cbSIngo Molnar }; 127943ae34cbSIngo Molnar 128043ae34cbSIngo Molnar #endif 128143ae34cbSIngo Molnar 12825091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 12835091faa4SMike Galbraith /* 12845091faa4SMike Galbraith * Print out autogroup related information: 12855091faa4SMike Galbraith */ 12865091faa4SMike Galbraith static int sched_autogroup_show(struct seq_file *m, void *v) 12875091faa4SMike Galbraith { 12885091faa4SMike Galbraith struct inode *inode = m->private; 12895091faa4SMike Galbraith struct task_struct *p; 12905091faa4SMike Galbraith 12915091faa4SMike Galbraith p = get_proc_task(inode); 12925091faa4SMike Galbraith if (!p) 12935091faa4SMike Galbraith return -ESRCH; 12945091faa4SMike Galbraith proc_sched_autogroup_show_task(p, m); 12955091faa4SMike Galbraith 12965091faa4SMike Galbraith put_task_struct(p); 12975091faa4SMike Galbraith 12985091faa4SMike Galbraith return 0; 12995091faa4SMike Galbraith } 13005091faa4SMike Galbraith 13015091faa4SMike Galbraith static ssize_t 13025091faa4SMike Galbraith sched_autogroup_write(struct file *file, const char __user *buf, 13035091faa4SMike Galbraith size_t count, loff_t *offset) 13045091faa4SMike Galbraith { 1305496ad9aaSAl Viro struct inode *inode = file_inode(file); 13065091faa4SMike Galbraith struct task_struct *p; 13075091faa4SMike Galbraith char buffer[PROC_NUMBUF]; 13080a8cb8e3SAlexey Dobriyan int nice; 13095091faa4SMike Galbraith int err; 13105091faa4SMike Galbraith 13115091faa4SMike Galbraith memset(buffer, 0, sizeof(buffer)); 13125091faa4SMike Galbraith if (count > sizeof(buffer) - 1) 13135091faa4SMike Galbraith count = sizeof(buffer) - 1; 13145091faa4SMike Galbraith if (copy_from_user(buffer, buf, count)) 13155091faa4SMike Galbraith return -EFAULT; 13165091faa4SMike Galbraith 13170a8cb8e3SAlexey Dobriyan err = kstrtoint(strstrip(buffer), 0, &nice); 13180a8cb8e3SAlexey Dobriyan if (err < 0) 13190a8cb8e3SAlexey Dobriyan return err; 13205091faa4SMike Galbraith 13215091faa4SMike Galbraith p = get_proc_task(inode); 13225091faa4SMike Galbraith if (!p) 13235091faa4SMike Galbraith return -ESRCH; 13245091faa4SMike Galbraith 13252e5b5b3aSHiroshi Shimamoto err = proc_sched_autogroup_set_nice(p, nice); 13265091faa4SMike Galbraith if (err) 13275091faa4SMike Galbraith count = err; 13285091faa4SMike Galbraith 13295091faa4SMike Galbraith put_task_struct(p); 13305091faa4SMike Galbraith 13315091faa4SMike Galbraith return count; 13325091faa4SMike Galbraith } 13335091faa4SMike Galbraith 13345091faa4SMike Galbraith static int sched_autogroup_open(struct inode *inode, struct file *filp) 13355091faa4SMike Galbraith { 13365091faa4SMike Galbraith int ret; 13375091faa4SMike Galbraith 13385091faa4SMike Galbraith ret = single_open(filp, sched_autogroup_show, NULL); 13395091faa4SMike Galbraith if (!ret) { 13405091faa4SMike Galbraith struct seq_file *m = filp->private_data; 13415091faa4SMike Galbraith 13425091faa4SMike Galbraith m->private = inode; 13435091faa4SMike Galbraith } 13445091faa4SMike Galbraith return ret; 13455091faa4SMike Galbraith } 13465091faa4SMike Galbraith 13475091faa4SMike Galbraith static const struct file_operations proc_pid_sched_autogroup_operations = { 13485091faa4SMike Galbraith .open = sched_autogroup_open, 13495091faa4SMike Galbraith .read = seq_read, 13505091faa4SMike Galbraith .write = sched_autogroup_write, 13515091faa4SMike Galbraith .llseek = seq_lseek, 13525091faa4SMike Galbraith .release = single_release, 13535091faa4SMike Galbraith }; 13545091faa4SMike Galbraith 13555091faa4SMike Galbraith #endif /* CONFIG_SCHED_AUTOGROUP */ 13565091faa4SMike Galbraith 13574614a696Sjohn stultz static ssize_t comm_write(struct file *file, const char __user *buf, 13584614a696Sjohn stultz size_t count, loff_t *offset) 13594614a696Sjohn stultz { 1360496ad9aaSAl Viro struct inode *inode = file_inode(file); 13614614a696Sjohn stultz struct task_struct *p; 13624614a696Sjohn stultz char buffer[TASK_COMM_LEN]; 1363830e0fc9SDavid Rientjes const size_t maxlen = sizeof(buffer) - 1; 13644614a696Sjohn stultz 13654614a696Sjohn stultz memset(buffer, 0, sizeof(buffer)); 1366830e0fc9SDavid Rientjes if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count)) 13674614a696Sjohn stultz return -EFAULT; 13684614a696Sjohn stultz 13694614a696Sjohn stultz p = get_proc_task(inode); 13704614a696Sjohn stultz if (!p) 13714614a696Sjohn stultz return -ESRCH; 13724614a696Sjohn stultz 13734614a696Sjohn stultz if (same_thread_group(current, p)) 13744614a696Sjohn stultz set_task_comm(p, buffer); 13754614a696Sjohn stultz else 13764614a696Sjohn stultz count = -EINVAL; 13774614a696Sjohn stultz 13784614a696Sjohn stultz put_task_struct(p); 13794614a696Sjohn stultz 13804614a696Sjohn stultz return count; 13814614a696Sjohn stultz } 13824614a696Sjohn stultz 13834614a696Sjohn stultz static int comm_show(struct seq_file *m, void *v) 13844614a696Sjohn stultz { 13854614a696Sjohn stultz struct inode *inode = m->private; 13864614a696Sjohn stultz struct task_struct *p; 13874614a696Sjohn stultz 13884614a696Sjohn stultz p = get_proc_task(inode); 13894614a696Sjohn stultz if (!p) 13904614a696Sjohn stultz return -ESRCH; 13914614a696Sjohn stultz 13924614a696Sjohn stultz task_lock(p); 13934614a696Sjohn stultz seq_printf(m, "%s\n", p->comm); 13944614a696Sjohn stultz task_unlock(p); 13954614a696Sjohn stultz 13964614a696Sjohn stultz put_task_struct(p); 13974614a696Sjohn stultz 13984614a696Sjohn stultz return 0; 13994614a696Sjohn stultz } 14004614a696Sjohn stultz 14014614a696Sjohn stultz static int comm_open(struct inode *inode, struct file *filp) 14024614a696Sjohn stultz { 1403c6a34058SJovi Zhang return single_open(filp, comm_show, inode); 14044614a696Sjohn stultz } 14054614a696Sjohn stultz 14064614a696Sjohn stultz static const struct file_operations proc_pid_set_comm_operations = { 14074614a696Sjohn stultz .open = comm_open, 14084614a696Sjohn stultz .read = seq_read, 14094614a696Sjohn stultz .write = comm_write, 14104614a696Sjohn stultz .llseek = seq_lseek, 14114614a696Sjohn stultz .release = single_release, 14124614a696Sjohn stultz }; 14134614a696Sjohn stultz 14147773fbc5SCyrill Gorcunov static int proc_exe_link(struct dentry *dentry, struct path *exe_path) 1415925d1c40SMatt Helsley { 1416925d1c40SMatt Helsley struct task_struct *task; 1417925d1c40SMatt Helsley struct mm_struct *mm; 1418925d1c40SMatt Helsley struct file *exe_file; 1419925d1c40SMatt Helsley 14207773fbc5SCyrill Gorcunov task = get_proc_task(dentry->d_inode); 1421925d1c40SMatt Helsley if (!task) 1422925d1c40SMatt Helsley return -ENOENT; 1423925d1c40SMatt Helsley mm = get_task_mm(task); 1424925d1c40SMatt Helsley put_task_struct(task); 1425925d1c40SMatt Helsley if (!mm) 1426925d1c40SMatt Helsley return -ENOENT; 1427925d1c40SMatt Helsley exe_file = get_mm_exe_file(mm); 1428925d1c40SMatt Helsley mmput(mm); 1429925d1c40SMatt Helsley if (exe_file) { 1430925d1c40SMatt Helsley *exe_path = exe_file->f_path; 1431925d1c40SMatt Helsley path_get(&exe_file->f_path); 1432925d1c40SMatt Helsley fput(exe_file); 1433925d1c40SMatt Helsley return 0; 1434925d1c40SMatt Helsley } else 1435925d1c40SMatt Helsley return -ENOENT; 1436925d1c40SMatt Helsley } 1437925d1c40SMatt Helsley 1438008b150aSAl Viro static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) 14391da177e4SLinus Torvalds { 14401da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 1441408ef013SChristoph Hellwig struct path path; 14421da177e4SLinus Torvalds int error = -EACCES; 14431da177e4SLinus Torvalds 1444778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1445778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 14461da177e4SLinus Torvalds goto out; 14471da177e4SLinus Torvalds 1448408ef013SChristoph Hellwig error = PROC_I(inode)->op.proc_get_link(dentry, &path); 1449408ef013SChristoph Hellwig if (error) 1450408ef013SChristoph Hellwig goto out; 1451408ef013SChristoph Hellwig 1452b5fb63c1SChristoph Hellwig nd_jump_link(nd, &path); 1453408ef013SChristoph Hellwig return NULL; 14541da177e4SLinus Torvalds out: 1455008b150aSAl Viro return ERR_PTR(error); 14561da177e4SLinus Torvalds } 14571da177e4SLinus Torvalds 14583dcd25f3SJan Blunck static int do_proc_readlink(struct path *path, char __user *buffer, int buflen) 14591da177e4SLinus Torvalds { 1460e12ba74dSMel Gorman char *tmp = (char*)__get_free_page(GFP_TEMPORARY); 14613dcd25f3SJan Blunck char *pathname; 14621da177e4SLinus Torvalds int len; 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds if (!tmp) 14651da177e4SLinus Torvalds return -ENOMEM; 14661da177e4SLinus Torvalds 14677b2a69baSEric W. Biederman pathname = d_path(path, tmp, PAGE_SIZE); 14683dcd25f3SJan Blunck len = PTR_ERR(pathname); 14693dcd25f3SJan Blunck if (IS_ERR(pathname)) 14701da177e4SLinus Torvalds goto out; 14713dcd25f3SJan Blunck len = tmp + PAGE_SIZE - 1 - pathname; 14721da177e4SLinus Torvalds 14731da177e4SLinus Torvalds if (len > buflen) 14741da177e4SLinus Torvalds len = buflen; 14753dcd25f3SJan Blunck if (copy_to_user(buffer, pathname, len)) 14761da177e4SLinus Torvalds len = -EFAULT; 14771da177e4SLinus Torvalds out: 14781da177e4SLinus Torvalds free_page((unsigned long)tmp); 14791da177e4SLinus Torvalds return len; 14801da177e4SLinus Torvalds } 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 14831da177e4SLinus Torvalds { 14841da177e4SLinus Torvalds int error = -EACCES; 14851da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 14863dcd25f3SJan Blunck struct path path; 14871da177e4SLinus Torvalds 1488778c1144SEric W. Biederman /* Are we allowed to snoop on the tasks file descriptors? */ 1489778c1144SEric W. Biederman if (!proc_fd_access_allowed(inode)) 14901da177e4SLinus Torvalds goto out; 14911da177e4SLinus Torvalds 14927773fbc5SCyrill Gorcunov error = PROC_I(inode)->op.proc_get_link(dentry, &path); 14931da177e4SLinus Torvalds if (error) 14941da177e4SLinus Torvalds goto out; 14951da177e4SLinus Torvalds 14963dcd25f3SJan Blunck error = do_proc_readlink(&path, buffer, buflen); 14973dcd25f3SJan Blunck path_put(&path); 14981da177e4SLinus Torvalds out: 14991da177e4SLinus Torvalds return error; 15001da177e4SLinus Torvalds } 15011da177e4SLinus Torvalds 1502faf60af1SCyrill Gorcunov const struct inode_operations proc_pid_link_inode_operations = { 15031da177e4SLinus Torvalds .readlink = proc_pid_readlink, 15046d76fa58SLinus Torvalds .follow_link = proc_pid_follow_link, 15056d76fa58SLinus Torvalds .setattr = proc_setattr, 15061da177e4SLinus Torvalds }; 15071da177e4SLinus Torvalds 150828a6d671SEric W. Biederman 150928a6d671SEric W. Biederman /* building an inode */ 151028a6d671SEric W. Biederman 15116b4e306aSEric W. Biederman struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task) 151228a6d671SEric W. Biederman { 151328a6d671SEric W. Biederman struct inode * inode; 151428a6d671SEric W. Biederman struct proc_inode *ei; 1515c69e8d9cSDavid Howells const struct cred *cred; 151628a6d671SEric W. Biederman 151728a6d671SEric W. Biederman /* We need a new inode */ 151828a6d671SEric W. Biederman 151928a6d671SEric W. Biederman inode = new_inode(sb); 152028a6d671SEric W. Biederman if (!inode) 152128a6d671SEric W. Biederman goto out; 152228a6d671SEric W. Biederman 152328a6d671SEric W. Biederman /* Common stuff */ 152428a6d671SEric W. Biederman ei = PROC_I(inode); 152585fe4025SChristoph Hellwig inode->i_ino = get_next_ino(); 152628a6d671SEric W. Biederman inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 152728a6d671SEric W. Biederman inode->i_op = &proc_def_inode_operations; 152828a6d671SEric W. Biederman 152928a6d671SEric W. Biederman /* 153028a6d671SEric W. Biederman * grab the reference to task. 153128a6d671SEric W. Biederman */ 15321a657f78SOleg Nesterov ei->pid = get_task_pid(task, PIDTYPE_PID); 153328a6d671SEric W. Biederman if (!ei->pid) 153428a6d671SEric W. Biederman goto out_unlock; 153528a6d671SEric W. Biederman 153628a6d671SEric W. Biederman if (task_dumpable(task)) { 1537c69e8d9cSDavid Howells rcu_read_lock(); 1538c69e8d9cSDavid Howells cred = __task_cred(task); 1539c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1540c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1541c69e8d9cSDavid Howells rcu_read_unlock(); 154228a6d671SEric W. Biederman } 154328a6d671SEric W. Biederman security_task_to_inode(task, inode); 154428a6d671SEric W. Biederman 154528a6d671SEric W. Biederman out: 154628a6d671SEric W. Biederman return inode; 154728a6d671SEric W. Biederman 154828a6d671SEric W. Biederman out_unlock: 154928a6d671SEric W. Biederman iput(inode); 155028a6d671SEric W. Biederman return NULL; 155128a6d671SEric W. Biederman } 155228a6d671SEric W. Biederman 15536b4e306aSEric W. Biederman int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 155428a6d671SEric W. Biederman { 155528a6d671SEric W. Biederman struct inode *inode = dentry->d_inode; 155628a6d671SEric W. Biederman struct task_struct *task; 1557c69e8d9cSDavid Howells const struct cred *cred; 15580499680aSVasiliy Kulikov struct pid_namespace *pid = dentry->d_sb->s_fs_info; 1559c69e8d9cSDavid Howells 156028a6d671SEric W. Biederman generic_fillattr(inode, stat); 156128a6d671SEric W. Biederman 156228a6d671SEric W. Biederman rcu_read_lock(); 1563dcb0f222SEric W. Biederman stat->uid = GLOBAL_ROOT_UID; 1564dcb0f222SEric W. Biederman stat->gid = GLOBAL_ROOT_GID; 156528a6d671SEric W. Biederman task = pid_task(proc_pid(inode), PIDTYPE_PID); 156628a6d671SEric W. Biederman if (task) { 15670499680aSVasiliy Kulikov if (!has_pid_permissions(pid, task, 2)) { 15680499680aSVasiliy Kulikov rcu_read_unlock(); 15690499680aSVasiliy Kulikov /* 15700499680aSVasiliy Kulikov * This doesn't prevent learning whether PID exists, 15710499680aSVasiliy Kulikov * it only makes getattr() consistent with readdir(). 15720499680aSVasiliy Kulikov */ 15730499680aSVasiliy Kulikov return -ENOENT; 15740499680aSVasiliy Kulikov } 157528a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 157628a6d671SEric W. Biederman task_dumpable(task)) { 1577c69e8d9cSDavid Howells cred = __task_cred(task); 1578c69e8d9cSDavid Howells stat->uid = cred->euid; 1579c69e8d9cSDavid Howells stat->gid = cred->egid; 158028a6d671SEric W. Biederman } 158128a6d671SEric W. Biederman } 158228a6d671SEric W. Biederman rcu_read_unlock(); 158328a6d671SEric W. Biederman return 0; 158428a6d671SEric W. Biederman } 158528a6d671SEric W. Biederman 158628a6d671SEric W. Biederman /* dentry stuff */ 158728a6d671SEric W. Biederman 158828a6d671SEric W. Biederman /* 158928a6d671SEric W. Biederman * Exceptional case: normally we are not allowed to unhash a busy 159028a6d671SEric W. Biederman * directory. In this case, however, we can do it - no aliasing problems 159128a6d671SEric W. Biederman * due to the way we treat inodes. 159228a6d671SEric W. Biederman * 159328a6d671SEric W. Biederman * Rewrite the inode's ownerships here because the owning task may have 159428a6d671SEric W. Biederman * performed a setuid(), etc. 159528a6d671SEric W. Biederman * 159628a6d671SEric W. Biederman * Before the /proc/pid/status file was created the only way to read 159728a6d671SEric W. Biederman * the effective uid of a /process was to stat /proc/pid. Reading 159828a6d671SEric W. Biederman * /proc/pid/status is slow enough that procps and other packages 159928a6d671SEric W. Biederman * kept stating /proc/pid. To keep the rules in /proc simple I have 160028a6d671SEric W. Biederman * made this apply to all per process world readable and executable 160128a6d671SEric W. Biederman * directories. 160228a6d671SEric W. Biederman */ 16030b728e19SAl Viro int pid_revalidate(struct dentry *dentry, unsigned int flags) 160428a6d671SEric W. Biederman { 160534286d66SNick Piggin struct inode *inode; 160634286d66SNick Piggin struct task_struct *task; 1607c69e8d9cSDavid Howells const struct cred *cred; 1608c69e8d9cSDavid Howells 16090b728e19SAl Viro if (flags & LOOKUP_RCU) 161034286d66SNick Piggin return -ECHILD; 161134286d66SNick Piggin 161234286d66SNick Piggin inode = dentry->d_inode; 161334286d66SNick Piggin task = get_proc_task(inode); 161434286d66SNick Piggin 161528a6d671SEric W. Biederman if (task) { 161628a6d671SEric W. Biederman if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) || 161728a6d671SEric W. Biederman task_dumpable(task)) { 1618c69e8d9cSDavid Howells rcu_read_lock(); 1619c69e8d9cSDavid Howells cred = __task_cred(task); 1620c69e8d9cSDavid Howells inode->i_uid = cred->euid; 1621c69e8d9cSDavid Howells inode->i_gid = cred->egid; 1622c69e8d9cSDavid Howells rcu_read_unlock(); 162328a6d671SEric W. Biederman } else { 1624dcb0f222SEric W. Biederman inode->i_uid = GLOBAL_ROOT_UID; 1625dcb0f222SEric W. Biederman inode->i_gid = GLOBAL_ROOT_GID; 162628a6d671SEric W. Biederman } 162728a6d671SEric W. Biederman inode->i_mode &= ~(S_ISUID | S_ISGID); 162828a6d671SEric W. Biederman security_task_to_inode(task, inode); 162928a6d671SEric W. Biederman put_task_struct(task); 163028a6d671SEric W. Biederman return 1; 163128a6d671SEric W. Biederman } 163228a6d671SEric W. Biederman d_drop(dentry); 163328a6d671SEric W. Biederman return 0; 163428a6d671SEric W. Biederman } 163528a6d671SEric W. Biederman 1636d855a4b7SOleg Nesterov static inline bool proc_inode_is_dead(struct inode *inode) 1637d855a4b7SOleg Nesterov { 1638d855a4b7SOleg Nesterov return !proc_pid(inode)->tasks[PIDTYPE_PID].first; 1639d855a4b7SOleg Nesterov } 1640d855a4b7SOleg Nesterov 16411dd704b6SDavid Howells int pid_delete_dentry(const struct dentry *dentry) 16421dd704b6SDavid Howells { 16431dd704b6SDavid Howells /* Is the task we represent dead? 16441dd704b6SDavid Howells * If so, then don't put the dentry on the lru list, 16451dd704b6SDavid Howells * kill it immediately. 16461dd704b6SDavid Howells */ 1647d855a4b7SOleg Nesterov return proc_inode_is_dead(dentry->d_inode); 16481dd704b6SDavid Howells } 16491dd704b6SDavid Howells 16506b4e306aSEric W. Biederman const struct dentry_operations pid_dentry_operations = 165128a6d671SEric W. Biederman { 165228a6d671SEric W. Biederman .d_revalidate = pid_revalidate, 165328a6d671SEric W. Biederman .d_delete = pid_delete_dentry, 165428a6d671SEric W. Biederman }; 165528a6d671SEric W. Biederman 165628a6d671SEric W. Biederman /* Lookups */ 165728a6d671SEric W. Biederman 16581c0d04c9SEric W. Biederman /* 16591c0d04c9SEric W. Biederman * Fill a directory entry. 16601c0d04c9SEric W. Biederman * 16611c0d04c9SEric W. Biederman * If possible create the dcache entry and derive our inode number and 16621c0d04c9SEric W. Biederman * file type from dcache entry. 16631c0d04c9SEric W. Biederman * 16641c0d04c9SEric W. Biederman * Since all of the proc inode numbers are dynamically generated, the inode 16651c0d04c9SEric W. Biederman * numbers do not exist until the inode is cache. This means creating the 16661c0d04c9SEric W. Biederman * the dcache entry in readdir is necessary to keep the inode numbers 16671c0d04c9SEric W. Biederman * reported by readdir in sync with the inode numbers reported 16681c0d04c9SEric W. Biederman * by stat. 16691c0d04c9SEric W. Biederman */ 1670f0c3b509SAl Viro bool proc_fill_cache(struct file *file, struct dir_context *ctx, 16716b4e306aSEric W. Biederman const char *name, int len, 1672c5141e6dSEric Dumazet instantiate_t instantiate, struct task_struct *task, const void *ptr) 167361a28784SEric W. Biederman { 1674f0c3b509SAl Viro struct dentry *child, *dir = file->f_path.dentry; 16751df98b8bSAl Viro struct qstr qname = QSTR_INIT(name, len); 167661a28784SEric W. Biederman struct inode *inode; 16771df98b8bSAl Viro unsigned type; 16781df98b8bSAl Viro ino_t ino; 167961a28784SEric W. Biederman 16801df98b8bSAl Viro child = d_hash_and_lookup(dir, &qname); 168161a28784SEric W. Biederman if (!child) { 16821df98b8bSAl Viro child = d_alloc(dir, &qname); 16831df98b8bSAl Viro if (!child) 168461a28784SEric W. Biederman goto end_instantiate; 16851df98b8bSAl Viro if (instantiate(dir->d_inode, child, task, ptr) < 0) { 16861df98b8bSAl Viro dput(child); 16871df98b8bSAl Viro goto end_instantiate; 16881df98b8bSAl Viro } 16891df98b8bSAl Viro } 169061a28784SEric W. Biederman inode = child->d_inode; 169161a28784SEric W. Biederman ino = inode->i_ino; 169261a28784SEric W. Biederman type = inode->i_mode >> 12; 169361a28784SEric W. Biederman dput(child); 1694f0c3b509SAl Viro return dir_emit(ctx, name, len, ino, type); 16951df98b8bSAl Viro 16961df98b8bSAl Viro end_instantiate: 16971df98b8bSAl Viro return dir_emit(ctx, name, len, 1, DT_UNKNOWN); 169861a28784SEric W. Biederman } 169961a28784SEric W. Biederman 1700640708a2SPavel Emelyanov #ifdef CONFIG_CHECKPOINT_RESTORE 1701640708a2SPavel Emelyanov 1702640708a2SPavel Emelyanov /* 1703640708a2SPavel Emelyanov * dname_to_vma_addr - maps a dentry name into two unsigned longs 1704640708a2SPavel Emelyanov * which represent vma start and end addresses. 1705640708a2SPavel Emelyanov */ 1706640708a2SPavel Emelyanov static int dname_to_vma_addr(struct dentry *dentry, 1707640708a2SPavel Emelyanov unsigned long *start, unsigned long *end) 1708640708a2SPavel Emelyanov { 1709640708a2SPavel Emelyanov if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2) 1710640708a2SPavel Emelyanov return -EINVAL; 1711640708a2SPavel Emelyanov 1712640708a2SPavel Emelyanov return 0; 1713640708a2SPavel Emelyanov } 1714640708a2SPavel Emelyanov 17150b728e19SAl Viro static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags) 1716640708a2SPavel Emelyanov { 1717640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1718640708a2SPavel Emelyanov bool exact_vma_exists = false; 1719640708a2SPavel Emelyanov struct mm_struct *mm = NULL; 1720640708a2SPavel Emelyanov struct task_struct *task; 1721640708a2SPavel Emelyanov const struct cred *cred; 1722640708a2SPavel Emelyanov struct inode *inode; 1723640708a2SPavel Emelyanov int status = 0; 1724640708a2SPavel Emelyanov 17250b728e19SAl Viro if (flags & LOOKUP_RCU) 1726640708a2SPavel Emelyanov return -ECHILD; 1727640708a2SPavel Emelyanov 1728640708a2SPavel Emelyanov if (!capable(CAP_SYS_ADMIN)) { 172941735818SZhao Hongjiang status = -EPERM; 1730640708a2SPavel Emelyanov goto out_notask; 1731640708a2SPavel Emelyanov } 1732640708a2SPavel Emelyanov 1733640708a2SPavel Emelyanov inode = dentry->d_inode; 1734640708a2SPavel Emelyanov task = get_proc_task(inode); 1735640708a2SPavel Emelyanov if (!task) 1736640708a2SPavel Emelyanov goto out_notask; 1737640708a2SPavel Emelyanov 17382344bec7SCong Wang mm = mm_access(task, PTRACE_MODE_READ); 17392344bec7SCong Wang if (IS_ERR_OR_NULL(mm)) 1740640708a2SPavel Emelyanov goto out; 1741640708a2SPavel Emelyanov 1742640708a2SPavel Emelyanov if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) { 1743640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1744640708a2SPavel Emelyanov exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end); 1745640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1746640708a2SPavel Emelyanov } 1747640708a2SPavel Emelyanov 1748640708a2SPavel Emelyanov mmput(mm); 1749640708a2SPavel Emelyanov 1750640708a2SPavel Emelyanov if (exact_vma_exists) { 1751640708a2SPavel Emelyanov if (task_dumpable(task)) { 1752640708a2SPavel Emelyanov rcu_read_lock(); 1753640708a2SPavel Emelyanov cred = __task_cred(task); 1754640708a2SPavel Emelyanov inode->i_uid = cred->euid; 1755640708a2SPavel Emelyanov inode->i_gid = cred->egid; 1756640708a2SPavel Emelyanov rcu_read_unlock(); 1757640708a2SPavel Emelyanov } else { 1758dcb0f222SEric W. Biederman inode->i_uid = GLOBAL_ROOT_UID; 1759dcb0f222SEric W. Biederman inode->i_gid = GLOBAL_ROOT_GID; 1760640708a2SPavel Emelyanov } 1761640708a2SPavel Emelyanov security_task_to_inode(task, inode); 1762640708a2SPavel Emelyanov status = 1; 1763640708a2SPavel Emelyanov } 1764640708a2SPavel Emelyanov 1765640708a2SPavel Emelyanov out: 1766640708a2SPavel Emelyanov put_task_struct(task); 1767640708a2SPavel Emelyanov 1768640708a2SPavel Emelyanov out_notask: 1769640708a2SPavel Emelyanov if (status <= 0) 1770640708a2SPavel Emelyanov d_drop(dentry); 1771640708a2SPavel Emelyanov 1772640708a2SPavel Emelyanov return status; 1773640708a2SPavel Emelyanov } 1774640708a2SPavel Emelyanov 1775640708a2SPavel Emelyanov static const struct dentry_operations tid_map_files_dentry_operations = { 1776640708a2SPavel Emelyanov .d_revalidate = map_files_d_revalidate, 1777640708a2SPavel Emelyanov .d_delete = pid_delete_dentry, 1778640708a2SPavel Emelyanov }; 1779640708a2SPavel Emelyanov 1780640708a2SPavel Emelyanov static int proc_map_files_get_link(struct dentry *dentry, struct path *path) 1781640708a2SPavel Emelyanov { 1782640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1783640708a2SPavel Emelyanov struct vm_area_struct *vma; 1784640708a2SPavel Emelyanov struct task_struct *task; 1785640708a2SPavel Emelyanov struct mm_struct *mm; 1786640708a2SPavel Emelyanov int rc; 1787640708a2SPavel Emelyanov 1788640708a2SPavel Emelyanov rc = -ENOENT; 1789640708a2SPavel Emelyanov task = get_proc_task(dentry->d_inode); 1790640708a2SPavel Emelyanov if (!task) 1791640708a2SPavel Emelyanov goto out; 1792640708a2SPavel Emelyanov 1793640708a2SPavel Emelyanov mm = get_task_mm(task); 1794640708a2SPavel Emelyanov put_task_struct(task); 1795640708a2SPavel Emelyanov if (!mm) 1796640708a2SPavel Emelyanov goto out; 1797640708a2SPavel Emelyanov 1798640708a2SPavel Emelyanov rc = dname_to_vma_addr(dentry, &vm_start, &vm_end); 1799640708a2SPavel Emelyanov if (rc) 1800640708a2SPavel Emelyanov goto out_mmput; 1801640708a2SPavel Emelyanov 180270335abbSArtem Fetishev rc = -ENOENT; 1803640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1804640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 1805640708a2SPavel Emelyanov if (vma && vma->vm_file) { 1806640708a2SPavel Emelyanov *path = vma->vm_file->f_path; 1807640708a2SPavel Emelyanov path_get(path); 1808640708a2SPavel Emelyanov rc = 0; 1809640708a2SPavel Emelyanov } 1810640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1811640708a2SPavel Emelyanov 1812640708a2SPavel Emelyanov out_mmput: 1813640708a2SPavel Emelyanov mmput(mm); 1814640708a2SPavel Emelyanov out: 1815640708a2SPavel Emelyanov return rc; 1816640708a2SPavel Emelyanov } 1817640708a2SPavel Emelyanov 1818640708a2SPavel Emelyanov struct map_files_info { 18197b540d06SAl Viro fmode_t mode; 1820640708a2SPavel Emelyanov unsigned long len; 1821640708a2SPavel Emelyanov unsigned char name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */ 1822640708a2SPavel Emelyanov }; 1823640708a2SPavel Emelyanov 1824c52a47acSAl Viro static int 1825640708a2SPavel Emelyanov proc_map_files_instantiate(struct inode *dir, struct dentry *dentry, 1826640708a2SPavel Emelyanov struct task_struct *task, const void *ptr) 1827640708a2SPavel Emelyanov { 18287b540d06SAl Viro fmode_t mode = (fmode_t)(unsigned long)ptr; 1829640708a2SPavel Emelyanov struct proc_inode *ei; 1830640708a2SPavel Emelyanov struct inode *inode; 1831640708a2SPavel Emelyanov 1832640708a2SPavel Emelyanov inode = proc_pid_make_inode(dir->i_sb, task); 1833640708a2SPavel Emelyanov if (!inode) 1834c52a47acSAl Viro return -ENOENT; 1835640708a2SPavel Emelyanov 1836640708a2SPavel Emelyanov ei = PROC_I(inode); 1837640708a2SPavel Emelyanov ei->op.proc_get_link = proc_map_files_get_link; 1838640708a2SPavel Emelyanov 1839640708a2SPavel Emelyanov inode->i_op = &proc_pid_link_inode_operations; 1840640708a2SPavel Emelyanov inode->i_size = 64; 1841640708a2SPavel Emelyanov inode->i_mode = S_IFLNK; 1842640708a2SPavel Emelyanov 18437b540d06SAl Viro if (mode & FMODE_READ) 1844640708a2SPavel Emelyanov inode->i_mode |= S_IRUSR; 18457b540d06SAl Viro if (mode & FMODE_WRITE) 1846640708a2SPavel Emelyanov inode->i_mode |= S_IWUSR; 1847640708a2SPavel Emelyanov 1848640708a2SPavel Emelyanov d_set_d_op(dentry, &tid_map_files_dentry_operations); 1849640708a2SPavel Emelyanov d_add(dentry, inode); 1850640708a2SPavel Emelyanov 1851c52a47acSAl Viro return 0; 1852640708a2SPavel Emelyanov } 1853640708a2SPavel Emelyanov 1854640708a2SPavel Emelyanov static struct dentry *proc_map_files_lookup(struct inode *dir, 185500cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 1856640708a2SPavel Emelyanov { 1857640708a2SPavel Emelyanov unsigned long vm_start, vm_end; 1858640708a2SPavel Emelyanov struct vm_area_struct *vma; 1859640708a2SPavel Emelyanov struct task_struct *task; 1860c52a47acSAl Viro int result; 1861640708a2SPavel Emelyanov struct mm_struct *mm; 1862640708a2SPavel Emelyanov 1863c52a47acSAl Viro result = -EPERM; 1864640708a2SPavel Emelyanov if (!capable(CAP_SYS_ADMIN)) 1865640708a2SPavel Emelyanov goto out; 1866640708a2SPavel Emelyanov 1867c52a47acSAl Viro result = -ENOENT; 1868640708a2SPavel Emelyanov task = get_proc_task(dir); 1869640708a2SPavel Emelyanov if (!task) 1870640708a2SPavel Emelyanov goto out; 1871640708a2SPavel Emelyanov 1872c52a47acSAl Viro result = -EACCES; 1873eb94cd96SCyrill Gorcunov if (!ptrace_may_access(task, PTRACE_MODE_READ)) 1874640708a2SPavel Emelyanov goto out_put_task; 1875640708a2SPavel Emelyanov 1876c52a47acSAl Viro result = -ENOENT; 1877640708a2SPavel Emelyanov if (dname_to_vma_addr(dentry, &vm_start, &vm_end)) 1878eb94cd96SCyrill Gorcunov goto out_put_task; 1879640708a2SPavel Emelyanov 1880640708a2SPavel Emelyanov mm = get_task_mm(task); 1881640708a2SPavel Emelyanov if (!mm) 1882eb94cd96SCyrill Gorcunov goto out_put_task; 1883640708a2SPavel Emelyanov 1884640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1885640708a2SPavel Emelyanov vma = find_exact_vma(mm, vm_start, vm_end); 1886640708a2SPavel Emelyanov if (!vma) 1887640708a2SPavel Emelyanov goto out_no_vma; 1888640708a2SPavel Emelyanov 188905f56484SStanislav Kinsbursky if (vma->vm_file) 18907b540d06SAl Viro result = proc_map_files_instantiate(dir, dentry, task, 18917b540d06SAl Viro (void *)(unsigned long)vma->vm_file->f_mode); 1892640708a2SPavel Emelyanov 1893640708a2SPavel Emelyanov out_no_vma: 1894640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1895640708a2SPavel Emelyanov mmput(mm); 1896640708a2SPavel Emelyanov out_put_task: 1897640708a2SPavel Emelyanov put_task_struct(task); 1898640708a2SPavel Emelyanov out: 1899c52a47acSAl Viro return ERR_PTR(result); 1900640708a2SPavel Emelyanov } 1901640708a2SPavel Emelyanov 1902640708a2SPavel Emelyanov static const struct inode_operations proc_map_files_inode_operations = { 1903640708a2SPavel Emelyanov .lookup = proc_map_files_lookup, 1904640708a2SPavel Emelyanov .permission = proc_fd_permission, 1905640708a2SPavel Emelyanov .setattr = proc_setattr, 1906640708a2SPavel Emelyanov }; 1907640708a2SPavel Emelyanov 1908640708a2SPavel Emelyanov static int 1909f0c3b509SAl Viro proc_map_files_readdir(struct file *file, struct dir_context *ctx) 1910640708a2SPavel Emelyanov { 1911640708a2SPavel Emelyanov struct vm_area_struct *vma; 1912640708a2SPavel Emelyanov struct task_struct *task; 1913640708a2SPavel Emelyanov struct mm_struct *mm; 1914f0c3b509SAl Viro unsigned long nr_files, pos, i; 1915f0c3b509SAl Viro struct flex_array *fa = NULL; 1916f0c3b509SAl Viro struct map_files_info info; 1917f0c3b509SAl Viro struct map_files_info *p; 1918640708a2SPavel Emelyanov int ret; 1919640708a2SPavel Emelyanov 192041735818SZhao Hongjiang ret = -EPERM; 1921640708a2SPavel Emelyanov if (!capable(CAP_SYS_ADMIN)) 1922640708a2SPavel Emelyanov goto out; 1923640708a2SPavel Emelyanov 1924640708a2SPavel Emelyanov ret = -ENOENT; 1925f0c3b509SAl Viro task = get_proc_task(file_inode(file)); 1926640708a2SPavel Emelyanov if (!task) 1927640708a2SPavel Emelyanov goto out; 1928640708a2SPavel Emelyanov 1929640708a2SPavel Emelyanov ret = -EACCES; 1930eb94cd96SCyrill Gorcunov if (!ptrace_may_access(task, PTRACE_MODE_READ)) 1931640708a2SPavel Emelyanov goto out_put_task; 1932640708a2SPavel Emelyanov 1933640708a2SPavel Emelyanov ret = 0; 1934f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 1935eb94cd96SCyrill Gorcunov goto out_put_task; 1936640708a2SPavel Emelyanov 1937640708a2SPavel Emelyanov mm = get_task_mm(task); 1938640708a2SPavel Emelyanov if (!mm) 1939eb94cd96SCyrill Gorcunov goto out_put_task; 1940640708a2SPavel Emelyanov down_read(&mm->mmap_sem); 1941640708a2SPavel Emelyanov 1942640708a2SPavel Emelyanov nr_files = 0; 1943640708a2SPavel Emelyanov 1944640708a2SPavel Emelyanov /* 1945640708a2SPavel Emelyanov * We need two passes here: 1946640708a2SPavel Emelyanov * 1947640708a2SPavel Emelyanov * 1) Collect vmas of mapped files with mmap_sem taken 1948640708a2SPavel Emelyanov * 2) Release mmap_sem and instantiate entries 1949640708a2SPavel Emelyanov * 1950640708a2SPavel Emelyanov * otherwise we get lockdep complained, since filldir() 1951640708a2SPavel Emelyanov * routine might require mmap_sem taken in might_fault(). 1952640708a2SPavel Emelyanov */ 1953640708a2SPavel Emelyanov 1954640708a2SPavel Emelyanov for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) { 1955f0c3b509SAl Viro if (vma->vm_file && ++pos > ctx->pos) 1956640708a2SPavel Emelyanov nr_files++; 1957640708a2SPavel Emelyanov } 1958640708a2SPavel Emelyanov 1959640708a2SPavel Emelyanov if (nr_files) { 1960640708a2SPavel Emelyanov fa = flex_array_alloc(sizeof(info), nr_files, 1961640708a2SPavel Emelyanov GFP_KERNEL); 1962640708a2SPavel Emelyanov if (!fa || flex_array_prealloc(fa, 0, nr_files, 1963640708a2SPavel Emelyanov GFP_KERNEL)) { 1964640708a2SPavel Emelyanov ret = -ENOMEM; 1965640708a2SPavel Emelyanov if (fa) 1966640708a2SPavel Emelyanov flex_array_free(fa); 1967640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1968640708a2SPavel Emelyanov mmput(mm); 1969eb94cd96SCyrill Gorcunov goto out_put_task; 1970640708a2SPavel Emelyanov } 1971640708a2SPavel Emelyanov for (i = 0, vma = mm->mmap, pos = 2; vma; 1972640708a2SPavel Emelyanov vma = vma->vm_next) { 1973640708a2SPavel Emelyanov if (!vma->vm_file) 1974640708a2SPavel Emelyanov continue; 1975f0c3b509SAl Viro if (++pos <= ctx->pos) 1976640708a2SPavel Emelyanov continue; 1977640708a2SPavel Emelyanov 19787b540d06SAl Viro info.mode = vma->vm_file->f_mode; 1979640708a2SPavel Emelyanov info.len = snprintf(info.name, 1980640708a2SPavel Emelyanov sizeof(info.name), "%lx-%lx", 1981640708a2SPavel Emelyanov vma->vm_start, vma->vm_end); 1982640708a2SPavel Emelyanov if (flex_array_put(fa, i++, &info, GFP_KERNEL)) 1983640708a2SPavel Emelyanov BUG(); 1984640708a2SPavel Emelyanov } 1985640708a2SPavel Emelyanov } 1986640708a2SPavel Emelyanov up_read(&mm->mmap_sem); 1987640708a2SPavel Emelyanov 1988640708a2SPavel Emelyanov for (i = 0; i < nr_files; i++) { 1989640708a2SPavel Emelyanov p = flex_array_get(fa, i); 1990f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, 1991640708a2SPavel Emelyanov p->name, p->len, 1992640708a2SPavel Emelyanov proc_map_files_instantiate, 19937b540d06SAl Viro task, 1994f0c3b509SAl Viro (void *)(unsigned long)p->mode)) 1995640708a2SPavel Emelyanov break; 1996f0c3b509SAl Viro ctx->pos++; 1997640708a2SPavel Emelyanov } 1998640708a2SPavel Emelyanov if (fa) 1999640708a2SPavel Emelyanov flex_array_free(fa); 2000640708a2SPavel Emelyanov mmput(mm); 2001640708a2SPavel Emelyanov 2002640708a2SPavel Emelyanov out_put_task: 2003640708a2SPavel Emelyanov put_task_struct(task); 2004640708a2SPavel Emelyanov out: 2005640708a2SPavel Emelyanov return ret; 2006640708a2SPavel Emelyanov } 2007640708a2SPavel Emelyanov 2008640708a2SPavel Emelyanov static const struct file_operations proc_map_files_operations = { 2009640708a2SPavel Emelyanov .read = generic_read_dir, 2010f0c3b509SAl Viro .iterate = proc_map_files_readdir, 2011640708a2SPavel Emelyanov .llseek = default_llseek, 2012640708a2SPavel Emelyanov }; 2013640708a2SPavel Emelyanov 201448f6a7a5SPavel Emelyanov struct timers_private { 201548f6a7a5SPavel Emelyanov struct pid *pid; 201648f6a7a5SPavel Emelyanov struct task_struct *task; 201748f6a7a5SPavel Emelyanov struct sighand_struct *sighand; 201857b8015eSPavel Emelyanov struct pid_namespace *ns; 201948f6a7a5SPavel Emelyanov unsigned long flags; 202048f6a7a5SPavel Emelyanov }; 202148f6a7a5SPavel Emelyanov 202248f6a7a5SPavel Emelyanov static void *timers_start(struct seq_file *m, loff_t *pos) 202348f6a7a5SPavel Emelyanov { 202448f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 202548f6a7a5SPavel Emelyanov 202648f6a7a5SPavel Emelyanov tp->task = get_pid_task(tp->pid, PIDTYPE_PID); 202748f6a7a5SPavel Emelyanov if (!tp->task) 202848f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 202948f6a7a5SPavel Emelyanov 203048f6a7a5SPavel Emelyanov tp->sighand = lock_task_sighand(tp->task, &tp->flags); 203148f6a7a5SPavel Emelyanov if (!tp->sighand) 203248f6a7a5SPavel Emelyanov return ERR_PTR(-ESRCH); 203348f6a7a5SPavel Emelyanov 203448f6a7a5SPavel Emelyanov return seq_list_start(&tp->task->signal->posix_timers, *pos); 203548f6a7a5SPavel Emelyanov } 203648f6a7a5SPavel Emelyanov 203748f6a7a5SPavel Emelyanov static void *timers_next(struct seq_file *m, void *v, loff_t *pos) 203848f6a7a5SPavel Emelyanov { 203948f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 204048f6a7a5SPavel Emelyanov return seq_list_next(v, &tp->task->signal->posix_timers, pos); 204148f6a7a5SPavel Emelyanov } 204248f6a7a5SPavel Emelyanov 204348f6a7a5SPavel Emelyanov static void timers_stop(struct seq_file *m, void *v) 204448f6a7a5SPavel Emelyanov { 204548f6a7a5SPavel Emelyanov struct timers_private *tp = m->private; 204648f6a7a5SPavel Emelyanov 204748f6a7a5SPavel Emelyanov if (tp->sighand) { 204848f6a7a5SPavel Emelyanov unlock_task_sighand(tp->task, &tp->flags); 204948f6a7a5SPavel Emelyanov tp->sighand = NULL; 205048f6a7a5SPavel Emelyanov } 205148f6a7a5SPavel Emelyanov 205248f6a7a5SPavel Emelyanov if (tp->task) { 205348f6a7a5SPavel Emelyanov put_task_struct(tp->task); 205448f6a7a5SPavel Emelyanov tp->task = NULL; 205548f6a7a5SPavel Emelyanov } 205648f6a7a5SPavel Emelyanov } 205748f6a7a5SPavel Emelyanov 205848f6a7a5SPavel Emelyanov static int show_timer(struct seq_file *m, void *v) 205948f6a7a5SPavel Emelyanov { 206048f6a7a5SPavel Emelyanov struct k_itimer *timer; 206157b8015eSPavel Emelyanov struct timers_private *tp = m->private; 206257b8015eSPavel Emelyanov int notify; 2063cedbccabSAlexey Dobriyan static const char * const nstr[] = { 206457b8015eSPavel Emelyanov [SIGEV_SIGNAL] = "signal", 206557b8015eSPavel Emelyanov [SIGEV_NONE] = "none", 206657b8015eSPavel Emelyanov [SIGEV_THREAD] = "thread", 206757b8015eSPavel Emelyanov }; 206848f6a7a5SPavel Emelyanov 206948f6a7a5SPavel Emelyanov timer = list_entry((struct list_head *)v, struct k_itimer, list); 207057b8015eSPavel Emelyanov notify = timer->it_sigev_notify; 207157b8015eSPavel Emelyanov 207248f6a7a5SPavel Emelyanov seq_printf(m, "ID: %d\n", timer->it_id); 207357b8015eSPavel Emelyanov seq_printf(m, "signal: %d/%p\n", timer->sigq->info.si_signo, 207457b8015eSPavel Emelyanov timer->sigq->info.si_value.sival_ptr); 207557b8015eSPavel Emelyanov seq_printf(m, "notify: %s/%s.%d\n", 207657b8015eSPavel Emelyanov nstr[notify & ~SIGEV_THREAD_ID], 207757b8015eSPavel Emelyanov (notify & SIGEV_THREAD_ID) ? "tid" : "pid", 207857b8015eSPavel Emelyanov pid_nr_ns(timer->it_pid, tp->ns)); 207915ef0298SPavel Tikhomirov seq_printf(m, "ClockID: %d\n", timer->it_clock); 208048f6a7a5SPavel Emelyanov 208148f6a7a5SPavel Emelyanov return 0; 208248f6a7a5SPavel Emelyanov } 208348f6a7a5SPavel Emelyanov 208448f6a7a5SPavel Emelyanov static const struct seq_operations proc_timers_seq_ops = { 208548f6a7a5SPavel Emelyanov .start = timers_start, 208648f6a7a5SPavel Emelyanov .next = timers_next, 208748f6a7a5SPavel Emelyanov .stop = timers_stop, 208848f6a7a5SPavel Emelyanov .show = show_timer, 208948f6a7a5SPavel Emelyanov }; 209048f6a7a5SPavel Emelyanov 209148f6a7a5SPavel Emelyanov static int proc_timers_open(struct inode *inode, struct file *file) 209248f6a7a5SPavel Emelyanov { 209348f6a7a5SPavel Emelyanov struct timers_private *tp; 209448f6a7a5SPavel Emelyanov 209548f6a7a5SPavel Emelyanov tp = __seq_open_private(file, &proc_timers_seq_ops, 209648f6a7a5SPavel Emelyanov sizeof(struct timers_private)); 209748f6a7a5SPavel Emelyanov if (!tp) 209848f6a7a5SPavel Emelyanov return -ENOMEM; 209948f6a7a5SPavel Emelyanov 210048f6a7a5SPavel Emelyanov tp->pid = proc_pid(inode); 210157b8015eSPavel Emelyanov tp->ns = inode->i_sb->s_fs_info; 210248f6a7a5SPavel Emelyanov return 0; 210348f6a7a5SPavel Emelyanov } 210448f6a7a5SPavel Emelyanov 210548f6a7a5SPavel Emelyanov static const struct file_operations proc_timers_operations = { 210648f6a7a5SPavel Emelyanov .open = proc_timers_open, 210748f6a7a5SPavel Emelyanov .read = seq_read, 210848f6a7a5SPavel Emelyanov .llseek = seq_lseek, 210948f6a7a5SPavel Emelyanov .release = seq_release_private, 211048f6a7a5SPavel Emelyanov }; 2111640708a2SPavel Emelyanov #endif /* CONFIG_CHECKPOINT_RESTORE */ 2112640708a2SPavel Emelyanov 2113c52a47acSAl Viro static int proc_pident_instantiate(struct inode *dir, 2114c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 2115444ceed8SEric W. Biederman { 2116c5141e6dSEric Dumazet const struct pid_entry *p = ptr; 2117444ceed8SEric W. Biederman struct inode *inode; 2118444ceed8SEric W. Biederman struct proc_inode *ei; 2119444ceed8SEric W. Biederman 212061a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2121444ceed8SEric W. Biederman if (!inode) 2122444ceed8SEric W. Biederman goto out; 2123444ceed8SEric W. Biederman 2124444ceed8SEric W. Biederman ei = PROC_I(inode); 2125444ceed8SEric W. Biederman inode->i_mode = p->mode; 2126444ceed8SEric W. Biederman if (S_ISDIR(inode->i_mode)) 2127bfe86848SMiklos Szeredi set_nlink(inode, 2); /* Use getattr to fix if necessary */ 2128444ceed8SEric W. Biederman if (p->iop) 2129444ceed8SEric W. Biederman inode->i_op = p->iop; 2130444ceed8SEric W. Biederman if (p->fop) 2131444ceed8SEric W. Biederman inode->i_fop = p->fop; 2132444ceed8SEric W. Biederman ei->op = p->op; 2133fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2134444ceed8SEric W. Biederman d_add(dentry, inode); 2135444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 21360b728e19SAl Viro if (pid_revalidate(dentry, 0)) 2137c52a47acSAl Viro return 0; 2138444ceed8SEric W. Biederman out: 2139c52a47acSAl Viro return -ENOENT; 2140444ceed8SEric W. Biederman } 2141444ceed8SEric W. Biederman 21421da177e4SLinus Torvalds static struct dentry *proc_pident_lookup(struct inode *dir, 21431da177e4SLinus Torvalds struct dentry *dentry, 2144c5141e6dSEric Dumazet const struct pid_entry *ents, 21457bcd6b0eSEric W. Biederman unsigned int nents) 21461da177e4SLinus Torvalds { 2147c52a47acSAl Viro int error; 214899f89551SEric W. Biederman struct task_struct *task = get_proc_task(dir); 2149c5141e6dSEric Dumazet const struct pid_entry *p, *last; 21501da177e4SLinus Torvalds 2151c52a47acSAl Viro error = -ENOENT; 21521da177e4SLinus Torvalds 215399f89551SEric W. Biederman if (!task) 215499f89551SEric W. Biederman goto out_no_task; 21551da177e4SLinus Torvalds 215620cdc894SEric W. Biederman /* 215720cdc894SEric W. Biederman * Yes, it does not scale. And it should not. Don't add 215820cdc894SEric W. Biederman * new entries into /proc/<tgid>/ without very good reasons. 215920cdc894SEric W. Biederman */ 21607bcd6b0eSEric W. Biederman last = &ents[nents - 1]; 21617bcd6b0eSEric W. Biederman for (p = ents; p <= last; p++) { 21621da177e4SLinus Torvalds if (p->len != dentry->d_name.len) 21631da177e4SLinus Torvalds continue; 21641da177e4SLinus Torvalds if (!memcmp(dentry->d_name.name, p->name, p->len)) 21651da177e4SLinus Torvalds break; 21661da177e4SLinus Torvalds } 21677bcd6b0eSEric W. Biederman if (p > last) 21681da177e4SLinus Torvalds goto out; 21691da177e4SLinus Torvalds 2170444ceed8SEric W. Biederman error = proc_pident_instantiate(dir, dentry, task, p); 21711da177e4SLinus Torvalds out: 217299f89551SEric W. Biederman put_task_struct(task); 217399f89551SEric W. Biederman out_no_task: 2174c52a47acSAl Viro return ERR_PTR(error); 21751da177e4SLinus Torvalds } 21761da177e4SLinus Torvalds 2177f0c3b509SAl Viro static int proc_pident_readdir(struct file *file, struct dir_context *ctx, 2178c5141e6dSEric Dumazet const struct pid_entry *ents, unsigned int nents) 217928a6d671SEric W. Biederman { 2180f0c3b509SAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 2181f0c3b509SAl Viro const struct pid_entry *p; 218228a6d671SEric W. Biederman 218328a6d671SEric W. Biederman if (!task) 2184f0c3b509SAl Viro return -ENOENT; 218528a6d671SEric W. Biederman 2186f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 218728a6d671SEric W. Biederman goto out; 21881da177e4SLinus Torvalds 2189f0c3b509SAl Viro if (ctx->pos >= nents + 2) 2190f0c3b509SAl Viro goto out; 2191f0c3b509SAl Viro 2192f0c3b509SAl Viro for (p = ents + (ctx->pos - 2); p <= ents + nents - 1; p++) { 2193f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, p->name, p->len, 2194f0c3b509SAl Viro proc_pident_instantiate, task, p)) 2195f0c3b509SAl Viro break; 2196f0c3b509SAl Viro ctx->pos++; 2197f0c3b509SAl Viro } 219828a6d671SEric W. Biederman out: 219961a28784SEric W. Biederman put_task_struct(task); 2200f0c3b509SAl Viro return 0; 22011da177e4SLinus Torvalds } 22021da177e4SLinus Torvalds 22031da177e4SLinus Torvalds #ifdef CONFIG_SECURITY 220428a6d671SEric W. Biederman static ssize_t proc_pid_attr_read(struct file * file, char __user * buf, 220528a6d671SEric W. Biederman size_t count, loff_t *ppos) 220628a6d671SEric W. Biederman { 2207496ad9aaSAl Viro struct inode * inode = file_inode(file); 220804ff9708SAl Viro char *p = NULL; 220928a6d671SEric W. Biederman ssize_t length; 221028a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 221128a6d671SEric W. Biederman 221228a6d671SEric W. Biederman if (!task) 221304ff9708SAl Viro return -ESRCH; 221428a6d671SEric W. Biederman 221528a6d671SEric W. Biederman length = security_getprocattr(task, 22162fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 221704ff9708SAl Viro &p); 221828a6d671SEric W. Biederman put_task_struct(task); 221904ff9708SAl Viro if (length > 0) 222004ff9708SAl Viro length = simple_read_from_buffer(buf, count, ppos, p, length); 222104ff9708SAl Viro kfree(p); 222228a6d671SEric W. Biederman return length; 222328a6d671SEric W. Biederman } 222428a6d671SEric W. Biederman 222528a6d671SEric W. Biederman static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf, 222628a6d671SEric W. Biederman size_t count, loff_t *ppos) 222728a6d671SEric W. Biederman { 2228496ad9aaSAl Viro struct inode * inode = file_inode(file); 222928a6d671SEric W. Biederman char *page; 223028a6d671SEric W. Biederman ssize_t length; 223128a6d671SEric W. Biederman struct task_struct *task = get_proc_task(inode); 223228a6d671SEric W. Biederman 223328a6d671SEric W. Biederman length = -ESRCH; 223428a6d671SEric W. Biederman if (!task) 223528a6d671SEric W. Biederman goto out_no_task; 223628a6d671SEric W. Biederman if (count > PAGE_SIZE) 223728a6d671SEric W. Biederman count = PAGE_SIZE; 223828a6d671SEric W. Biederman 223928a6d671SEric W. Biederman /* No partial writes. */ 224028a6d671SEric W. Biederman length = -EINVAL; 224128a6d671SEric W. Biederman if (*ppos != 0) 224228a6d671SEric W. Biederman goto out; 224328a6d671SEric W. Biederman 224428a6d671SEric W. Biederman length = -ENOMEM; 2245e12ba74dSMel Gorman page = (char*)__get_free_page(GFP_TEMPORARY); 224628a6d671SEric W. Biederman if (!page) 224728a6d671SEric W. Biederman goto out; 224828a6d671SEric W. Biederman 224928a6d671SEric W. Biederman length = -EFAULT; 225028a6d671SEric W. Biederman if (copy_from_user(page, buf, count)) 225128a6d671SEric W. Biederman goto out_free; 225228a6d671SEric W. Biederman 2253107db7c7SDavid Howells /* Guard against adverse ptrace interaction */ 22549b1bf12dSKOSAKI Motohiro length = mutex_lock_interruptible(&task->signal->cred_guard_mutex); 2255107db7c7SDavid Howells if (length < 0) 2256107db7c7SDavid Howells goto out_free; 2257107db7c7SDavid Howells 225828a6d671SEric W. Biederman length = security_setprocattr(task, 22592fddfeefSJosef "Jeff" Sipek (char*)file->f_path.dentry->d_name.name, 226028a6d671SEric W. Biederman (void*)page, count); 22619b1bf12dSKOSAKI Motohiro mutex_unlock(&task->signal->cred_guard_mutex); 226228a6d671SEric W. Biederman out_free: 226328a6d671SEric W. Biederman free_page((unsigned long) page); 226428a6d671SEric W. Biederman out: 226528a6d671SEric W. Biederman put_task_struct(task); 226628a6d671SEric W. Biederman out_no_task: 226728a6d671SEric W. Biederman return length; 226828a6d671SEric W. Biederman } 226928a6d671SEric W. Biederman 227000977a59SArjan van de Ven static const struct file_operations proc_pid_attr_operations = { 227128a6d671SEric W. Biederman .read = proc_pid_attr_read, 227228a6d671SEric W. Biederman .write = proc_pid_attr_write, 227387df8424SArnd Bergmann .llseek = generic_file_llseek, 227428a6d671SEric W. Biederman }; 227528a6d671SEric W. Biederman 2276c5141e6dSEric Dumazet static const struct pid_entry attr_dir_stuff[] = { 2277631f9c18SAlexey Dobriyan REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2278631f9c18SAlexey Dobriyan REG("prev", S_IRUGO, proc_pid_attr_operations), 2279631f9c18SAlexey Dobriyan REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2280631f9c18SAlexey Dobriyan REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2281631f9c18SAlexey Dobriyan REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 2282631f9c18SAlexey Dobriyan REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations), 228328a6d671SEric W. Biederman }; 228428a6d671SEric W. Biederman 2285f0c3b509SAl Viro static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx) 22861da177e4SLinus Torvalds { 2287f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 228872d9dcfcSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 22891da177e4SLinus Torvalds } 22901da177e4SLinus Torvalds 229100977a59SArjan van de Ven static const struct file_operations proc_attr_dir_operations = { 22921da177e4SLinus Torvalds .read = generic_read_dir, 2293f0c3b509SAl Viro .iterate = proc_attr_dir_readdir, 22946038f373SArnd Bergmann .llseek = default_llseek, 22951da177e4SLinus Torvalds }; 22961da177e4SLinus Torvalds 229772d9dcfcSEric W. Biederman static struct dentry *proc_attr_dir_lookup(struct inode *dir, 229800cd8dd3SAl Viro struct dentry *dentry, unsigned int flags) 22991da177e4SLinus Torvalds { 23007bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 23017bcd6b0eSEric W. Biederman attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff)); 23021da177e4SLinus Torvalds } 23031da177e4SLinus Torvalds 2304c5ef1c42SArjan van de Ven static const struct inode_operations proc_attr_dir_inode_operations = { 230572d9dcfcSEric W. Biederman .lookup = proc_attr_dir_lookup, 230699f89551SEric W. Biederman .getattr = pid_getattr, 23076d76fa58SLinus Torvalds .setattr = proc_setattr, 23081da177e4SLinus Torvalds }; 23091da177e4SLinus Torvalds 23101da177e4SLinus Torvalds #endif 23111da177e4SLinus Torvalds 2312698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 23133cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, 23143cb4a0bbSKawai, Hidehiro size_t count, loff_t *ppos) 23153cb4a0bbSKawai, Hidehiro { 2316496ad9aaSAl Viro struct task_struct *task = get_proc_task(file_inode(file)); 23173cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 23183cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF]; 23193cb4a0bbSKawai, Hidehiro size_t len; 23203cb4a0bbSKawai, Hidehiro int ret; 23213cb4a0bbSKawai, Hidehiro 23223cb4a0bbSKawai, Hidehiro if (!task) 23233cb4a0bbSKawai, Hidehiro return -ESRCH; 23243cb4a0bbSKawai, Hidehiro 23253cb4a0bbSKawai, Hidehiro ret = 0; 23263cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 23273cb4a0bbSKawai, Hidehiro if (mm) { 23283cb4a0bbSKawai, Hidehiro len = snprintf(buffer, sizeof(buffer), "%08lx\n", 23293cb4a0bbSKawai, Hidehiro ((mm->flags & MMF_DUMP_FILTER_MASK) >> 23303cb4a0bbSKawai, Hidehiro MMF_DUMP_FILTER_SHIFT)); 23313cb4a0bbSKawai, Hidehiro mmput(mm); 23323cb4a0bbSKawai, Hidehiro ret = simple_read_from_buffer(buf, count, ppos, buffer, len); 23333cb4a0bbSKawai, Hidehiro } 23343cb4a0bbSKawai, Hidehiro 23353cb4a0bbSKawai, Hidehiro put_task_struct(task); 23363cb4a0bbSKawai, Hidehiro 23373cb4a0bbSKawai, Hidehiro return ret; 23383cb4a0bbSKawai, Hidehiro } 23393cb4a0bbSKawai, Hidehiro 23403cb4a0bbSKawai, Hidehiro static ssize_t proc_coredump_filter_write(struct file *file, 23413cb4a0bbSKawai, Hidehiro const char __user *buf, 23423cb4a0bbSKawai, Hidehiro size_t count, 23433cb4a0bbSKawai, Hidehiro loff_t *ppos) 23443cb4a0bbSKawai, Hidehiro { 23453cb4a0bbSKawai, Hidehiro struct task_struct *task; 23463cb4a0bbSKawai, Hidehiro struct mm_struct *mm; 23473cb4a0bbSKawai, Hidehiro char buffer[PROC_NUMBUF], *end; 23483cb4a0bbSKawai, Hidehiro unsigned int val; 23493cb4a0bbSKawai, Hidehiro int ret; 23503cb4a0bbSKawai, Hidehiro int i; 23513cb4a0bbSKawai, Hidehiro unsigned long mask; 23523cb4a0bbSKawai, Hidehiro 23533cb4a0bbSKawai, Hidehiro ret = -EFAULT; 23543cb4a0bbSKawai, Hidehiro memset(buffer, 0, sizeof(buffer)); 23553cb4a0bbSKawai, Hidehiro if (count > sizeof(buffer) - 1) 23563cb4a0bbSKawai, Hidehiro count = sizeof(buffer) - 1; 23573cb4a0bbSKawai, Hidehiro if (copy_from_user(buffer, buf, count)) 23583cb4a0bbSKawai, Hidehiro goto out_no_task; 23593cb4a0bbSKawai, Hidehiro 23603cb4a0bbSKawai, Hidehiro ret = -EINVAL; 23613cb4a0bbSKawai, Hidehiro val = (unsigned int)simple_strtoul(buffer, &end, 0); 23623cb4a0bbSKawai, Hidehiro if (*end == '\n') 23633cb4a0bbSKawai, Hidehiro end++; 23643cb4a0bbSKawai, Hidehiro if (end - buffer == 0) 23653cb4a0bbSKawai, Hidehiro goto out_no_task; 23663cb4a0bbSKawai, Hidehiro 23673cb4a0bbSKawai, Hidehiro ret = -ESRCH; 2368496ad9aaSAl Viro task = get_proc_task(file_inode(file)); 23693cb4a0bbSKawai, Hidehiro if (!task) 23703cb4a0bbSKawai, Hidehiro goto out_no_task; 23713cb4a0bbSKawai, Hidehiro 23723cb4a0bbSKawai, Hidehiro ret = end - buffer; 23733cb4a0bbSKawai, Hidehiro mm = get_task_mm(task); 23743cb4a0bbSKawai, Hidehiro if (!mm) 23753cb4a0bbSKawai, Hidehiro goto out_no_mm; 23763cb4a0bbSKawai, Hidehiro 23773cb4a0bbSKawai, Hidehiro for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) { 23783cb4a0bbSKawai, Hidehiro if (val & mask) 23793cb4a0bbSKawai, Hidehiro set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 23803cb4a0bbSKawai, Hidehiro else 23813cb4a0bbSKawai, Hidehiro clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags); 23823cb4a0bbSKawai, Hidehiro } 23833cb4a0bbSKawai, Hidehiro 23843cb4a0bbSKawai, Hidehiro mmput(mm); 23853cb4a0bbSKawai, Hidehiro out_no_mm: 23863cb4a0bbSKawai, Hidehiro put_task_struct(task); 23873cb4a0bbSKawai, Hidehiro out_no_task: 23883cb4a0bbSKawai, Hidehiro return ret; 23893cb4a0bbSKawai, Hidehiro } 23903cb4a0bbSKawai, Hidehiro 23913cb4a0bbSKawai, Hidehiro static const struct file_operations proc_coredump_filter_operations = { 23923cb4a0bbSKawai, Hidehiro .read = proc_coredump_filter_read, 23933cb4a0bbSKawai, Hidehiro .write = proc_coredump_filter_write, 239487df8424SArnd Bergmann .llseek = generic_file_llseek, 23953cb4a0bbSKawai, Hidehiro }; 23963cb4a0bbSKawai, Hidehiro #endif 23973cb4a0bbSKawai, Hidehiro 2398aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 2399297c5d92SAndrea Righi static int do_io_accounting(struct task_struct *task, char *buffer, int whole) 2400aba76fdbSAndrew Morton { 2401940389b8SAndrea Righi struct task_io_accounting acct = task->ioac; 2402297c5d92SAndrea Righi unsigned long flags; 2403293eb1e7SVasiliy Kulikov int result; 2404297c5d92SAndrea Righi 2405293eb1e7SVasiliy Kulikov result = mutex_lock_killable(&task->signal->cred_guard_mutex); 2406293eb1e7SVasiliy Kulikov if (result) 2407293eb1e7SVasiliy Kulikov return result; 2408293eb1e7SVasiliy Kulikov 2409293eb1e7SVasiliy Kulikov if (!ptrace_may_access(task, PTRACE_MODE_READ)) { 2410293eb1e7SVasiliy Kulikov result = -EACCES; 2411293eb1e7SVasiliy Kulikov goto out_unlock; 2412293eb1e7SVasiliy Kulikov } 24131d1221f3SVasiliy Kulikov 24145995477aSAndrea Righi if (whole && lock_task_sighand(task, &flags)) { 2415b2d002dbSAndrea Righi struct task_struct *t = task; 2416297c5d92SAndrea Righi 24175995477aSAndrea Righi task_io_accounting_add(&acct, &task->signal->ioac); 24185995477aSAndrea Righi while_each_thread(task, t) 24195995477aSAndrea Righi task_io_accounting_add(&acct, &t->ioac); 2420297c5d92SAndrea Righi 2421297c5d92SAndrea Righi unlock_task_sighand(task, &flags); 2422297c5d92SAndrea Righi } 2423293eb1e7SVasiliy Kulikov result = sprintf(buffer, 2424aba76fdbSAndrew Morton "rchar: %llu\n" 2425aba76fdbSAndrew Morton "wchar: %llu\n" 2426aba76fdbSAndrew Morton "syscr: %llu\n" 2427aba76fdbSAndrew Morton "syscw: %llu\n" 2428aba76fdbSAndrew Morton "read_bytes: %llu\n" 2429aba76fdbSAndrew Morton "write_bytes: %llu\n" 2430aba76fdbSAndrew Morton "cancelled_write_bytes: %llu\n", 24317c44319dSAlexander Beregalov (unsigned long long)acct.rchar, 24327c44319dSAlexander Beregalov (unsigned long long)acct.wchar, 24337c44319dSAlexander Beregalov (unsigned long long)acct.syscr, 24347c44319dSAlexander Beregalov (unsigned long long)acct.syscw, 24357c44319dSAlexander Beregalov (unsigned long long)acct.read_bytes, 24367c44319dSAlexander Beregalov (unsigned long long)acct.write_bytes, 24377c44319dSAlexander Beregalov (unsigned long long)acct.cancelled_write_bytes); 2438293eb1e7SVasiliy Kulikov out_unlock: 2439293eb1e7SVasiliy Kulikov mutex_unlock(&task->signal->cred_guard_mutex); 2440293eb1e7SVasiliy Kulikov return result; 2441aba76fdbSAndrew Morton } 2442297c5d92SAndrea Righi 2443297c5d92SAndrea Righi static int proc_tid_io_accounting(struct task_struct *task, char *buffer) 2444297c5d92SAndrea Righi { 2445297c5d92SAndrea Righi return do_io_accounting(task, buffer, 0); 2446297c5d92SAndrea Righi } 2447297c5d92SAndrea Righi 2448297c5d92SAndrea Righi static int proc_tgid_io_accounting(struct task_struct *task, char *buffer) 2449297c5d92SAndrea Righi { 2450297c5d92SAndrea Righi return do_io_accounting(task, buffer, 1); 2451297c5d92SAndrea Righi } 2452297c5d92SAndrea Righi #endif /* CONFIG_TASK_IO_ACCOUNTING */ 2453aba76fdbSAndrew Morton 245422d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 245522d917d8SEric W. Biederman static int proc_id_map_open(struct inode *inode, struct file *file, 2456ccf94f1bSFabian Frederick const struct seq_operations *seq_ops) 245722d917d8SEric W. Biederman { 245822d917d8SEric W. Biederman struct user_namespace *ns = NULL; 245922d917d8SEric W. Biederman struct task_struct *task; 246022d917d8SEric W. Biederman struct seq_file *seq; 246122d917d8SEric W. Biederman int ret = -EINVAL; 246222d917d8SEric W. Biederman 246322d917d8SEric W. Biederman task = get_proc_task(inode); 246422d917d8SEric W. Biederman if (task) { 246522d917d8SEric W. Biederman rcu_read_lock(); 246622d917d8SEric W. Biederman ns = get_user_ns(task_cred_xxx(task, user_ns)); 246722d917d8SEric W. Biederman rcu_read_unlock(); 246822d917d8SEric W. Biederman put_task_struct(task); 246922d917d8SEric W. Biederman } 247022d917d8SEric W. Biederman if (!ns) 247122d917d8SEric W. Biederman goto err; 247222d917d8SEric W. Biederman 247322d917d8SEric W. Biederman ret = seq_open(file, seq_ops); 247422d917d8SEric W. Biederman if (ret) 247522d917d8SEric W. Biederman goto err_put_ns; 247622d917d8SEric W. Biederman 247722d917d8SEric W. Biederman seq = file->private_data; 247822d917d8SEric W. Biederman seq->private = ns; 247922d917d8SEric W. Biederman 248022d917d8SEric W. Biederman return 0; 248122d917d8SEric W. Biederman err_put_ns: 248222d917d8SEric W. Biederman put_user_ns(ns); 248322d917d8SEric W. Biederman err: 248422d917d8SEric W. Biederman return ret; 248522d917d8SEric W. Biederman } 248622d917d8SEric W. Biederman 248722d917d8SEric W. Biederman static int proc_id_map_release(struct inode *inode, struct file *file) 248822d917d8SEric W. Biederman { 248922d917d8SEric W. Biederman struct seq_file *seq = file->private_data; 249022d917d8SEric W. Biederman struct user_namespace *ns = seq->private; 249122d917d8SEric W. Biederman put_user_ns(ns); 249222d917d8SEric W. Biederman return seq_release(inode, file); 249322d917d8SEric W. Biederman } 249422d917d8SEric W. Biederman 249522d917d8SEric W. Biederman static int proc_uid_map_open(struct inode *inode, struct file *file) 249622d917d8SEric W. Biederman { 249722d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_uid_seq_operations); 249822d917d8SEric W. Biederman } 249922d917d8SEric W. Biederman 250022d917d8SEric W. Biederman static int proc_gid_map_open(struct inode *inode, struct file *file) 250122d917d8SEric W. Biederman { 250222d917d8SEric W. Biederman return proc_id_map_open(inode, file, &proc_gid_seq_operations); 250322d917d8SEric W. Biederman } 250422d917d8SEric W. Biederman 2505f76d207aSEric W. Biederman static int proc_projid_map_open(struct inode *inode, struct file *file) 2506f76d207aSEric W. Biederman { 2507f76d207aSEric W. Biederman return proc_id_map_open(inode, file, &proc_projid_seq_operations); 2508f76d207aSEric W. Biederman } 2509f76d207aSEric W. Biederman 251022d917d8SEric W. Biederman static const struct file_operations proc_uid_map_operations = { 251122d917d8SEric W. Biederman .open = proc_uid_map_open, 251222d917d8SEric W. Biederman .write = proc_uid_map_write, 251322d917d8SEric W. Biederman .read = seq_read, 251422d917d8SEric W. Biederman .llseek = seq_lseek, 251522d917d8SEric W. Biederman .release = proc_id_map_release, 251622d917d8SEric W. Biederman }; 251722d917d8SEric W. Biederman 251822d917d8SEric W. Biederman static const struct file_operations proc_gid_map_operations = { 251922d917d8SEric W. Biederman .open = proc_gid_map_open, 252022d917d8SEric W. Biederman .write = proc_gid_map_write, 252122d917d8SEric W. Biederman .read = seq_read, 252222d917d8SEric W. Biederman .llseek = seq_lseek, 252322d917d8SEric W. Biederman .release = proc_id_map_release, 252422d917d8SEric W. Biederman }; 2525f76d207aSEric W. Biederman 2526f76d207aSEric W. Biederman static const struct file_operations proc_projid_map_operations = { 2527f76d207aSEric W. Biederman .open = proc_projid_map_open, 2528f76d207aSEric W. Biederman .write = proc_projid_map_write, 2529f76d207aSEric W. Biederman .read = seq_read, 2530f76d207aSEric W. Biederman .llseek = seq_lseek, 2531f76d207aSEric W. Biederman .release = proc_id_map_release, 2532f76d207aSEric W. Biederman }; 253322d917d8SEric W. Biederman #endif /* CONFIG_USER_NS */ 253422d917d8SEric W. Biederman 253547830723SKees Cook static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns, 253647830723SKees Cook struct pid *pid, struct task_struct *task) 253747830723SKees Cook { 2538a9712bc1SAl Viro int err = lock_trace(task); 2539a9712bc1SAl Viro if (!err) { 254047830723SKees Cook seq_printf(m, "%08x\n", task->personality); 2541a9712bc1SAl Viro unlock_trace(task); 2542a9712bc1SAl Viro } 2543a9712bc1SAl Viro return err; 254447830723SKees Cook } 254547830723SKees Cook 2546801199ceSEric W. Biederman /* 254728a6d671SEric W. Biederman * Thread groups 254828a6d671SEric W. Biederman */ 254900977a59SArjan van de Ven static const struct file_operations proc_task_operations; 2550c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations; 255120cdc894SEric W. Biederman 2552c5141e6dSEric Dumazet static const struct pid_entry tgid_base_stuff[] = { 2553631f9c18SAlexey Dobriyan DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations), 2554631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 2555640708a2SPavel Emelyanov #ifdef CONFIG_CHECKPOINT_RESTORE 2556640708a2SPavel Emelyanov DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations), 2557640708a2SPavel Emelyanov #endif 2558631f9c18SAlexey Dobriyan DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 25596b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 2560b2211a36SAndrew Morton #ifdef CONFIG_NET 2561631f9c18SAlexey Dobriyan DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations), 2562b2211a36SAndrew Morton #endif 2563631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2564f9ea536eSAlexey Dobriyan ONE("auxv", S_IRUSR, proc_pid_auxv), 2565631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 256635a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 25671c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 256843ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2569631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 257043ae34cbSIngo Molnar #endif 25715091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 25725091faa4SMike Galbraith REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations), 25735091faa4SMike Galbraith #endif 25744614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 2575ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 257609d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 2577ebcb6734SRoland McGrath #endif 25782ca66ff7SAlexey Dobriyan ONE("cmdline", S_IRUGO, proc_pid_cmdline), 2579631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tgid_stat), 2580631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2581b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_pid_maps_operations), 258228a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2583b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_pid_numa_maps_operations), 258428a6d671SEric W. Biederman #endif 2585631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2586631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2587631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2588631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2589631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2590631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 2591631f9c18SAlexey Dobriyan REG("mountstats", S_IRUSR, proc_mountstats_operations), 25921e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2593631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2594b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_pid_smaps_operations), 259532ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 259628a6d671SEric W. Biederman #endif 259728a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2598631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 259928a6d671SEric W. Biederman #endif 260028a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2601*edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 260228a6d671SEric W. Biederman #endif 26032ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 260435a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 260528a6d671SEric W. Biederman #endif 260628a6d671SEric W. Biederman #ifdef CONFIG_SCHEDSTATS 2607631f9c18SAlexey Dobriyan INF("schedstat", S_IRUGO, proc_pid_schedstat), 260828a6d671SEric W. Biederman #endif 26099745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2610631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 26119745512cSArjan van de Ven #endif 26128793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 2613631f9c18SAlexey Dobriyan REG("cpuset", S_IRUGO, proc_cpuset_operations), 261428a6d671SEric W. Biederman #endif 2615a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2616631f9c18SAlexey Dobriyan REG("cgroup", S_IRUGO, proc_cgroup_operations), 2617a424316cSPaul Menage #endif 2618631f9c18SAlexey Dobriyan INF("oom_score", S_IRUGO, proc_oom_score), 2619fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 2620a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 262128a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2622631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 2623631f9c18SAlexey Dobriyan REG("sessionid", S_IRUGO, proc_sessionid_operations), 262428a6d671SEric W. Biederman #endif 2625f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2626631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2627f4f154fdSAkinobu Mita #endif 2628698ba7b5SChristoph Hellwig #ifdef CONFIG_ELF_CORE 2629631f9c18SAlexey Dobriyan REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations), 26303cb4a0bbSKawai, Hidehiro #endif 2631aba76fdbSAndrew Morton #ifdef CONFIG_TASK_IO_ACCOUNTING 26321d1221f3SVasiliy Kulikov INF("io", S_IRUSR, proc_tgid_io_accounting), 2633aba76fdbSAndrew Morton #endif 2634f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 2635f133eccaSChris Metcalf INF("hardwall", S_IRUGO, proc_pid_hardwall), 2636f133eccaSChris Metcalf #endif 263722d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 263822d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 263922d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 2640f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 264122d917d8SEric W. Biederman #endif 264248f6a7a5SPavel Emelyanov #ifdef CONFIG_CHECKPOINT_RESTORE 264348f6a7a5SPavel Emelyanov REG("timers", S_IRUGO, proc_timers_operations), 264448f6a7a5SPavel Emelyanov #endif 264528a6d671SEric W. Biederman }; 264628a6d671SEric W. Biederman 2647f0c3b509SAl Viro static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx) 264828a6d671SEric W. Biederman { 2649f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 265028a6d671SEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 265128a6d671SEric W. Biederman } 265228a6d671SEric W. Biederman 265300977a59SArjan van de Ven static const struct file_operations proc_tgid_base_operations = { 265428a6d671SEric W. Biederman .read = generic_read_dir, 2655f0c3b509SAl Viro .iterate = proc_tgid_base_readdir, 26566038f373SArnd Bergmann .llseek = default_llseek, 265728a6d671SEric W. Biederman }; 265828a6d671SEric W. Biederman 265900cd8dd3SAl Viro static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 266000cd8dd3SAl Viro { 26617bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 26627bcd6b0eSEric W. Biederman tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff)); 266328a6d671SEric W. Biederman } 266428a6d671SEric W. Biederman 2665c5ef1c42SArjan van de Ven static const struct inode_operations proc_tgid_base_inode_operations = { 266628a6d671SEric W. Biederman .lookup = proc_tgid_base_lookup, 266728a6d671SEric W. Biederman .getattr = pid_getattr, 266828a6d671SEric W. Biederman .setattr = proc_setattr, 26690499680aSVasiliy Kulikov .permission = proc_pid_permission, 267028a6d671SEric W. Biederman }; 267128a6d671SEric W. Biederman 267260347f67SPavel Emelyanov static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid) 26731da177e4SLinus Torvalds { 267448e6484dSEric W. Biederman struct dentry *dentry, *leader, *dir; 26758578cea7SEric W. Biederman char buf[PROC_NUMBUF]; 267648e6484dSEric W. Biederman struct qstr name; 26771da177e4SLinus Torvalds 267848e6484dSEric W. Biederman name.name = buf; 267960347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 26804f522a24SAl Viro /* no ->d_hash() rejects on procfs */ 268160347f67SPavel Emelyanov dentry = d_hash_and_lookup(mnt->mnt_root, &name); 268248e6484dSEric W. Biederman if (dentry) { 268348e6484dSEric W. Biederman shrink_dcache_parent(dentry); 268448e6484dSEric W. Biederman d_drop(dentry); 268548e6484dSEric W. Biederman dput(dentry); 26861da177e4SLinus Torvalds } 26871da177e4SLinus Torvalds 268848e6484dSEric W. Biederman name.name = buf; 268960347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", tgid); 269060347f67SPavel Emelyanov leader = d_hash_and_lookup(mnt->mnt_root, &name); 269148e6484dSEric W. Biederman if (!leader) 269248e6484dSEric W. Biederman goto out; 269348e6484dSEric W. Biederman 269448e6484dSEric W. Biederman name.name = "task"; 269548e6484dSEric W. Biederman name.len = strlen(name.name); 269648e6484dSEric W. Biederman dir = d_hash_and_lookup(leader, &name); 269748e6484dSEric W. Biederman if (!dir) 269848e6484dSEric W. Biederman goto out_put_leader; 269948e6484dSEric W. Biederman 270048e6484dSEric W. Biederman name.name = buf; 270160347f67SPavel Emelyanov name.len = snprintf(buf, sizeof(buf), "%d", pid); 270248e6484dSEric W. Biederman dentry = d_hash_and_lookup(dir, &name); 270348e6484dSEric W. Biederman if (dentry) { 270448e6484dSEric W. Biederman shrink_dcache_parent(dentry); 270548e6484dSEric W. Biederman d_drop(dentry); 270648e6484dSEric W. Biederman dput(dentry); 27071da177e4SLinus Torvalds } 270848e6484dSEric W. Biederman 270948e6484dSEric W. Biederman dput(dir); 271048e6484dSEric W. Biederman out_put_leader: 271148e6484dSEric W. Biederman dput(leader); 271248e6484dSEric W. Biederman out: 271348e6484dSEric W. Biederman return; 27141da177e4SLinus Torvalds } 27151da177e4SLinus Torvalds 27160895e91dSRandy Dunlap /** 27170895e91dSRandy Dunlap * proc_flush_task - Remove dcache entries for @task from the /proc dcache. 27180895e91dSRandy Dunlap * @task: task that should be flushed. 27190895e91dSRandy Dunlap * 27200895e91dSRandy Dunlap * When flushing dentries from proc, one needs to flush them from global 272160347f67SPavel Emelyanov * proc (proc_mnt) and from all the namespaces' procs this task was seen 27220895e91dSRandy Dunlap * in. This call is supposed to do all of this job. 27230895e91dSRandy Dunlap * 27240895e91dSRandy Dunlap * Looks in the dcache for 27250895e91dSRandy Dunlap * /proc/@pid 27260895e91dSRandy Dunlap * /proc/@tgid/task/@pid 27270895e91dSRandy Dunlap * if either directory is present flushes it and all of it'ts children 27280895e91dSRandy Dunlap * from the dcache. 27290895e91dSRandy Dunlap * 27300895e91dSRandy Dunlap * It is safe and reasonable to cache /proc entries for a task until 27310895e91dSRandy Dunlap * that task exits. After that they just clog up the dcache with 27320895e91dSRandy Dunlap * useless entries, possibly causing useful dcache entries to be 27330895e91dSRandy Dunlap * flushed instead. This routine is proved to flush those useless 27340895e91dSRandy Dunlap * dcache entries at process exit time. 27350895e91dSRandy Dunlap * 27360895e91dSRandy Dunlap * NOTE: This routine is just an optimization so it does not guarantee 27370895e91dSRandy Dunlap * that no dcache entries will exist at process exit time it 27380895e91dSRandy Dunlap * just makes it very unlikely that any will persist. 273960347f67SPavel Emelyanov */ 274060347f67SPavel Emelyanov 274160347f67SPavel Emelyanov void proc_flush_task(struct task_struct *task) 274260347f67SPavel Emelyanov { 27439fcc2d15SEric W. Biederman int i; 27449b4d1cbeSOleg Nesterov struct pid *pid, *tgid; 2745130f77ecSPavel Emelyanov struct upid *upid; 2746130f77ecSPavel Emelyanov 2747130f77ecSPavel Emelyanov pid = task_pid(task); 2748130f77ecSPavel Emelyanov tgid = task_tgid(task); 27499fcc2d15SEric W. Biederman 27509fcc2d15SEric W. Biederman for (i = 0; i <= pid->level; i++) { 2751130f77ecSPavel Emelyanov upid = &pid->numbers[i]; 2752130f77ecSPavel Emelyanov proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr, 27539b4d1cbeSOleg Nesterov tgid->numbers[i].nr); 2754130f77ecSPavel Emelyanov } 275560347f67SPavel Emelyanov } 275660347f67SPavel Emelyanov 2757c52a47acSAl Viro static int proc_pid_instantiate(struct inode *dir, 27589711ef99SAdrian Bunk struct dentry * dentry, 2759c5141e6dSEric Dumazet struct task_struct *task, const void *ptr) 2760444ceed8SEric W. Biederman { 2761444ceed8SEric W. Biederman struct inode *inode; 2762444ceed8SEric W. Biederman 276361a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 2764444ceed8SEric W. Biederman if (!inode) 2765444ceed8SEric W. Biederman goto out; 2766444ceed8SEric W. Biederman 2767444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 2768444ceed8SEric W. Biederman inode->i_op = &proc_tgid_base_inode_operations; 2769444ceed8SEric W. Biederman inode->i_fop = &proc_tgid_base_operations; 2770444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 2771aed54175SVegard Nossum 2772bfe86848SMiklos Szeredi set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff, 2773bfe86848SMiklos Szeredi ARRAY_SIZE(tgid_base_stuff))); 2774444ceed8SEric W. Biederman 2775fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 2776444ceed8SEric W. Biederman 2777444ceed8SEric W. Biederman d_add(dentry, inode); 2778444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 27790b728e19SAl Viro if (pid_revalidate(dentry, 0)) 2780c52a47acSAl Viro return 0; 2781444ceed8SEric W. Biederman out: 2782c52a47acSAl Viro return -ENOENT; 2783444ceed8SEric W. Biederman } 2784444ceed8SEric W. Biederman 278500cd8dd3SAl Viro struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 27861da177e4SLinus Torvalds { 2787335eb531SAlexey Dobriyan int result = -ENOENT; 27881da177e4SLinus Torvalds struct task_struct *task; 27891da177e4SLinus Torvalds unsigned tgid; 2790b488893aSPavel Emelyanov struct pid_namespace *ns; 27911da177e4SLinus Torvalds 2792dbcdb504SAlexey Dobriyan tgid = name_to_int(&dentry->d_name); 27931da177e4SLinus Torvalds if (tgid == ~0U) 27941da177e4SLinus Torvalds goto out; 27951da177e4SLinus Torvalds 2796b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 2797de758734SEric W. Biederman rcu_read_lock(); 2798b488893aSPavel Emelyanov task = find_task_by_pid_ns(tgid, ns); 27991da177e4SLinus Torvalds if (task) 28001da177e4SLinus Torvalds get_task_struct(task); 2801de758734SEric W. Biederman rcu_read_unlock(); 28021da177e4SLinus Torvalds if (!task) 28031da177e4SLinus Torvalds goto out; 28041da177e4SLinus Torvalds 2805444ceed8SEric W. Biederman result = proc_pid_instantiate(dir, dentry, task, NULL); 280648e6484dSEric W. Biederman put_task_struct(task); 28071da177e4SLinus Torvalds out: 2808c52a47acSAl Viro return ERR_PTR(result); 28091da177e4SLinus Torvalds } 28101da177e4SLinus Torvalds 28111da177e4SLinus Torvalds /* 28120804ef4bSEric W. Biederman * Find the first task with tgid >= tgid 28130bc58a91SEric W. Biederman * 28141da177e4SLinus Torvalds */ 281519fd4bb2SEric W. Biederman struct tgid_iter { 281619fd4bb2SEric W. Biederman unsigned int tgid; 28170804ef4bSEric W. Biederman struct task_struct *task; 281819fd4bb2SEric W. Biederman }; 281919fd4bb2SEric W. Biederman static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter) 282019fd4bb2SEric W. Biederman { 28210804ef4bSEric W. Biederman struct pid *pid; 28221da177e4SLinus Torvalds 282319fd4bb2SEric W. Biederman if (iter.task) 282419fd4bb2SEric W. Biederman put_task_struct(iter.task); 28250804ef4bSEric W. Biederman rcu_read_lock(); 28260804ef4bSEric W. Biederman retry: 282719fd4bb2SEric W. Biederman iter.task = NULL; 282819fd4bb2SEric W. Biederman pid = find_ge_pid(iter.tgid, ns); 28290804ef4bSEric W. Biederman if (pid) { 283019fd4bb2SEric W. Biederman iter.tgid = pid_nr_ns(pid, ns); 283119fd4bb2SEric W. Biederman iter.task = pid_task(pid, PIDTYPE_PID); 28320804ef4bSEric W. Biederman /* What we to know is if the pid we have find is the 28330804ef4bSEric W. Biederman * pid of a thread_group_leader. Testing for task 28340804ef4bSEric W. Biederman * being a thread_group_leader is the obvious thing 28350804ef4bSEric W. Biederman * todo but there is a window when it fails, due to 28360804ef4bSEric W. Biederman * the pid transfer logic in de_thread. 28370804ef4bSEric W. Biederman * 28380804ef4bSEric W. Biederman * So we perform the straight forward test of seeing 28390804ef4bSEric W. Biederman * if the pid we have found is the pid of a thread 28400804ef4bSEric W. Biederman * group leader, and don't worry if the task we have 28410804ef4bSEric W. Biederman * found doesn't happen to be a thread group leader. 28420804ef4bSEric W. Biederman * As we don't care in the case of readdir. 28430bc58a91SEric W. Biederman */ 284419fd4bb2SEric W. Biederman if (!iter.task || !has_group_leader_pid(iter.task)) { 284519fd4bb2SEric W. Biederman iter.tgid += 1; 28460804ef4bSEric W. Biederman goto retry; 284719fd4bb2SEric W. Biederman } 284819fd4bb2SEric W. Biederman get_task_struct(iter.task); 28491da177e4SLinus Torvalds } 2850454cc105SEric W. Biederman rcu_read_unlock(); 285119fd4bb2SEric W. Biederman return iter; 28521da177e4SLinus Torvalds } 28531da177e4SLinus Torvalds 2854021ada7dSAl Viro #define TGID_OFFSET (FIRST_PROCESS_ENTRY + 1) 28551da177e4SLinus Torvalds 28561da177e4SLinus Torvalds /* for the /proc/ directory itself, after non-process stuff has been done */ 2857f0c3b509SAl Viro int proc_pid_readdir(struct file *file, struct dir_context *ctx) 28581da177e4SLinus Torvalds { 285919fd4bb2SEric W. Biederman struct tgid_iter iter; 2860db963164SAl Viro struct pid_namespace *ns = file->f_dentry->d_sb->s_fs_info; 2861f0c3b509SAl Viro loff_t pos = ctx->pos; 28621da177e4SLinus Torvalds 2863021ada7dSAl Viro if (pos >= PID_MAX_LIMIT + TGID_OFFSET) 2864f0c3b509SAl Viro return 0; 28651da177e4SLinus Torvalds 2866021ada7dSAl Viro if (pos == TGID_OFFSET - 1) { 2867db963164SAl Viro struct inode *inode = ns->proc_self->d_inode; 2868db963164SAl Viro if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK)) 2869f0c3b509SAl Viro return 0; 2870021ada7dSAl Viro iter.tgid = 0; 2871021ada7dSAl Viro } else { 2872021ada7dSAl Viro iter.tgid = pos - TGID_OFFSET; 2873021ada7dSAl Viro } 287419fd4bb2SEric W. Biederman iter.task = NULL; 287519fd4bb2SEric W. Biederman for (iter = next_tgid(ns, iter); 287619fd4bb2SEric W. Biederman iter.task; 287719fd4bb2SEric W. Biederman iter.tgid += 1, iter = next_tgid(ns, iter)) { 2878f0c3b509SAl Viro char name[PROC_NUMBUF]; 2879f0c3b509SAl Viro int len; 2880f0c3b509SAl Viro if (!has_pid_permissions(ns, iter.task, 2)) 2881f0c3b509SAl Viro continue; 28820499680aSVasiliy Kulikov 2883f0c3b509SAl Viro len = snprintf(name, sizeof(name), "%d", iter.tgid); 2884f0c3b509SAl Viro ctx->pos = iter.tgid + TGID_OFFSET; 2885f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 2886f0c3b509SAl Viro proc_pid_instantiate, iter.task, NULL)) { 288719fd4bb2SEric W. Biederman put_task_struct(iter.task); 2888f0c3b509SAl Viro return 0; 28891da177e4SLinus Torvalds } 28901da177e4SLinus Torvalds } 2891f0c3b509SAl Viro ctx->pos = PID_MAX_LIMIT + TGID_OFFSET; 28921da177e4SLinus Torvalds return 0; 28931da177e4SLinus Torvalds } 28941da177e4SLinus Torvalds 28950bc58a91SEric W. Biederman /* 289628a6d671SEric W. Biederman * Tasks 289728a6d671SEric W. Biederman */ 2898c5141e6dSEric Dumazet static const struct pid_entry tid_base_stuff[] = { 2899631f9c18SAlexey Dobriyan DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations), 29003835541dSJerome Marchand DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations), 29016b4e306aSEric W. Biederman DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations), 2902631f9c18SAlexey Dobriyan REG("environ", S_IRUSR, proc_environ_operations), 2903f9ea536eSAlexey Dobriyan ONE("auxv", S_IRUSR, proc_pid_auxv), 2904631f9c18SAlexey Dobriyan ONE("status", S_IRUGO, proc_pid_status), 290535a35046SDjalal Harouni ONE("personality", S_IRUSR, proc_pid_personality), 29061c963eb1SAlexey Dobriyan ONE("limits", S_IRUGO, proc_pid_limits), 290743ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 2908631f9c18SAlexey Dobriyan REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), 290943ae34cbSIngo Molnar #endif 29104614a696Sjohn stultz REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations), 2911ebcb6734SRoland McGrath #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 291209d93bd6SAlexey Dobriyan ONE("syscall", S_IRUSR, proc_pid_syscall), 2913ebcb6734SRoland McGrath #endif 29142ca66ff7SAlexey Dobriyan ONE("cmdline", S_IRUGO, proc_pid_cmdline), 2915631f9c18SAlexey Dobriyan ONE("stat", S_IRUGO, proc_tid_stat), 2916631f9c18SAlexey Dobriyan ONE("statm", S_IRUGO, proc_pid_statm), 2917b7643757SSiddhesh Poyarekar REG("maps", S_IRUGO, proc_tid_maps_operations), 291881841161SCyrill Gorcunov #ifdef CONFIG_CHECKPOINT_RESTORE 291981841161SCyrill Gorcunov REG("children", S_IRUGO, proc_tid_children_operations), 292081841161SCyrill Gorcunov #endif 292128a6d671SEric W. Biederman #ifdef CONFIG_NUMA 2922b7643757SSiddhesh Poyarekar REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations), 292328a6d671SEric W. Biederman #endif 2924631f9c18SAlexey Dobriyan REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations), 2925631f9c18SAlexey Dobriyan LNK("cwd", proc_cwd_link), 2926631f9c18SAlexey Dobriyan LNK("root", proc_root_link), 2927631f9c18SAlexey Dobriyan LNK("exe", proc_exe_link), 2928631f9c18SAlexey Dobriyan REG("mounts", S_IRUGO, proc_mounts_operations), 2929631f9c18SAlexey Dobriyan REG("mountinfo", S_IRUGO, proc_mountinfo_operations), 29301e883281SMatt Mackall #ifdef CONFIG_PROC_PAGE_MONITOR 2931631f9c18SAlexey Dobriyan REG("clear_refs", S_IWUSR, proc_clear_refs_operations), 2932b7643757SSiddhesh Poyarekar REG("smaps", S_IRUGO, proc_tid_smaps_operations), 293332ed74a4SDjalal Harouni REG("pagemap", S_IRUSR, proc_pagemap_operations), 293428a6d671SEric W. Biederman #endif 293528a6d671SEric W. Biederman #ifdef CONFIG_SECURITY 2936631f9c18SAlexey Dobriyan DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations), 293728a6d671SEric W. Biederman #endif 293828a6d671SEric W. Biederman #ifdef CONFIG_KALLSYMS 2939*edfcd606SAlexey Dobriyan ONE("wchan", S_IRUGO, proc_pid_wchan), 294028a6d671SEric W. Biederman #endif 29412ec220e2SKen Chen #ifdef CONFIG_STACKTRACE 294235a35046SDjalal Harouni ONE("stack", S_IRUSR, proc_pid_stack), 294328a6d671SEric W. Biederman #endif 294428a6d671SEric W. Biederman #ifdef CONFIG_SCHEDSTATS 2945631f9c18SAlexey Dobriyan INF("schedstat", S_IRUGO, proc_pid_schedstat), 294628a6d671SEric W. Biederman #endif 29479745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 2948631f9c18SAlexey Dobriyan REG("latency", S_IRUGO, proc_lstats_operations), 29499745512cSArjan van de Ven #endif 29508793d854SPaul Menage #ifdef CONFIG_PROC_PID_CPUSET 2951631f9c18SAlexey Dobriyan REG("cpuset", S_IRUGO, proc_cpuset_operations), 295228a6d671SEric W. Biederman #endif 2953a424316cSPaul Menage #ifdef CONFIG_CGROUPS 2954631f9c18SAlexey Dobriyan REG("cgroup", S_IRUGO, proc_cgroup_operations), 2955a424316cSPaul Menage #endif 2956631f9c18SAlexey Dobriyan INF("oom_score", S_IRUGO, proc_oom_score), 2957fa0cbbf1SDavid Rientjes REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adj_operations), 2958a63d83f4SDavid Rientjes REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations), 295928a6d671SEric W. Biederman #ifdef CONFIG_AUDITSYSCALL 2960631f9c18SAlexey Dobriyan REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations), 296126ec3c64SAl Viro REG("sessionid", S_IRUGO, proc_sessionid_operations), 296228a6d671SEric W. Biederman #endif 2963f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 2964631f9c18SAlexey Dobriyan REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations), 2965f4f154fdSAkinobu Mita #endif 2966297c5d92SAndrea Righi #ifdef CONFIG_TASK_IO_ACCOUNTING 29671d1221f3SVasiliy Kulikov INF("io", S_IRUSR, proc_tid_io_accounting), 2968297c5d92SAndrea Righi #endif 2969f133eccaSChris Metcalf #ifdef CONFIG_HARDWALL 2970f133eccaSChris Metcalf INF("hardwall", S_IRUGO, proc_pid_hardwall), 2971f133eccaSChris Metcalf #endif 297222d917d8SEric W. Biederman #ifdef CONFIG_USER_NS 297322d917d8SEric W. Biederman REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations), 297422d917d8SEric W. Biederman REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations), 2975f76d207aSEric W. Biederman REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations), 297622d917d8SEric W. Biederman #endif 297728a6d671SEric W. Biederman }; 297828a6d671SEric W. Biederman 2979f0c3b509SAl Viro static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx) 298028a6d671SEric W. Biederman { 2981f0c3b509SAl Viro return proc_pident_readdir(file, ctx, 298228a6d671SEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 298328a6d671SEric W. Biederman } 298428a6d671SEric W. Biederman 298500cd8dd3SAl Viro static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 298600cd8dd3SAl Viro { 29877bcd6b0eSEric W. Biederman return proc_pident_lookup(dir, dentry, 29887bcd6b0eSEric W. Biederman tid_base_stuff, ARRAY_SIZE(tid_base_stuff)); 298928a6d671SEric W. Biederman } 299028a6d671SEric W. Biederman 299100977a59SArjan van de Ven static const struct file_operations proc_tid_base_operations = { 299228a6d671SEric W. Biederman .read = generic_read_dir, 2993f0c3b509SAl Viro .iterate = proc_tid_base_readdir, 29946038f373SArnd Bergmann .llseek = default_llseek, 299528a6d671SEric W. Biederman }; 299628a6d671SEric W. Biederman 2997c5ef1c42SArjan van de Ven static const struct inode_operations proc_tid_base_inode_operations = { 299828a6d671SEric W. Biederman .lookup = proc_tid_base_lookup, 299928a6d671SEric W. Biederman .getattr = pid_getattr, 300028a6d671SEric W. Biederman .setattr = proc_setattr, 300128a6d671SEric W. Biederman }; 300228a6d671SEric W. Biederman 3003c52a47acSAl Viro static int proc_task_instantiate(struct inode *dir, 3004c5141e6dSEric Dumazet struct dentry *dentry, struct task_struct *task, const void *ptr) 3005444ceed8SEric W. Biederman { 3006444ceed8SEric W. Biederman struct inode *inode; 300761a28784SEric W. Biederman inode = proc_pid_make_inode(dir->i_sb, task); 3008444ceed8SEric W. Biederman 3009444ceed8SEric W. Biederman if (!inode) 3010444ceed8SEric W. Biederman goto out; 3011444ceed8SEric W. Biederman inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO; 3012444ceed8SEric W. Biederman inode->i_op = &proc_tid_base_inode_operations; 3013444ceed8SEric W. Biederman inode->i_fop = &proc_tid_base_operations; 3014444ceed8SEric W. Biederman inode->i_flags|=S_IMMUTABLE; 3015aed54175SVegard Nossum 3016bfe86848SMiklos Szeredi set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff, 3017bfe86848SMiklos Szeredi ARRAY_SIZE(tid_base_stuff))); 3018444ceed8SEric W. Biederman 3019fb045adbSNick Piggin d_set_d_op(dentry, &pid_dentry_operations); 3020444ceed8SEric W. Biederman 3021444ceed8SEric W. Biederman d_add(dentry, inode); 3022444ceed8SEric W. Biederman /* Close the race of the process dying before we return the dentry */ 30230b728e19SAl Viro if (pid_revalidate(dentry, 0)) 3024c52a47acSAl Viro return 0; 3025444ceed8SEric W. Biederman out: 3026c52a47acSAl Viro return -ENOENT; 3027444ceed8SEric W. Biederman } 3028444ceed8SEric W. Biederman 302900cd8dd3SAl Viro static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 303028a6d671SEric W. Biederman { 3031c52a47acSAl Viro int result = -ENOENT; 303228a6d671SEric W. Biederman struct task_struct *task; 303328a6d671SEric W. Biederman struct task_struct *leader = get_proc_task(dir); 303428a6d671SEric W. Biederman unsigned tid; 3035b488893aSPavel Emelyanov struct pid_namespace *ns; 303628a6d671SEric W. Biederman 303728a6d671SEric W. Biederman if (!leader) 303828a6d671SEric W. Biederman goto out_no_task; 303928a6d671SEric W. Biederman 3040dbcdb504SAlexey Dobriyan tid = name_to_int(&dentry->d_name); 304128a6d671SEric W. Biederman if (tid == ~0U) 304228a6d671SEric W. Biederman goto out; 304328a6d671SEric W. Biederman 3044b488893aSPavel Emelyanov ns = dentry->d_sb->s_fs_info; 304528a6d671SEric W. Biederman rcu_read_lock(); 3046b488893aSPavel Emelyanov task = find_task_by_pid_ns(tid, ns); 304728a6d671SEric W. Biederman if (task) 304828a6d671SEric W. Biederman get_task_struct(task); 304928a6d671SEric W. Biederman rcu_read_unlock(); 305028a6d671SEric W. Biederman if (!task) 305128a6d671SEric W. Biederman goto out; 3052bac0abd6SPavel Emelyanov if (!same_thread_group(leader, task)) 305328a6d671SEric W. Biederman goto out_drop_task; 305428a6d671SEric W. Biederman 3055444ceed8SEric W. Biederman result = proc_task_instantiate(dir, dentry, task, NULL); 305628a6d671SEric W. Biederman out_drop_task: 305728a6d671SEric W. Biederman put_task_struct(task); 305828a6d671SEric W. Biederman out: 305928a6d671SEric W. Biederman put_task_struct(leader); 306028a6d671SEric W. Biederman out_no_task: 3061c52a47acSAl Viro return ERR_PTR(result); 306228a6d671SEric W. Biederman } 306328a6d671SEric W. Biederman 306428a6d671SEric W. Biederman /* 30650bc58a91SEric W. Biederman * Find the first tid of a thread group to return to user space. 30660bc58a91SEric W. Biederman * 30670bc58a91SEric W. Biederman * Usually this is just the thread group leader, but if the users 30680bc58a91SEric W. Biederman * buffer was too small or there was a seek into the middle of the 30690bc58a91SEric W. Biederman * directory we have more work todo. 30700bc58a91SEric W. Biederman * 30710bc58a91SEric W. Biederman * In the case of a short read we start with find_task_by_pid. 30720bc58a91SEric W. Biederman * 30730bc58a91SEric W. Biederman * In the case of a seek we start with the leader and walk nr 30740bc58a91SEric W. Biederman * threads past it. 30750bc58a91SEric W. Biederman */ 30769f6e963fSOleg Nesterov static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos, 30779f6e963fSOleg Nesterov struct pid_namespace *ns) 30780bc58a91SEric W. Biederman { 3079d855a4b7SOleg Nesterov struct task_struct *pos, *task; 30809f6e963fSOleg Nesterov unsigned long nr = f_pos; 30819f6e963fSOleg Nesterov 30829f6e963fSOleg Nesterov if (nr != f_pos) /* 32bit overflow? */ 30839f6e963fSOleg Nesterov return NULL; 30840bc58a91SEric W. Biederman 3085cc288738SEric W. Biederman rcu_read_lock(); 3086d855a4b7SOleg Nesterov task = pid_task(pid, PIDTYPE_PID); 3087d855a4b7SOleg Nesterov if (!task) 3088d855a4b7SOleg Nesterov goto fail; 3089d855a4b7SOleg Nesterov 3090d855a4b7SOleg Nesterov /* Attempt to start with the tid of a thread */ 30919f6e963fSOleg Nesterov if (tid && nr) { 3092b488893aSPavel Emelyanov pos = find_task_by_pid_ns(tid, ns); 3093d855a4b7SOleg Nesterov if (pos && same_thread_group(pos, task)) 3094a872ff0cSOleg Nesterov goto found; 30950bc58a91SEric W. Biederman } 30960bc58a91SEric W. Biederman 30970bc58a91SEric W. Biederman /* If nr exceeds the number of threads there is nothing todo */ 30989f6e963fSOleg Nesterov if (nr >= get_nr_threads(task)) 3099c986c14aSOleg Nesterov goto fail; 3100a872ff0cSOleg Nesterov 3101a872ff0cSOleg Nesterov /* If we haven't found our starting place yet start 3102a872ff0cSOleg Nesterov * with the leader and walk nr threads forward. 3103a872ff0cSOleg Nesterov */ 3104d855a4b7SOleg Nesterov pos = task = task->group_leader; 3105c986c14aSOleg Nesterov do { 31069f6e963fSOleg Nesterov if (!nr--) 3107c986c14aSOleg Nesterov goto found; 3108d855a4b7SOleg Nesterov } while_each_thread(task, pos); 3109c986c14aSOleg Nesterov fail: 3110a872ff0cSOleg Nesterov pos = NULL; 3111a872ff0cSOleg Nesterov goto out; 3112a872ff0cSOleg Nesterov found: 3113a872ff0cSOleg Nesterov get_task_struct(pos); 3114a872ff0cSOleg Nesterov out: 3115cc288738SEric W. Biederman rcu_read_unlock(); 31160bc58a91SEric W. Biederman return pos; 31170bc58a91SEric W. Biederman } 31180bc58a91SEric W. Biederman 31190bc58a91SEric W. Biederman /* 31200bc58a91SEric W. Biederman * Find the next thread in the thread list. 31210bc58a91SEric W. Biederman * Return NULL if there is an error or no next thread. 31220bc58a91SEric W. Biederman * 31230bc58a91SEric W. Biederman * The reference to the input task_struct is released. 31240bc58a91SEric W. Biederman */ 31250bc58a91SEric W. Biederman static struct task_struct *next_tid(struct task_struct *start) 31260bc58a91SEric W. Biederman { 3127c1df7fb8SOleg Nesterov struct task_struct *pos = NULL; 3128cc288738SEric W. Biederman rcu_read_lock(); 3129c1df7fb8SOleg Nesterov if (pid_alive(start)) { 31300bc58a91SEric W. Biederman pos = next_thread(start); 3131c1df7fb8SOleg Nesterov if (thread_group_leader(pos)) 31320bc58a91SEric W. Biederman pos = NULL; 3133c1df7fb8SOleg Nesterov else 3134c1df7fb8SOleg Nesterov get_task_struct(pos); 3135c1df7fb8SOleg Nesterov } 3136cc288738SEric W. Biederman rcu_read_unlock(); 31370bc58a91SEric W. Biederman put_task_struct(start); 31380bc58a91SEric W. Biederman return pos; 31390bc58a91SEric W. Biederman } 31400bc58a91SEric W. Biederman 31411da177e4SLinus Torvalds /* for the /proc/TGID/task/ directories */ 3142f0c3b509SAl Viro static int proc_task_readdir(struct file *file, struct dir_context *ctx) 31431da177e4SLinus Torvalds { 3144d855a4b7SOleg Nesterov struct inode *inode = file_inode(file); 3145d855a4b7SOleg Nesterov struct task_struct *task; 3146b488893aSPavel Emelyanov struct pid_namespace *ns; 3147f0c3b509SAl Viro int tid; 31481da177e4SLinus Torvalds 3149d855a4b7SOleg Nesterov if (proc_inode_is_dead(inode)) 3150f0c3b509SAl Viro return -ENOENT; 31511da177e4SLinus Torvalds 3152f0c3b509SAl Viro if (!dir_emit_dots(file, ctx)) 3153d855a4b7SOleg Nesterov return 0; 31541da177e4SLinus Torvalds 31550bc58a91SEric W. Biederman /* f_version caches the tgid value that the last readdir call couldn't 31560bc58a91SEric W. Biederman * return. lseek aka telldir automagically resets f_version to 0. 31570bc58a91SEric W. Biederman */ 3158f0c3b509SAl Viro ns = file->f_dentry->d_sb->s_fs_info; 3159f0c3b509SAl Viro tid = (int)file->f_version; 3160f0c3b509SAl Viro file->f_version = 0; 3161d855a4b7SOleg Nesterov for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns); 31620bc58a91SEric W. Biederman task; 3163f0c3b509SAl Viro task = next_tid(task), ctx->pos++) { 3164f0c3b509SAl Viro char name[PROC_NUMBUF]; 3165f0c3b509SAl Viro int len; 3166b488893aSPavel Emelyanov tid = task_pid_nr_ns(task, ns); 3167f0c3b509SAl Viro len = snprintf(name, sizeof(name), "%d", tid); 3168f0c3b509SAl Viro if (!proc_fill_cache(file, ctx, name, len, 3169f0c3b509SAl Viro proc_task_instantiate, task, NULL)) { 31700bc58a91SEric W. Biederman /* returning this tgid failed, save it as the first 31710bc58a91SEric W. Biederman * pid for the next readir call */ 3172f0c3b509SAl Viro file->f_version = (u64)tid; 31730bc58a91SEric W. Biederman put_task_struct(task); 31741da177e4SLinus Torvalds break; 31750bc58a91SEric W. Biederman } 31761da177e4SLinus Torvalds } 3177d855a4b7SOleg Nesterov 3178f0c3b509SAl Viro return 0; 31791da177e4SLinus Torvalds } 31806e66b52bSEric W. Biederman 31816e66b52bSEric W. Biederman static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 31826e66b52bSEric W. Biederman { 31836e66b52bSEric W. Biederman struct inode *inode = dentry->d_inode; 318499f89551SEric W. Biederman struct task_struct *p = get_proc_task(inode); 31856e66b52bSEric W. Biederman generic_fillattr(inode, stat); 31866e66b52bSEric W. Biederman 318799f89551SEric W. Biederman if (p) { 318899f89551SEric W. Biederman stat->nlink += get_nr_threads(p); 318999f89551SEric W. Biederman put_task_struct(p); 31906e66b52bSEric W. Biederman } 31916e66b52bSEric W. Biederman 31926e66b52bSEric W. Biederman return 0; 31936e66b52bSEric W. Biederman } 319428a6d671SEric W. Biederman 3195c5ef1c42SArjan van de Ven static const struct inode_operations proc_task_inode_operations = { 319628a6d671SEric W. Biederman .lookup = proc_task_lookup, 319728a6d671SEric W. Biederman .getattr = proc_task_getattr, 319828a6d671SEric W. Biederman .setattr = proc_setattr, 31990499680aSVasiliy Kulikov .permission = proc_pid_permission, 320028a6d671SEric W. Biederman }; 320128a6d671SEric W. Biederman 320200977a59SArjan van de Ven static const struct file_operations proc_task_operations = { 320328a6d671SEric W. Biederman .read = generic_read_dir, 3204f0c3b509SAl Viro .iterate = proc_task_readdir, 32056038f373SArnd Bergmann .llseek = default_llseek, 320628a6d671SEric W. Biederman }; 3207