![Vasiliy Kulikov](/assets/img/avatar_default.png)
Add support for mount options to restrict access to /proc/PID/ directories. The default backward-compatible "relaxed" behaviour is left untouched. The first mount option is called "hidepid" and its value defines how much info about processes we want to be available for non-owners: hidepid=0 (default) means the old behavior - anybody may read all world-readable /proc/PID/* files. hidepid=1 means users may not access any /proc/<pid>/ directories, but their own. Sensitive files like cmdline, sched*, status are now protected against other users. As permission checking done in proc_pid_permission() and files' permissions are left untouched, programs expecting specific files' modes are not confused. hidepid=2 means hidepid=1 plus all /proc/PID/ will be invisible to other users. It doesn't mean that it hides whether a process exists (it can be learned by other means, e.g. by kill -0 $PID), but it hides process' euid and egid. It compicates intruder's task of gathering info about running processes, whether some daemon runs with elevated privileges, whether another user runs some sensitive program, whether other users run any program at all, etc. gid=XXX defines a group that will be able to gather all processes' info (as in hidepid=0 mode). This group should be used instead of putting nonroot user in sudoers file or something. However, untrusted users (like daemons, etc.) which are not supposed to monitor the tasks in the whole system should not be added to the group. hidepid=1 or higher is designed to restrict access to procfs files, which might reveal some sensitive private information like precise keystrokes timings: http://www.openwall.com/lists/oss-security/2011/11/05/3 hidepid=1/2 doesn't break monitoring userspace tools. ps, top, pgrep, and conky gracefully handle EPERM/ENOENT and behave as if the current user is the only user running processes. pstree shows the process subtree which contains "pstree" process. Note: the patch doesn't deal with setuid/setgid issues of keeping preopened descriptors of procfs files (like https://lkml.org/lkml/2011/2/7/368). We rely on that the leaked information like the scheduling counters of setuid apps doesn't threaten anybody's privacy - only the user started the setuid program may read the counters. Signed-off-by: Vasiliy Kulikov <segoon@openwall.com> Cc: Alexey Dobriyan <adobriyan@gmail.com> Cc: Al Viro <viro@zeniv.linux.org.uk> Cc: Randy Dunlap <rdunlap@xenotime.net> Cc: "H. Peter Anvin" <hpa@zytor.com> Cc: Greg KH <greg@kroah.com> Cc: Theodore Tso <tytso@MIT.EDU> Cc: Alan Cox <alan@lxorguk.ukuu.org.uk> Cc: James Morris <jmorris@namei.org> Cc: Oleg Nesterov <oleg@redhat.com> Cc: Hugh Dickins <hughd@google.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
3763 lines
88 KiB
C
3763 lines
88 KiB
C
/*
|
|
* linux/fs/proc/base.c
|
|
*
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*
|
|
* proc base directory handling functions
|
|
*
|
|
* 1999, Al Viro. Rewritten. Now it covers the whole per-process part.
|
|
* Instead of using magical inumbers to determine the kind of object
|
|
* we allocate and fill in-core inodes upon lookup. They don't even
|
|
* go into icache. We cache the reference to task_struct upon lookup too.
|
|
* Eventually it should become a filesystem in its own. We don't use the
|
|
* rest of procfs anymore.
|
|
*
|
|
*
|
|
* Changelog:
|
|
* 17-Jan-2005
|
|
* Allan Bezerra
|
|
* Bruna Moreira <bruna.moreira@indt.org.br>
|
|
* Edjard Mota <edjard.mota@indt.org.br>
|
|
* Ilias Biris <ilias.biris@indt.org.br>
|
|
* Mauricio Lin <mauricio.lin@indt.org.br>
|
|
*
|
|
* Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
|
|
*
|
|
* A new process specific entry (smaps) included in /proc. It shows the
|
|
* size of rss for each memory area. The maps entry lacks information
|
|
* about physical memory size (rss) for each mapped file, i.e.,
|
|
* rss information for executables and library files.
|
|
* This additional information is useful for any tools that need to know
|
|
* about physical memory consumption for a process specific library.
|
|
*
|
|
* Changelog:
|
|
* 21-Feb-2005
|
|
* Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
|
|
* Pud inclusion in the page table walking.
|
|
*
|
|
* ChangeLog:
|
|
* 10-Mar-2005
|
|
* 10LE Instituto Nokia de Tecnologia - INdT:
|
|
* A better way to walks through the page table as suggested by Hugh Dickins.
|
|
*
|
|
* Simo Piiroinen <simo.piiroinen@nokia.com>:
|
|
* Smaps information related to shared, private, clean and dirty pages.
|
|
*
|
|
* Paul Mundt <paul.mundt@nokia.com>:
|
|
* Overall revision about smaps.
|
|
*/
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/time.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/task_io_accounting_ops.h>
|
|
#include <linux/init.h>
|
|
#include <linux/capability.h>
|
|
#include <linux/file.h>
|
|
#include <linux/fdtable.h>
|
|
#include <linux/string.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/namei.h>
|
|
#include <linux/mnt_namespace.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/swap.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <linux/kallsyms.h>
|
|
#include <linux/stacktrace.h>
|
|
#include <linux/resource.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/security.h>
|
|
#include <linux/ptrace.h>
|
|
#include <linux/tracehook.h>
|
|
#include <linux/cgroup.h>
|
|
#include <linux/cpuset.h>
|
|
#include <linux/audit.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/nsproxy.h>
|
|
#include <linux/oom.h>
|
|
#include <linux/elf.h>
|
|
#include <linux/pid_namespace.h>
|
|
#include <linux/fs_struct.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/flex_array.h>
|
|
#ifdef CONFIG_HARDWALL
|
|
#include <asm/hardwall.h>
|
|
#endif
|
|
#include <trace/events/oom.h>
|
|
#include "internal.h"
|
|
|
|
/* NOTE:
|
|
* Implementing inode permission operations in /proc is almost
|
|
* certainly an error. Permission checks need to happen during
|
|
* each system call not at open time. The reason is that most of
|
|
* what we wish to check for permissions in /proc varies at runtime.
|
|
*
|
|
* The classic example of a problem is opening file descriptors
|
|
* in /proc for a task before it execs a suid executable.
|
|
*/
|
|
|
|
struct pid_entry {
|
|
char *name;
|
|
int len;
|
|
umode_t mode;
|
|
const struct inode_operations *iop;
|
|
const struct file_operations *fop;
|
|
union proc_op op;
|
|
};
|
|
|
|
#define NOD(NAME, MODE, IOP, FOP, OP) { \
|
|
.name = (NAME), \
|
|
.len = sizeof(NAME) - 1, \
|
|
.mode = MODE, \
|
|
.iop = IOP, \
|
|
.fop = FOP, \
|
|
.op = OP, \
|
|
}
|
|
|
|
#define DIR(NAME, MODE, iops, fops) \
|
|
NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} )
|
|
#define LNK(NAME, get_link) \
|
|
NOD(NAME, (S_IFLNK|S_IRWXUGO), \
|
|
&proc_pid_link_inode_operations, NULL, \
|
|
{ .proc_get_link = get_link } )
|
|
#define REG(NAME, MODE, fops) \
|
|
NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {})
|
|
#define INF(NAME, MODE, read) \
|
|
NOD(NAME, (S_IFREG|(MODE)), \
|
|
NULL, &proc_info_file_operations, \
|
|
{ .proc_read = read } )
|
|
#define ONE(NAME, MODE, show) \
|
|
NOD(NAME, (S_IFREG|(MODE)), \
|
|
NULL, &proc_single_file_operations, \
|
|
{ .proc_show = show } )
|
|
|
|
static int proc_fd_permission(struct inode *inode, int mask);
|
|
|
|
/*
|
|
* Count the number of hardlinks for the pid_entry table, excluding the .
|
|
* and .. links.
|
|
*/
|
|
static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
|
|
unsigned int n)
|
|
{
|
|
unsigned int i;
|
|
unsigned int count;
|
|
|
|
count = 0;
|
|
for (i = 0; i < n; ++i) {
|
|
if (S_ISDIR(entries[i].mode))
|
|
++count;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static int get_task_root(struct task_struct *task, struct path *root)
|
|
{
|
|
int result = -ENOENT;
|
|
|
|
task_lock(task);
|
|
if (task->fs) {
|
|
get_fs_root(task->fs, root);
|
|
result = 0;
|
|
}
|
|
task_unlock(task);
|
|
return result;
|
|
}
|
|
|
|
static int proc_cwd_link(struct dentry *dentry, struct path *path)
|
|
{
|
|
struct task_struct *task = get_proc_task(dentry->d_inode);
|
|
int result = -ENOENT;
|
|
|
|
if (task) {
|
|
task_lock(task);
|
|
if (task->fs) {
|
|
get_fs_pwd(task->fs, path);
|
|
result = 0;
|
|
}
|
|
task_unlock(task);
|
|
put_task_struct(task);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static int proc_root_link(struct dentry *dentry, struct path *path)
|
|
{
|
|
struct task_struct *task = get_proc_task(dentry->d_inode);
|
|
int result = -ENOENT;
|
|
|
|
if (task) {
|
|
result = get_task_root(task, path);
|
|
put_task_struct(task);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static struct mm_struct *__check_mem_permission(struct task_struct *task)
|
|
{
|
|
struct mm_struct *mm;
|
|
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
/*
|
|
* A task can always look at itself, in case it chooses
|
|
* to use system calls instead of load instructions.
|
|
*/
|
|
if (task == current)
|
|
return mm;
|
|
|
|
/*
|
|
* If current is actively ptrace'ing, and would also be
|
|
* permitted to freshly attach with ptrace now, permit it.
|
|
*/
|
|
if (task_is_stopped_or_traced(task)) {
|
|
int match;
|
|
rcu_read_lock();
|
|
match = (ptrace_parent(task) == current);
|
|
rcu_read_unlock();
|
|
if (match && ptrace_may_access(task, PTRACE_MODE_ATTACH))
|
|
return mm;
|
|
}
|
|
|
|
/*
|
|
* No one else is allowed.
|
|
*/
|
|
mmput(mm);
|
|
return ERR_PTR(-EPERM);
|
|
}
|
|
|
|
/*
|
|
* If current may access user memory in @task return a reference to the
|
|
* corresponding mm, otherwise ERR_PTR.
|
|
*/
|
|
static struct mm_struct *check_mem_permission(struct task_struct *task)
|
|
{
|
|
struct mm_struct *mm;
|
|
int err;
|
|
|
|
/*
|
|
* Avoid racing if task exec's as we might get a new mm but validate
|
|
* against old credentials.
|
|
*/
|
|
err = mutex_lock_killable(&task->signal->cred_guard_mutex);
|
|
if (err)
|
|
return ERR_PTR(err);
|
|
|
|
mm = __check_mem_permission(task);
|
|
mutex_unlock(&task->signal->cred_guard_mutex);
|
|
|
|
return mm;
|
|
}
|
|
|
|
struct mm_struct *mm_for_maps(struct task_struct *task)
|
|
{
|
|
struct mm_struct *mm;
|
|
int err;
|
|
|
|
err = mutex_lock_killable(&task->signal->cred_guard_mutex);
|
|
if (err)
|
|
return ERR_PTR(err);
|
|
|
|
mm = get_task_mm(task);
|
|
if (mm && mm != current->mm &&
|
|
!ptrace_may_access(task, PTRACE_MODE_READ)) {
|
|
mmput(mm);
|
|
mm = ERR_PTR(-EACCES);
|
|
}
|
|
mutex_unlock(&task->signal->cred_guard_mutex);
|
|
|
|
return mm;
|
|
}
|
|
|
|
static int proc_pid_cmdline(struct task_struct *task, char * buffer)
|
|
{
|
|
int res = 0;
|
|
unsigned int len;
|
|
struct mm_struct *mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out;
|
|
if (!mm->arg_end)
|
|
goto out_mm; /* Shh! No looking before we're done */
|
|
|
|
len = mm->arg_end - mm->arg_start;
|
|
|
|
if (len > PAGE_SIZE)
|
|
len = PAGE_SIZE;
|
|
|
|
res = access_process_vm(task, mm->arg_start, buffer, len, 0);
|
|
|
|
// If the nul at the end of args has been overwritten, then
|
|
// assume application is using setproctitle(3).
|
|
if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
|
|
len = strnlen(buffer, res);
|
|
if (len < res) {
|
|
res = len;
|
|
} else {
|
|
len = mm->env_end - mm->env_start;
|
|
if (len > PAGE_SIZE - res)
|
|
len = PAGE_SIZE - res;
|
|
res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
|
|
res = strnlen(buffer, res);
|
|
}
|
|
}
|
|
out_mm:
|
|
mmput(mm);
|
|
out:
|
|
return res;
|
|
}
|
|
|
|
static int proc_pid_auxv(struct task_struct *task, char *buffer)
|
|
{
|
|
struct mm_struct *mm = mm_for_maps(task);
|
|
int res = PTR_ERR(mm);
|
|
if (mm && !IS_ERR(mm)) {
|
|
unsigned int nwords = 0;
|
|
do {
|
|
nwords += 2;
|
|
} while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
|
|
res = nwords * sizeof(mm->saved_auxv[0]);
|
|
if (res > PAGE_SIZE)
|
|
res = PAGE_SIZE;
|
|
memcpy(buffer, mm->saved_auxv, res);
|
|
mmput(mm);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
/*
|
|
* Provides a wchan file via kallsyms in a proper one-value-per-file format.
|
|
* Returns the resolved symbol. If that fails, simply return the address.
|
|
*/
|
|
static int proc_pid_wchan(struct task_struct *task, char *buffer)
|
|
{
|
|
unsigned long wchan;
|
|
char symname[KSYM_NAME_LEN];
|
|
|
|
wchan = get_wchan(task);
|
|
|
|
if (lookup_symbol_name(wchan, symname) < 0)
|
|
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
|
return 0;
|
|
else
|
|
return sprintf(buffer, "%lu", wchan);
|
|
else
|
|
return sprintf(buffer, "%s", symname);
|
|
}
|
|
#endif /* CONFIG_KALLSYMS */
|
|
|
|
static int lock_trace(struct task_struct *task)
|
|
{
|
|
int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
|
|
if (err)
|
|
return err;
|
|
if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
|
|
mutex_unlock(&task->signal->cred_guard_mutex);
|
|
return -EPERM;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void unlock_trace(struct task_struct *task)
|
|
{
|
|
mutex_unlock(&task->signal->cred_guard_mutex);
|
|
}
|
|
|
|
#ifdef CONFIG_STACKTRACE
|
|
|
|
#define MAX_STACK_TRACE_DEPTH 64
|
|
|
|
static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
struct stack_trace trace;
|
|
unsigned long *entries;
|
|
int err;
|
|
int i;
|
|
|
|
entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL);
|
|
if (!entries)
|
|
return -ENOMEM;
|
|
|
|
trace.nr_entries = 0;
|
|
trace.max_entries = MAX_STACK_TRACE_DEPTH;
|
|
trace.entries = entries;
|
|
trace.skip = 0;
|
|
|
|
err = lock_trace(task);
|
|
if (!err) {
|
|
save_stack_trace_tsk(task, &trace);
|
|
|
|
for (i = 0; i < trace.nr_entries; i++) {
|
|
seq_printf(m, "[<%pK>] %pS\n",
|
|
(void *)entries[i], (void *)entries[i]);
|
|
}
|
|
unlock_trace(task);
|
|
}
|
|
kfree(entries);
|
|
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
/*
|
|
* Provides /proc/PID/schedstat
|
|
*/
|
|
static int proc_pid_schedstat(struct task_struct *task, char *buffer)
|
|
{
|
|
return sprintf(buffer, "%llu %llu %lu\n",
|
|
(unsigned long long)task->se.sum_exec_runtime,
|
|
(unsigned long long)task->sched_info.run_delay,
|
|
task->sched_info.pcount);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_LATENCYTOP
|
|
static int lstats_show_proc(struct seq_file *m, void *v)
|
|
{
|
|
int i;
|
|
struct inode *inode = m->private;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
seq_puts(m, "Latency Top version : v0.1\n");
|
|
for (i = 0; i < 32; i++) {
|
|
struct latency_record *lr = &task->latency_record[i];
|
|
if (lr->backtrace[0]) {
|
|
int q;
|
|
seq_printf(m, "%i %li %li",
|
|
lr->count, lr->time, lr->max);
|
|
for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
|
|
unsigned long bt = lr->backtrace[q];
|
|
if (!bt)
|
|
break;
|
|
if (bt == ULONG_MAX)
|
|
break;
|
|
seq_printf(m, " %ps", (void *)bt);
|
|
}
|
|
seq_putc(m, '\n');
|
|
}
|
|
|
|
}
|
|
put_task_struct(task);
|
|
return 0;
|
|
}
|
|
|
|
static int lstats_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, lstats_show_proc, inode);
|
|
}
|
|
|
|
static ssize_t lstats_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *offs)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
clear_all_latency_tracing(task);
|
|
put_task_struct(task);
|
|
|
|
return count;
|
|
}
|
|
|
|
static const struct file_operations proc_lstats_operations = {
|
|
.open = lstats_open,
|
|
.read = seq_read,
|
|
.write = lstats_write,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
#endif
|
|
|
|
static int proc_oom_score(struct task_struct *task, char *buffer)
|
|
{
|
|
unsigned long points = 0;
|
|
|
|
read_lock(&tasklist_lock);
|
|
if (pid_alive(task))
|
|
points = oom_badness(task, NULL, NULL,
|
|
totalram_pages + total_swap_pages);
|
|
read_unlock(&tasklist_lock);
|
|
return sprintf(buffer, "%lu\n", points);
|
|
}
|
|
|
|
struct limit_names {
|
|
char *name;
|
|
char *unit;
|
|
};
|
|
|
|
static const struct limit_names lnames[RLIM_NLIMITS] = {
|
|
[RLIMIT_CPU] = {"Max cpu time", "seconds"},
|
|
[RLIMIT_FSIZE] = {"Max file size", "bytes"},
|
|
[RLIMIT_DATA] = {"Max data size", "bytes"},
|
|
[RLIMIT_STACK] = {"Max stack size", "bytes"},
|
|
[RLIMIT_CORE] = {"Max core file size", "bytes"},
|
|
[RLIMIT_RSS] = {"Max resident set", "bytes"},
|
|
[RLIMIT_NPROC] = {"Max processes", "processes"},
|
|
[RLIMIT_NOFILE] = {"Max open files", "files"},
|
|
[RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
|
|
[RLIMIT_AS] = {"Max address space", "bytes"},
|
|
[RLIMIT_LOCKS] = {"Max file locks", "locks"},
|
|
[RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
|
|
[RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
|
|
[RLIMIT_NICE] = {"Max nice priority", NULL},
|
|
[RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
|
|
[RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
|
|
};
|
|
|
|
/* Display limits for a process */
|
|
static int proc_pid_limits(struct task_struct *task, char *buffer)
|
|
{
|
|
unsigned int i;
|
|
int count = 0;
|
|
unsigned long flags;
|
|
char *bufptr = buffer;
|
|
|
|
struct rlimit rlim[RLIM_NLIMITS];
|
|
|
|
if (!lock_task_sighand(task, &flags))
|
|
return 0;
|
|
memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
|
|
unlock_task_sighand(task, &flags);
|
|
|
|
/*
|
|
* print the file header
|
|
*/
|
|
count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n",
|
|
"Limit", "Soft Limit", "Hard Limit", "Units");
|
|
|
|
for (i = 0; i < RLIM_NLIMITS; i++) {
|
|
if (rlim[i].rlim_cur == RLIM_INFINITY)
|
|
count += sprintf(&bufptr[count], "%-25s %-20s ",
|
|
lnames[i].name, "unlimited");
|
|
else
|
|
count += sprintf(&bufptr[count], "%-25s %-20lu ",
|
|
lnames[i].name, rlim[i].rlim_cur);
|
|
|
|
if (rlim[i].rlim_max == RLIM_INFINITY)
|
|
count += sprintf(&bufptr[count], "%-20s ", "unlimited");
|
|
else
|
|
count += sprintf(&bufptr[count], "%-20lu ",
|
|
rlim[i].rlim_max);
|
|
|
|
if (lnames[i].unit)
|
|
count += sprintf(&bufptr[count], "%-10s\n",
|
|
lnames[i].unit);
|
|
else
|
|
count += sprintf(&bufptr[count], "\n");
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
|
|
static int proc_pid_syscall(struct task_struct *task, char *buffer)
|
|
{
|
|
long nr;
|
|
unsigned long args[6], sp, pc;
|
|
int res = lock_trace(task);
|
|
if (res)
|
|
return res;
|
|
|
|
if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
|
|
res = sprintf(buffer, "running\n");
|
|
else if (nr < 0)
|
|
res = sprintf(buffer, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
|
|
else
|
|
res = sprintf(buffer,
|
|
"%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
|
|
nr,
|
|
args[0], args[1], args[2], args[3], args[4], args[5],
|
|
sp, pc);
|
|
unlock_trace(task);
|
|
return res;
|
|
}
|
|
#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
|
|
|
|
/************************************************************************/
|
|
/* Here the fs part begins */
|
|
/************************************************************************/
|
|
|
|
/* permission checks */
|
|
static int proc_fd_access_allowed(struct inode *inode)
|
|
{
|
|
struct task_struct *task;
|
|
int allowed = 0;
|
|
/* Allow access to a task's file descriptors if it is us or we
|
|
* may use ptrace attach to the process and find out that
|
|
* information.
|
|
*/
|
|
task = get_proc_task(inode);
|
|
if (task) {
|
|
allowed = ptrace_may_access(task, PTRACE_MODE_READ);
|
|
put_task_struct(task);
|
|
}
|
|
return allowed;
|
|
}
|
|
|
|
int proc_setattr(struct dentry *dentry, struct iattr *attr)
|
|
{
|
|
int error;
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
if (attr->ia_valid & ATTR_MODE)
|
|
return -EPERM;
|
|
|
|
error = inode_change_ok(inode, attr);
|
|
if (error)
|
|
return error;
|
|
|
|
if ((attr->ia_valid & ATTR_SIZE) &&
|
|
attr->ia_size != i_size_read(inode)) {
|
|
error = vmtruncate(inode, attr->ia_size);
|
|
if (error)
|
|
return error;
|
|
}
|
|
|
|
setattr_copy(inode, attr);
|
|
mark_inode_dirty(inode);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* May current process learn task's sched/cmdline info (for hide_pid_min=1)
|
|
* or euid/egid (for hide_pid_min=2)?
|
|
*/
|
|
static bool has_pid_permissions(struct pid_namespace *pid,
|
|
struct task_struct *task,
|
|
int hide_pid_min)
|
|
{
|
|
if (pid->hide_pid < hide_pid_min)
|
|
return true;
|
|
if (in_group_p(pid->pid_gid))
|
|
return true;
|
|
return ptrace_may_access(task, PTRACE_MODE_READ);
|
|
}
|
|
|
|
|
|
static int proc_pid_permission(struct inode *inode, int mask)
|
|
{
|
|
struct pid_namespace *pid = inode->i_sb->s_fs_info;
|
|
struct task_struct *task;
|
|
bool has_perms;
|
|
|
|
task = get_proc_task(inode);
|
|
has_perms = has_pid_permissions(pid, task, 1);
|
|
put_task_struct(task);
|
|
|
|
if (!has_perms) {
|
|
if (pid->hide_pid == 2) {
|
|
/*
|
|
* Let's make getdents(), stat(), and open()
|
|
* consistent with each other. If a process
|
|
* may not stat() a file, it shouldn't be seen
|
|
* in procfs at all.
|
|
*/
|
|
return -ENOENT;
|
|
}
|
|
|
|
return -EPERM;
|
|
}
|
|
return generic_permission(inode, mask);
|
|
}
|
|
|
|
|
|
|
|
static const struct inode_operations proc_def_inode_operations = {
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
#define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */
|
|
|
|
static ssize_t proc_info_read(struct file * file, char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
unsigned long page;
|
|
ssize_t length;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
|
|
length = -ESRCH;
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
if (count > PROC_BLOCK_SIZE)
|
|
count = PROC_BLOCK_SIZE;
|
|
|
|
length = -ENOMEM;
|
|
if (!(page = __get_free_page(GFP_TEMPORARY)))
|
|
goto out;
|
|
|
|
length = PROC_I(inode)->op.proc_read(task, (char*)page);
|
|
|
|
if (length >= 0)
|
|
length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
|
|
free_page(page);
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return length;
|
|
}
|
|
|
|
static const struct file_operations proc_info_file_operations = {
|
|
.read = proc_info_read,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static int proc_single_show(struct seq_file *m, void *v)
|
|
{
|
|
struct inode *inode = m->private;
|
|
struct pid_namespace *ns;
|
|
struct pid *pid;
|
|
struct task_struct *task;
|
|
int ret;
|
|
|
|
ns = inode->i_sb->s_fs_info;
|
|
pid = proc_pid(inode);
|
|
task = get_pid_task(pid, PIDTYPE_PID);
|
|
if (!task)
|
|
return -ESRCH;
|
|
|
|
ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);
|
|
|
|
put_task_struct(task);
|
|
return ret;
|
|
}
|
|
|
|
static int proc_single_open(struct inode *inode, struct file *filp)
|
|
{
|
|
return single_open(filp, proc_single_show, inode);
|
|
}
|
|
|
|
static const struct file_operations proc_single_file_operations = {
|
|
.open = proc_single_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mem_open(struct inode* inode, struct file* file)
|
|
{
|
|
file->private_data = (void*)((long)current->self_exec_id);
|
|
/* OK to pass negative loff_t, we can catch out-of-range */
|
|
file->f_mode |= FMODE_UNSIGNED_OFFSET;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t mem_read(struct file * file, char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
|
|
char *page;
|
|
unsigned long src = *ppos;
|
|
int ret = -ESRCH;
|
|
struct mm_struct *mm;
|
|
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
ret = -ENOMEM;
|
|
page = (char *)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
goto out;
|
|
|
|
mm = check_mem_permission(task);
|
|
ret = PTR_ERR(mm);
|
|
if (IS_ERR(mm))
|
|
goto out_free;
|
|
|
|
ret = -EIO;
|
|
|
|
if (file->private_data != (void*)((long)current->self_exec_id))
|
|
goto out_put;
|
|
|
|
ret = 0;
|
|
|
|
while (count > 0) {
|
|
int this_len, retval;
|
|
|
|
this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
|
|
retval = access_remote_vm(mm, src, page, this_len, 0);
|
|
if (!retval) {
|
|
if (!ret)
|
|
ret = -EIO;
|
|
break;
|
|
}
|
|
|
|
if (copy_to_user(buf, page, retval)) {
|
|
ret = -EFAULT;
|
|
break;
|
|
}
|
|
|
|
ret += retval;
|
|
src += retval;
|
|
buf += retval;
|
|
count -= retval;
|
|
}
|
|
*ppos = src;
|
|
|
|
out_put:
|
|
mmput(mm);
|
|
out_free:
|
|
free_page((unsigned long) page);
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t mem_write(struct file * file, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
int copied;
|
|
char *page;
|
|
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
|
|
unsigned long dst = *ppos;
|
|
struct mm_struct *mm;
|
|
|
|
copied = -ESRCH;
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
copied = -ENOMEM;
|
|
page = (char *)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
goto out_task;
|
|
|
|
mm = check_mem_permission(task);
|
|
copied = PTR_ERR(mm);
|
|
if (IS_ERR(mm))
|
|
goto out_free;
|
|
|
|
copied = -EIO;
|
|
if (file->private_data != (void *)((long)current->self_exec_id))
|
|
goto out_mm;
|
|
|
|
copied = 0;
|
|
while (count > 0) {
|
|
int this_len, retval;
|
|
|
|
this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
|
|
if (copy_from_user(page, buf, this_len)) {
|
|
copied = -EFAULT;
|
|
break;
|
|
}
|
|
retval = access_remote_vm(mm, dst, page, this_len, 1);
|
|
if (!retval) {
|
|
if (!copied)
|
|
copied = -EIO;
|
|
break;
|
|
}
|
|
copied += retval;
|
|
buf += retval;
|
|
dst += retval;
|
|
count -= retval;
|
|
}
|
|
*ppos = dst;
|
|
|
|
out_mm:
|
|
mmput(mm);
|
|
out_free:
|
|
free_page((unsigned long) page);
|
|
out_task:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return copied;
|
|
}
|
|
|
|
loff_t mem_lseek(struct file *file, loff_t offset, int orig)
|
|
{
|
|
switch (orig) {
|
|
case 0:
|
|
file->f_pos = offset;
|
|
break;
|
|
case 1:
|
|
file->f_pos += offset;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
force_successful_syscall_return();
|
|
return file->f_pos;
|
|
}
|
|
|
|
static const struct file_operations proc_mem_operations = {
|
|
.llseek = mem_lseek,
|
|
.read = mem_read,
|
|
.write = mem_write,
|
|
.open = mem_open,
|
|
};
|
|
|
|
static ssize_t environ_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
|
|
char *page;
|
|
unsigned long src = *ppos;
|
|
int ret = -ESRCH;
|
|
struct mm_struct *mm;
|
|
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
ret = -ENOMEM;
|
|
page = (char *)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
goto out;
|
|
|
|
|
|
mm = mm_for_maps(task);
|
|
ret = PTR_ERR(mm);
|
|
if (!mm || IS_ERR(mm))
|
|
goto out_free;
|
|
|
|
ret = 0;
|
|
while (count > 0) {
|
|
int this_len, retval, max_len;
|
|
|
|
this_len = mm->env_end - (mm->env_start + src);
|
|
|
|
if (this_len <= 0)
|
|
break;
|
|
|
|
max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
|
|
this_len = (this_len > max_len) ? max_len : this_len;
|
|
|
|
retval = access_process_vm(task, (mm->env_start + src),
|
|
page, this_len, 0);
|
|
|
|
if (retval <= 0) {
|
|
ret = retval;
|
|
break;
|
|
}
|
|
|
|
if (copy_to_user(buf, page, retval)) {
|
|
ret = -EFAULT;
|
|
break;
|
|
}
|
|
|
|
ret += retval;
|
|
src += retval;
|
|
buf += retval;
|
|
count -= retval;
|
|
}
|
|
*ppos = src;
|
|
|
|
mmput(mm);
|
|
out_free:
|
|
free_page((unsigned long) page);
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_environ_operations = {
|
|
.read = environ_read,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static ssize_t oom_adjust_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
|
|
char buffer[PROC_NUMBUF];
|
|
size_t len;
|
|
int oom_adjust = OOM_DISABLE;
|
|
unsigned long flags;
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
|
|
if (lock_task_sighand(task, &flags)) {
|
|
oom_adjust = task->signal->oom_adj;
|
|
unlock_task_sighand(task, &flags);
|
|
}
|
|
|
|
put_task_struct(task);
|
|
|
|
len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
|
|
|
|
return simple_read_from_buffer(buf, count, ppos, buffer, len);
|
|
}
|
|
|
|
static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task;
|
|
char buffer[PROC_NUMBUF];
|
|
int oom_adjust;
|
|
unsigned long flags;
|
|
int err;
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (count > sizeof(buffer) - 1)
|
|
count = sizeof(buffer) - 1;
|
|
if (copy_from_user(buffer, buf, count)) {
|
|
err = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
err = kstrtoint(strstrip(buffer), 0, &oom_adjust);
|
|
if (err)
|
|
goto out;
|
|
if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) &&
|
|
oom_adjust != OOM_DISABLE) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
task = get_proc_task(file->f_path.dentry->d_inode);
|
|
if (!task) {
|
|
err = -ESRCH;
|
|
goto out;
|
|
}
|
|
|
|
task_lock(task);
|
|
if (!task->mm) {
|
|
err = -EINVAL;
|
|
goto err_task_lock;
|
|
}
|
|
|
|
if (!lock_task_sighand(task, &flags)) {
|
|
err = -ESRCH;
|
|
goto err_task_lock;
|
|
}
|
|
|
|
if (oom_adjust < task->signal->oom_adj && !capable(CAP_SYS_RESOURCE)) {
|
|
err = -EACCES;
|
|
goto err_sighand;
|
|
}
|
|
|
|
/*
|
|
* Warn that /proc/pid/oom_adj is deprecated, see
|
|
* Documentation/feature-removal-schedule.txt.
|
|
*/
|
|
printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
|
|
current->comm, task_pid_nr(current), task_pid_nr(task),
|
|
task_pid_nr(task));
|
|
task->signal->oom_adj = oom_adjust;
|
|
/*
|
|
* Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
|
|
* value is always attainable.
|
|
*/
|
|
if (task->signal->oom_adj == OOM_ADJUST_MAX)
|
|
task->signal->oom_score_adj = OOM_SCORE_ADJ_MAX;
|
|
else
|
|
task->signal->oom_score_adj = (oom_adjust * OOM_SCORE_ADJ_MAX) /
|
|
-OOM_DISABLE;
|
|
trace_oom_score_adj_update(task);
|
|
err_sighand:
|
|
unlock_task_sighand(task, &flags);
|
|
err_task_lock:
|
|
task_unlock(task);
|
|
put_task_struct(task);
|
|
out:
|
|
return err < 0 ? err : count;
|
|
}
|
|
|
|
static const struct file_operations proc_oom_adjust_operations = {
|
|
.read = oom_adjust_read,
|
|
.write = oom_adjust_write,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
|
|
char buffer[PROC_NUMBUF];
|
|
int oom_score_adj = OOM_SCORE_ADJ_MIN;
|
|
unsigned long flags;
|
|
size_t len;
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
if (lock_task_sighand(task, &flags)) {
|
|
oom_score_adj = task->signal->oom_score_adj;
|
|
unlock_task_sighand(task, &flags);
|
|
}
|
|
put_task_struct(task);
|
|
len = snprintf(buffer, sizeof(buffer), "%d\n", oom_score_adj);
|
|
return simple_read_from_buffer(buf, count, ppos, buffer, len);
|
|
}
|
|
|
|
static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task;
|
|
char buffer[PROC_NUMBUF];
|
|
unsigned long flags;
|
|
int oom_score_adj;
|
|
int err;
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (count > sizeof(buffer) - 1)
|
|
count = sizeof(buffer) - 1;
|
|
if (copy_from_user(buffer, buf, count)) {
|
|
err = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
err = kstrtoint(strstrip(buffer), 0, &oom_score_adj);
|
|
if (err)
|
|
goto out;
|
|
if (oom_score_adj < OOM_SCORE_ADJ_MIN ||
|
|
oom_score_adj > OOM_SCORE_ADJ_MAX) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
task = get_proc_task(file->f_path.dentry->d_inode);
|
|
if (!task) {
|
|
err = -ESRCH;
|
|
goto out;
|
|
}
|
|
|
|
task_lock(task);
|
|
if (!task->mm) {
|
|
err = -EINVAL;
|
|
goto err_task_lock;
|
|
}
|
|
|
|
if (!lock_task_sighand(task, &flags)) {
|
|
err = -ESRCH;
|
|
goto err_task_lock;
|
|
}
|
|
|
|
if (oom_score_adj < task->signal->oom_score_adj_min &&
|
|
!capable(CAP_SYS_RESOURCE)) {
|
|
err = -EACCES;
|
|
goto err_sighand;
|
|
}
|
|
|
|
task->signal->oom_score_adj = oom_score_adj;
|
|
if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
|
|
task->signal->oom_score_adj_min = oom_score_adj;
|
|
trace_oom_score_adj_update(task);
|
|
/*
|
|
* Scale /proc/pid/oom_adj appropriately ensuring that OOM_DISABLE is
|
|
* always attainable.
|
|
*/
|
|
if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
|
|
task->signal->oom_adj = OOM_DISABLE;
|
|
else
|
|
task->signal->oom_adj = (oom_score_adj * OOM_ADJUST_MAX) /
|
|
OOM_SCORE_ADJ_MAX;
|
|
err_sighand:
|
|
unlock_task_sighand(task, &flags);
|
|
err_task_lock:
|
|
task_unlock(task);
|
|
put_task_struct(task);
|
|
out:
|
|
return err < 0 ? err : count;
|
|
}
|
|
|
|
static const struct file_operations proc_oom_score_adj_operations = {
|
|
.read = oom_score_adj_read,
|
|
.write = oom_score_adj_write,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
#ifdef CONFIG_AUDITSYSCALL
|
|
#define TMPBUFLEN 21
|
|
static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
ssize_t length;
|
|
char tmpbuf[TMPBUFLEN];
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
|
|
audit_get_loginuid(task));
|
|
put_task_struct(task);
|
|
return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
|
|
}
|
|
|
|
static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
char *page, *tmp;
|
|
ssize_t length;
|
|
uid_t loginuid;
|
|
|
|
if (!capable(CAP_AUDIT_CONTROL))
|
|
return -EPERM;
|
|
|
|
rcu_read_lock();
|
|
if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {
|
|
rcu_read_unlock();
|
|
return -EPERM;
|
|
}
|
|
rcu_read_unlock();
|
|
|
|
if (count >= PAGE_SIZE)
|
|
count = PAGE_SIZE - 1;
|
|
|
|
if (*ppos != 0) {
|
|
/* No partial writes. */
|
|
return -EINVAL;
|
|
}
|
|
page = (char*)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
return -ENOMEM;
|
|
length = -EFAULT;
|
|
if (copy_from_user(page, buf, count))
|
|
goto out_free_page;
|
|
|
|
page[count] = '\0';
|
|
loginuid = simple_strtoul(page, &tmp, 10);
|
|
if (tmp == page) {
|
|
length = -EINVAL;
|
|
goto out_free_page;
|
|
|
|
}
|
|
length = audit_set_loginuid(current, loginuid);
|
|
if (likely(length == 0))
|
|
length = count;
|
|
|
|
out_free_page:
|
|
free_page((unsigned long) page);
|
|
return length;
|
|
}
|
|
|
|
static const struct file_operations proc_loginuid_operations = {
|
|
.read = proc_loginuid_read,
|
|
.write = proc_loginuid_write,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
ssize_t length;
|
|
char tmpbuf[TMPBUFLEN];
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
|
|
audit_get_sessionid(task));
|
|
put_task_struct(task);
|
|
return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
|
|
}
|
|
|
|
static const struct file_operations proc_sessionid_operations = {
|
|
.read = proc_sessionid_read,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_FAULT_INJECTION
|
|
static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
|
|
char buffer[PROC_NUMBUF];
|
|
size_t len;
|
|
int make_it_fail;
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
make_it_fail = task->make_it_fail;
|
|
put_task_struct(task);
|
|
|
|
len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
|
|
|
|
return simple_read_from_buffer(buf, count, ppos, buffer, len);
|
|
}
|
|
|
|
static ssize_t proc_fault_inject_write(struct file * file,
|
|
const char __user * buf, size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task;
|
|
char buffer[PROC_NUMBUF], *end;
|
|
int make_it_fail;
|
|
|
|
if (!capable(CAP_SYS_RESOURCE))
|
|
return -EPERM;
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (count > sizeof(buffer) - 1)
|
|
count = sizeof(buffer) - 1;
|
|
if (copy_from_user(buffer, buf, count))
|
|
return -EFAULT;
|
|
make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
|
|
if (*end)
|
|
return -EINVAL;
|
|
task = get_proc_task(file->f_dentry->d_inode);
|
|
if (!task)
|
|
return -ESRCH;
|
|
task->make_it_fail = make_it_fail;
|
|
put_task_struct(task);
|
|
|
|
return count;
|
|
}
|
|
|
|
static const struct file_operations proc_fault_inject_operations = {
|
|
.read = proc_fault_inject_read,
|
|
.write = proc_fault_inject_write,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
#endif
|
|
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
/*
|
|
* Print out various scheduling related per-task fields:
|
|
*/
|
|
static int sched_show(struct seq_file *m, void *v)
|
|
{
|
|
struct inode *inode = m->private;
|
|
struct task_struct *p;
|
|
|
|
p = get_proc_task(inode);
|
|
if (!p)
|
|
return -ESRCH;
|
|
proc_sched_show_task(p, m);
|
|
|
|
put_task_struct(p);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t
|
|
sched_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *offset)
|
|
{
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
|
struct task_struct *p;
|
|
|
|
p = get_proc_task(inode);
|
|
if (!p)
|
|
return -ESRCH;
|
|
proc_sched_set_task(p);
|
|
|
|
put_task_struct(p);
|
|
|
|
return count;
|
|
}
|
|
|
|
static int sched_open(struct inode *inode, struct file *filp)
|
|
{
|
|
return single_open(filp, sched_show, inode);
|
|
}
|
|
|
|
static const struct file_operations proc_pid_sched_operations = {
|
|
.open = sched_open,
|
|
.read = seq_read,
|
|
.write = sched_write,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_AUTOGROUP
|
|
/*
|
|
* Print out autogroup related information:
|
|
*/
|
|
static int sched_autogroup_show(struct seq_file *m, void *v)
|
|
{
|
|
struct inode *inode = m->private;
|
|
struct task_struct *p;
|
|
|
|
p = get_proc_task(inode);
|
|
if (!p)
|
|
return -ESRCH;
|
|
proc_sched_autogroup_show_task(p, m);
|
|
|
|
put_task_struct(p);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t
|
|
sched_autogroup_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *offset)
|
|
{
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
|
struct task_struct *p;
|
|
char buffer[PROC_NUMBUF];
|
|
int nice;
|
|
int err;
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (count > sizeof(buffer) - 1)
|
|
count = sizeof(buffer) - 1;
|
|
if (copy_from_user(buffer, buf, count))
|
|
return -EFAULT;
|
|
|
|
err = kstrtoint(strstrip(buffer), 0, &nice);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
p = get_proc_task(inode);
|
|
if (!p)
|
|
return -ESRCH;
|
|
|
|
err = nice;
|
|
err = proc_sched_autogroup_set_nice(p, &err);
|
|
if (err)
|
|
count = err;
|
|
|
|
put_task_struct(p);
|
|
|
|
return count;
|
|
}
|
|
|
|
static int sched_autogroup_open(struct inode *inode, struct file *filp)
|
|
{
|
|
int ret;
|
|
|
|
ret = single_open(filp, sched_autogroup_show, NULL);
|
|
if (!ret) {
|
|
struct seq_file *m = filp->private_data;
|
|
|
|
m->private = inode;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_pid_sched_autogroup_operations = {
|
|
.open = sched_autogroup_open,
|
|
.read = seq_read,
|
|
.write = sched_autogroup_write,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
#endif /* CONFIG_SCHED_AUTOGROUP */
|
|
|
|
static ssize_t comm_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *offset)
|
|
{
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
|
struct task_struct *p;
|
|
char buffer[TASK_COMM_LEN];
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (count > sizeof(buffer) - 1)
|
|
count = sizeof(buffer) - 1;
|
|
if (copy_from_user(buffer, buf, count))
|
|
return -EFAULT;
|
|
|
|
p = get_proc_task(inode);
|
|
if (!p)
|
|
return -ESRCH;
|
|
|
|
if (same_thread_group(current, p))
|
|
set_task_comm(p, buffer);
|
|
else
|
|
count = -EINVAL;
|
|
|
|
put_task_struct(p);
|
|
|
|
return count;
|
|
}
|
|
|
|
static int comm_show(struct seq_file *m, void *v)
|
|
{
|
|
struct inode *inode = m->private;
|
|
struct task_struct *p;
|
|
|
|
p = get_proc_task(inode);
|
|
if (!p)
|
|
return -ESRCH;
|
|
|
|
task_lock(p);
|
|
seq_printf(m, "%s\n", p->comm);
|
|
task_unlock(p);
|
|
|
|
put_task_struct(p);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int comm_open(struct inode *inode, struct file *filp)
|
|
{
|
|
return single_open(filp, comm_show, inode);
|
|
}
|
|
|
|
static const struct file_operations proc_pid_set_comm_operations = {
|
|
.open = comm_open,
|
|
.read = seq_read,
|
|
.write = comm_write,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
|
|
{
|
|
struct task_struct *task;
|
|
struct mm_struct *mm;
|
|
struct file *exe_file;
|
|
|
|
task = get_proc_task(dentry->d_inode);
|
|
if (!task)
|
|
return -ENOENT;
|
|
mm = get_task_mm(task);
|
|
put_task_struct(task);
|
|
if (!mm)
|
|
return -ENOENT;
|
|
exe_file = get_mm_exe_file(mm);
|
|
mmput(mm);
|
|
if (exe_file) {
|
|
*exe_path = exe_file->f_path;
|
|
path_get(&exe_file->f_path);
|
|
fput(exe_file);
|
|
return 0;
|
|
} else
|
|
return -ENOENT;
|
|
}
|
|
|
|
static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
int error = -EACCES;
|
|
|
|
/* We don't need a base pointer in the /proc filesystem */
|
|
path_put(&nd->path);
|
|
|
|
/* Are we allowed to snoop on the tasks file descriptors? */
|
|
if (!proc_fd_access_allowed(inode))
|
|
goto out;
|
|
|
|
error = PROC_I(inode)->op.proc_get_link(dentry, &nd->path);
|
|
out:
|
|
return ERR_PTR(error);
|
|
}
|
|
|
|
static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
|
|
{
|
|
char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
|
|
char *pathname;
|
|
int len;
|
|
|
|
if (!tmp)
|
|
return -ENOMEM;
|
|
|
|
pathname = d_path(path, tmp, PAGE_SIZE);
|
|
len = PTR_ERR(pathname);
|
|
if (IS_ERR(pathname))
|
|
goto out;
|
|
len = tmp + PAGE_SIZE - 1 - pathname;
|
|
|
|
if (len > buflen)
|
|
len = buflen;
|
|
if (copy_to_user(buffer, pathname, len))
|
|
len = -EFAULT;
|
|
out:
|
|
free_page((unsigned long)tmp);
|
|
return len;
|
|
}
|
|
|
|
static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
|
|
{
|
|
int error = -EACCES;
|
|
struct inode *inode = dentry->d_inode;
|
|
struct path path;
|
|
|
|
/* Are we allowed to snoop on the tasks file descriptors? */
|
|
if (!proc_fd_access_allowed(inode))
|
|
goto out;
|
|
|
|
error = PROC_I(inode)->op.proc_get_link(dentry, &path);
|
|
if (error)
|
|
goto out;
|
|
|
|
error = do_proc_readlink(&path, buffer, buflen);
|
|
path_put(&path);
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static const struct inode_operations proc_pid_link_inode_operations = {
|
|
.readlink = proc_pid_readlink,
|
|
.follow_link = proc_pid_follow_link,
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
|
|
/* building an inode */
|
|
|
|
static int task_dumpable(struct task_struct *task)
|
|
{
|
|
int dumpable = 0;
|
|
struct mm_struct *mm;
|
|
|
|
task_lock(task);
|
|
mm = task->mm;
|
|
if (mm)
|
|
dumpable = get_dumpable(mm);
|
|
task_unlock(task);
|
|
if(dumpable == 1)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
|
|
{
|
|
struct inode * inode;
|
|
struct proc_inode *ei;
|
|
const struct cred *cred;
|
|
|
|
/* We need a new inode */
|
|
|
|
inode = new_inode(sb);
|
|
if (!inode)
|
|
goto out;
|
|
|
|
/* Common stuff */
|
|
ei = PROC_I(inode);
|
|
inode->i_ino = get_next_ino();
|
|
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
|
|
inode->i_op = &proc_def_inode_operations;
|
|
|
|
/*
|
|
* grab the reference to task.
|
|
*/
|
|
ei->pid = get_task_pid(task, PIDTYPE_PID);
|
|
if (!ei->pid)
|
|
goto out_unlock;
|
|
|
|
if (task_dumpable(task)) {
|
|
rcu_read_lock();
|
|
cred = __task_cred(task);
|
|
inode->i_uid = cred->euid;
|
|
inode->i_gid = cred->egid;
|
|
rcu_read_unlock();
|
|
}
|
|
security_task_to_inode(task, inode);
|
|
|
|
out:
|
|
return inode;
|
|
|
|
out_unlock:
|
|
iput(inode);
|
|
return NULL;
|
|
}
|
|
|
|
int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
struct task_struct *task;
|
|
const struct cred *cred;
|
|
struct pid_namespace *pid = dentry->d_sb->s_fs_info;
|
|
|
|
generic_fillattr(inode, stat);
|
|
|
|
rcu_read_lock();
|
|
stat->uid = 0;
|
|
stat->gid = 0;
|
|
task = pid_task(proc_pid(inode), PIDTYPE_PID);
|
|
if (task) {
|
|
if (!has_pid_permissions(pid, task, 2)) {
|
|
rcu_read_unlock();
|
|
/*
|
|
* This doesn't prevent learning whether PID exists,
|
|
* it only makes getattr() consistent with readdir().
|
|
*/
|
|
return -ENOENT;
|
|
}
|
|
if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
|
|
task_dumpable(task)) {
|
|
cred = __task_cred(task);
|
|
stat->uid = cred->euid;
|
|
stat->gid = cred->egid;
|
|
}
|
|
}
|
|
rcu_read_unlock();
|
|
return 0;
|
|
}
|
|
|
|
/* dentry stuff */
|
|
|
|
/*
|
|
* Exceptional case: normally we are not allowed to unhash a busy
|
|
* directory. In this case, however, we can do it - no aliasing problems
|
|
* due to the way we treat inodes.
|
|
*
|
|
* Rewrite the inode's ownerships here because the owning task may have
|
|
* performed a setuid(), etc.
|
|
*
|
|
* Before the /proc/pid/status file was created the only way to read
|
|
* the effective uid of a /process was to stat /proc/pid. Reading
|
|
* /proc/pid/status is slow enough that procps and other packages
|
|
* kept stating /proc/pid. To keep the rules in /proc simple I have
|
|
* made this apply to all per process world readable and executable
|
|
* directories.
|
|
*/
|
|
int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
struct inode *inode;
|
|
struct task_struct *task;
|
|
const struct cred *cred;
|
|
|
|
if (nd && nd->flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
inode = dentry->d_inode;
|
|
task = get_proc_task(inode);
|
|
|
|
if (task) {
|
|
if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
|
|
task_dumpable(task)) {
|
|
rcu_read_lock();
|
|
cred = __task_cred(task);
|
|
inode->i_uid = cred->euid;
|
|
inode->i_gid = cred->egid;
|
|
rcu_read_unlock();
|
|
} else {
|
|
inode->i_uid = 0;
|
|
inode->i_gid = 0;
|
|
}
|
|
inode->i_mode &= ~(S_ISUID | S_ISGID);
|
|
security_task_to_inode(task, inode);
|
|
put_task_struct(task);
|
|
return 1;
|
|
}
|
|
d_drop(dentry);
|
|
return 0;
|
|
}
|
|
|
|
static int pid_delete_dentry(const struct dentry * dentry)
|
|
{
|
|
/* Is the task we represent dead?
|
|
* If so, then don't put the dentry on the lru list,
|
|
* kill it immediately.
|
|
*/
|
|
return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
|
|
}
|
|
|
|
const struct dentry_operations pid_dentry_operations =
|
|
{
|
|
.d_revalidate = pid_revalidate,
|
|
.d_delete = pid_delete_dentry,
|
|
};
|
|
|
|
/* Lookups */
|
|
|
|
/*
|
|
* Fill a directory entry.
|
|
*
|
|
* If possible create the dcache entry and derive our inode number and
|
|
* file type from dcache entry.
|
|
*
|
|
* Since all of the proc inode numbers are dynamically generated, the inode
|
|
* numbers do not exist until the inode is cache. This means creating the
|
|
* the dcache entry in readdir is necessary to keep the inode numbers
|
|
* reported by readdir in sync with the inode numbers reported
|
|
* by stat.
|
|
*/
|
|
int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
|
|
const char *name, int len,
|
|
instantiate_t instantiate, struct task_struct *task, const void *ptr)
|
|
{
|
|
struct dentry *child, *dir = filp->f_path.dentry;
|
|
struct inode *inode;
|
|
struct qstr qname;
|
|
ino_t ino = 0;
|
|
unsigned type = DT_UNKNOWN;
|
|
|
|
qname.name = name;
|
|
qname.len = len;
|
|
qname.hash = full_name_hash(name, len);
|
|
|
|
child = d_lookup(dir, &qname);
|
|
if (!child) {
|
|
struct dentry *new;
|
|
new = d_alloc(dir, &qname);
|
|
if (new) {
|
|
child = instantiate(dir->d_inode, new, task, ptr);
|
|
if (child)
|
|
dput(new);
|
|
else
|
|
child = new;
|
|
}
|
|
}
|
|
if (!child || IS_ERR(child) || !child->d_inode)
|
|
goto end_instantiate;
|
|
inode = child->d_inode;
|
|
if (inode) {
|
|
ino = inode->i_ino;
|
|
type = inode->i_mode >> 12;
|
|
}
|
|
dput(child);
|
|
end_instantiate:
|
|
if (!ino)
|
|
ino = find_inode_number(dir, &qname);
|
|
if (!ino)
|
|
ino = 1;
|
|
return filldir(dirent, name, len, filp->f_pos, ino, type);
|
|
}
|
|
|
|
static unsigned name_to_int(struct dentry *dentry)
|
|
{
|
|
const char *name = dentry->d_name.name;
|
|
int len = dentry->d_name.len;
|
|
unsigned n = 0;
|
|
|
|
if (len > 1 && *name == '0')
|
|
goto out;
|
|
while (len-- > 0) {
|
|
unsigned c = *name++ - '0';
|
|
if (c > 9)
|
|
goto out;
|
|
if (n >= (~0U-9)/10)
|
|
goto out;
|
|
n *= 10;
|
|
n += c;
|
|
}
|
|
return n;
|
|
out:
|
|
return ~0U;
|
|
}
|
|
|
|
#define PROC_FDINFO_MAX 64
|
|
|
|
static int proc_fd_info(struct inode *inode, struct path *path, char *info)
|
|
{
|
|
struct task_struct *task = get_proc_task(inode);
|
|
struct files_struct *files = NULL;
|
|
struct file *file;
|
|
int fd = proc_fd(inode);
|
|
|
|
if (task) {
|
|
files = get_files_struct(task);
|
|
put_task_struct(task);
|
|
}
|
|
if (files) {
|
|
/*
|
|
* We are not taking a ref to the file structure, so we must
|
|
* hold ->file_lock.
|
|
*/
|
|
spin_lock(&files->file_lock);
|
|
file = fcheck_files(files, fd);
|
|
if (file) {
|
|
unsigned int f_flags;
|
|
struct fdtable *fdt;
|
|
|
|
fdt = files_fdtable(files);
|
|
f_flags = file->f_flags & ~O_CLOEXEC;
|
|
if (FD_ISSET(fd, fdt->close_on_exec))
|
|
f_flags |= O_CLOEXEC;
|
|
|
|
if (path) {
|
|
*path = file->f_path;
|
|
path_get(&file->f_path);
|
|
}
|
|
if (info)
|
|
snprintf(info, PROC_FDINFO_MAX,
|
|
"pos:\t%lli\n"
|
|
"flags:\t0%o\n",
|
|
(long long) file->f_pos,
|
|
f_flags);
|
|
spin_unlock(&files->file_lock);
|
|
put_files_struct(files);
|
|
return 0;
|
|
}
|
|
spin_unlock(&files->file_lock);
|
|
put_files_struct(files);
|
|
}
|
|
return -ENOENT;
|
|
}
|
|
|
|
static int proc_fd_link(struct dentry *dentry, struct path *path)
|
|
{
|
|
return proc_fd_info(dentry->d_inode, path, NULL);
|
|
}
|
|
|
|
static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
struct inode *inode;
|
|
struct task_struct *task;
|
|
int fd;
|
|
struct files_struct *files;
|
|
const struct cred *cred;
|
|
|
|
if (nd && nd->flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
inode = dentry->d_inode;
|
|
task = get_proc_task(inode);
|
|
fd = proc_fd(inode);
|
|
|
|
if (task) {
|
|
files = get_files_struct(task);
|
|
if (files) {
|
|
rcu_read_lock();
|
|
if (fcheck_files(files, fd)) {
|
|
rcu_read_unlock();
|
|
put_files_struct(files);
|
|
if (task_dumpable(task)) {
|
|
rcu_read_lock();
|
|
cred = __task_cred(task);
|
|
inode->i_uid = cred->euid;
|
|
inode->i_gid = cred->egid;
|
|
rcu_read_unlock();
|
|
} else {
|
|
inode->i_uid = 0;
|
|
inode->i_gid = 0;
|
|
}
|
|
inode->i_mode &= ~(S_ISUID | S_ISGID);
|
|
security_task_to_inode(task, inode);
|
|
put_task_struct(task);
|
|
return 1;
|
|
}
|
|
rcu_read_unlock();
|
|
put_files_struct(files);
|
|
}
|
|
put_task_struct(task);
|
|
}
|
|
d_drop(dentry);
|
|
return 0;
|
|
}
|
|
|
|
static const struct dentry_operations tid_fd_dentry_operations =
|
|
{
|
|
.d_revalidate = tid_fd_revalidate,
|
|
.d_delete = pid_delete_dentry,
|
|
};
|
|
|
|
static struct dentry *proc_fd_instantiate(struct inode *dir,
|
|
struct dentry *dentry, struct task_struct *task, const void *ptr)
|
|
{
|
|
unsigned fd = *(const unsigned *)ptr;
|
|
struct file *file;
|
|
struct files_struct *files;
|
|
struct inode *inode;
|
|
struct proc_inode *ei;
|
|
struct dentry *error = ERR_PTR(-ENOENT);
|
|
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
if (!inode)
|
|
goto out;
|
|
ei = PROC_I(inode);
|
|
ei->fd = fd;
|
|
files = get_files_struct(task);
|
|
if (!files)
|
|
goto out_iput;
|
|
inode->i_mode = S_IFLNK;
|
|
|
|
/*
|
|
* We are not taking a ref to the file structure, so we must
|
|
* hold ->file_lock.
|
|
*/
|
|
spin_lock(&files->file_lock);
|
|
file = fcheck_files(files, fd);
|
|
if (!file)
|
|
goto out_unlock;
|
|
if (file->f_mode & FMODE_READ)
|
|
inode->i_mode |= S_IRUSR | S_IXUSR;
|
|
if (file->f_mode & FMODE_WRITE)
|
|
inode->i_mode |= S_IWUSR | S_IXUSR;
|
|
spin_unlock(&files->file_lock);
|
|
put_files_struct(files);
|
|
|
|
inode->i_op = &proc_pid_link_inode_operations;
|
|
inode->i_size = 64;
|
|
ei->op.proc_get_link = proc_fd_link;
|
|
d_set_d_op(dentry, &tid_fd_dentry_operations);
|
|
d_add(dentry, inode);
|
|
/* Close the race of the process dying before we return the dentry */
|
|
if (tid_fd_revalidate(dentry, NULL))
|
|
error = NULL;
|
|
|
|
out:
|
|
return error;
|
|
out_unlock:
|
|
spin_unlock(&files->file_lock);
|
|
put_files_struct(files);
|
|
out_iput:
|
|
iput(inode);
|
|
goto out;
|
|
}
|
|
|
|
static struct dentry *proc_lookupfd_common(struct inode *dir,
|
|
struct dentry *dentry,
|
|
instantiate_t instantiate)
|
|
{
|
|
struct task_struct *task = get_proc_task(dir);
|
|
unsigned fd = name_to_int(dentry);
|
|
struct dentry *result = ERR_PTR(-ENOENT);
|
|
|
|
if (!task)
|
|
goto out_no_task;
|
|
if (fd == ~0U)
|
|
goto out;
|
|
|
|
result = instantiate(dir, dentry, task, &fd);
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return result;
|
|
}
|
|
|
|
static int proc_readfd_common(struct file * filp, void * dirent,
|
|
filldir_t filldir, instantiate_t instantiate)
|
|
{
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
struct inode *inode = dentry->d_inode;
|
|
struct task_struct *p = get_proc_task(inode);
|
|
unsigned int fd, ino;
|
|
int retval;
|
|
struct files_struct * files;
|
|
|
|
retval = -ENOENT;
|
|
if (!p)
|
|
goto out_no_task;
|
|
retval = 0;
|
|
|
|
fd = filp->f_pos;
|
|
switch (fd) {
|
|
case 0:
|
|
if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
|
|
goto out;
|
|
filp->f_pos++;
|
|
case 1:
|
|
ino = parent_ino(dentry);
|
|
if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
|
|
goto out;
|
|
filp->f_pos++;
|
|
default:
|
|
files = get_files_struct(p);
|
|
if (!files)
|
|
goto out;
|
|
rcu_read_lock();
|
|
for (fd = filp->f_pos-2;
|
|
fd < files_fdtable(files)->max_fds;
|
|
fd++, filp->f_pos++) {
|
|
char name[PROC_NUMBUF];
|
|
int len;
|
|
|
|
if (!fcheck_files(files, fd))
|
|
continue;
|
|
rcu_read_unlock();
|
|
|
|
len = snprintf(name, sizeof(name), "%d", fd);
|
|
if (proc_fill_cache(filp, dirent, filldir,
|
|
name, len, instantiate,
|
|
p, &fd) < 0) {
|
|
rcu_read_lock();
|
|
break;
|
|
}
|
|
rcu_read_lock();
|
|
}
|
|
rcu_read_unlock();
|
|
put_files_struct(files);
|
|
}
|
|
out:
|
|
put_task_struct(p);
|
|
out_no_task:
|
|
return retval;
|
|
}
|
|
|
|
static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
|
|
struct nameidata *nd)
|
|
{
|
|
return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
|
|
}
|
|
|
|
static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
|
|
{
|
|
return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
|
|
}
|
|
|
|
static ssize_t proc_fdinfo_read(struct file *file, char __user *buf,
|
|
size_t len, loff_t *ppos)
|
|
{
|
|
char tmp[PROC_FDINFO_MAX];
|
|
int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, tmp);
|
|
if (!err)
|
|
err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp));
|
|
return err;
|
|
}
|
|
|
|
static const struct file_operations proc_fdinfo_file_operations = {
|
|
.open = nonseekable_open,
|
|
.read = proc_fdinfo_read,
|
|
.llseek = no_llseek,
|
|
};
|
|
|
|
static const struct file_operations proc_fd_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_readfd,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
#ifdef CONFIG_CHECKPOINT_RESTORE
|
|
|
|
/*
|
|
* dname_to_vma_addr - maps a dentry name into two unsigned longs
|
|
* which represent vma start and end addresses.
|
|
*/
|
|
static int dname_to_vma_addr(struct dentry *dentry,
|
|
unsigned long *start, unsigned long *end)
|
|
{
|
|
if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int map_files_d_revalidate(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
unsigned long vm_start, vm_end;
|
|
bool exact_vma_exists = false;
|
|
struct mm_struct *mm = NULL;
|
|
struct task_struct *task;
|
|
const struct cred *cred;
|
|
struct inode *inode;
|
|
int status = 0;
|
|
|
|
if (nd && nd->flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
status = -EACCES;
|
|
goto out_notask;
|
|
}
|
|
|
|
inode = dentry->d_inode;
|
|
task = get_proc_task(inode);
|
|
if (!task)
|
|
goto out_notask;
|
|
|
|
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
|
goto out;
|
|
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out;
|
|
|
|
if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
|
|
down_read(&mm->mmap_sem);
|
|
exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end);
|
|
up_read(&mm->mmap_sem);
|
|
}
|
|
|
|
mmput(mm);
|
|
|
|
if (exact_vma_exists) {
|
|
if (task_dumpable(task)) {
|
|
rcu_read_lock();
|
|
cred = __task_cred(task);
|
|
inode->i_uid = cred->euid;
|
|
inode->i_gid = cred->egid;
|
|
rcu_read_unlock();
|
|
} else {
|
|
inode->i_uid = 0;
|
|
inode->i_gid = 0;
|
|
}
|
|
security_task_to_inode(task, inode);
|
|
status = 1;
|
|
}
|
|
|
|
out:
|
|
put_task_struct(task);
|
|
|
|
out_notask:
|
|
if (status <= 0)
|
|
d_drop(dentry);
|
|
|
|
return status;
|
|
}
|
|
|
|
static const struct dentry_operations tid_map_files_dentry_operations = {
|
|
.d_revalidate = map_files_d_revalidate,
|
|
.d_delete = pid_delete_dentry,
|
|
};
|
|
|
|
static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
|
|
{
|
|
unsigned long vm_start, vm_end;
|
|
struct vm_area_struct *vma;
|
|
struct task_struct *task;
|
|
struct mm_struct *mm;
|
|
int rc;
|
|
|
|
rc = -ENOENT;
|
|
task = get_proc_task(dentry->d_inode);
|
|
if (!task)
|
|
goto out;
|
|
|
|
mm = get_task_mm(task);
|
|
put_task_struct(task);
|
|
if (!mm)
|
|
goto out;
|
|
|
|
rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);
|
|
if (rc)
|
|
goto out_mmput;
|
|
|
|
down_read(&mm->mmap_sem);
|
|
vma = find_exact_vma(mm, vm_start, vm_end);
|
|
if (vma && vma->vm_file) {
|
|
*path = vma->vm_file->f_path;
|
|
path_get(path);
|
|
rc = 0;
|
|
}
|
|
up_read(&mm->mmap_sem);
|
|
|
|
out_mmput:
|
|
mmput(mm);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
struct map_files_info {
|
|
struct file *file;
|
|
unsigned long len;
|
|
unsigned char name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
|
|
};
|
|
|
|
static struct dentry *
|
|
proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
|
|
struct task_struct *task, const void *ptr)
|
|
{
|
|
const struct file *file = ptr;
|
|
struct proc_inode *ei;
|
|
struct inode *inode;
|
|
|
|
if (!file)
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
if (!inode)
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
ei = PROC_I(inode);
|
|
ei->op.proc_get_link = proc_map_files_get_link;
|
|
|
|
inode->i_op = &proc_pid_link_inode_operations;
|
|
inode->i_size = 64;
|
|
inode->i_mode = S_IFLNK;
|
|
|
|
if (file->f_mode & FMODE_READ)
|
|
inode->i_mode |= S_IRUSR;
|
|
if (file->f_mode & FMODE_WRITE)
|
|
inode->i_mode |= S_IWUSR;
|
|
|
|
d_set_d_op(dentry, &tid_map_files_dentry_operations);
|
|
d_add(dentry, inode);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct dentry *proc_map_files_lookup(struct inode *dir,
|
|
struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
unsigned long vm_start, vm_end;
|
|
struct vm_area_struct *vma;
|
|
struct task_struct *task;
|
|
struct dentry *result;
|
|
struct mm_struct *mm;
|
|
|
|
result = ERR_PTR(-EACCES);
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
goto out;
|
|
|
|
result = ERR_PTR(-ENOENT);
|
|
task = get_proc_task(dir);
|
|
if (!task)
|
|
goto out;
|
|
|
|
result = ERR_PTR(-EACCES);
|
|
if (lock_trace(task))
|
|
goto out_put_task;
|
|
|
|
result = ERR_PTR(-ENOENT);
|
|
if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
|
|
goto out_unlock;
|
|
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out_unlock;
|
|
|
|
down_read(&mm->mmap_sem);
|
|
vma = find_exact_vma(mm, vm_start, vm_end);
|
|
if (!vma)
|
|
goto out_no_vma;
|
|
|
|
result = proc_map_files_instantiate(dir, dentry, task, vma->vm_file);
|
|
|
|
out_no_vma:
|
|
up_read(&mm->mmap_sem);
|
|
mmput(mm);
|
|
out_unlock:
|
|
unlock_trace(task);
|
|
out_put_task:
|
|
put_task_struct(task);
|
|
out:
|
|
return result;
|
|
}
|
|
|
|
static const struct inode_operations proc_map_files_inode_operations = {
|
|
.lookup = proc_map_files_lookup,
|
|
.permission = proc_fd_permission,
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
static int
|
|
proc_map_files_readdir(struct file *filp, void *dirent, filldir_t filldir)
|
|
{
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
struct inode *inode = dentry->d_inode;
|
|
struct vm_area_struct *vma;
|
|
struct task_struct *task;
|
|
struct mm_struct *mm;
|
|
ino_t ino;
|
|
int ret;
|
|
|
|
ret = -EACCES;
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
goto out;
|
|
|
|
ret = -ENOENT;
|
|
task = get_proc_task(inode);
|
|
if (!task)
|
|
goto out;
|
|
|
|
ret = -EACCES;
|
|
if (lock_trace(task))
|
|
goto out_put_task;
|
|
|
|
ret = 0;
|
|
switch (filp->f_pos) {
|
|
case 0:
|
|
ino = inode->i_ino;
|
|
if (filldir(dirent, ".", 1, 0, ino, DT_DIR) < 0)
|
|
goto out_unlock;
|
|
filp->f_pos++;
|
|
case 1:
|
|
ino = parent_ino(dentry);
|
|
if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
|
|
goto out_unlock;
|
|
filp->f_pos++;
|
|
default:
|
|
{
|
|
unsigned long nr_files, pos, i;
|
|
struct flex_array *fa = NULL;
|
|
struct map_files_info info;
|
|
struct map_files_info *p;
|
|
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out_unlock;
|
|
down_read(&mm->mmap_sem);
|
|
|
|
nr_files = 0;
|
|
|
|
/*
|
|
* We need two passes here:
|
|
*
|
|
* 1) Collect vmas of mapped files with mmap_sem taken
|
|
* 2) Release mmap_sem and instantiate entries
|
|
*
|
|
* otherwise we get lockdep complained, since filldir()
|
|
* routine might require mmap_sem taken in might_fault().
|
|
*/
|
|
|
|
for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
|
|
if (vma->vm_file && ++pos > filp->f_pos)
|
|
nr_files++;
|
|
}
|
|
|
|
if (nr_files) {
|
|
fa = flex_array_alloc(sizeof(info), nr_files,
|
|
GFP_KERNEL);
|
|
if (!fa || flex_array_prealloc(fa, 0, nr_files,
|
|
GFP_KERNEL)) {
|
|
ret = -ENOMEM;
|
|
if (fa)
|
|
flex_array_free(fa);
|
|
up_read(&mm->mmap_sem);
|
|
mmput(mm);
|
|
goto out_unlock;
|
|
}
|
|
for (i = 0, vma = mm->mmap, pos = 2; vma;
|
|
vma = vma->vm_next) {
|
|
if (!vma->vm_file)
|
|
continue;
|
|
if (++pos <= filp->f_pos)
|
|
continue;
|
|
|
|
get_file(vma->vm_file);
|
|
info.file = vma->vm_file;
|
|
info.len = snprintf(info.name,
|
|
sizeof(info.name), "%lx-%lx",
|
|
vma->vm_start, vma->vm_end);
|
|
if (flex_array_put(fa, i++, &info, GFP_KERNEL))
|
|
BUG();
|
|
}
|
|
}
|
|
up_read(&mm->mmap_sem);
|
|
|
|
for (i = 0; i < nr_files; i++) {
|
|
p = flex_array_get(fa, i);
|
|
ret = proc_fill_cache(filp, dirent, filldir,
|
|
p->name, p->len,
|
|
proc_map_files_instantiate,
|
|
task, p->file);
|
|
if (ret)
|
|
break;
|
|
filp->f_pos++;
|
|
fput(p->file);
|
|
}
|
|
for (; i < nr_files; i++) {
|
|
/*
|
|
* In case of error don't forget
|
|
* to put rest of file refs.
|
|
*/
|
|
p = flex_array_get(fa, i);
|
|
fput(p->file);
|
|
}
|
|
if (fa)
|
|
flex_array_free(fa);
|
|
mmput(mm);
|
|
}
|
|
}
|
|
|
|
out_unlock:
|
|
unlock_trace(task);
|
|
out_put_task:
|
|
put_task_struct(task);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_map_files_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_map_files_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
#endif /* CONFIG_CHECKPOINT_RESTORE */
|
|
|
|
/*
|
|
* /proc/pid/fd needs a special permission handler so that a process can still
|
|
* access /proc/self/fd after it has executed a setuid().
|
|
*/
|
|
static int proc_fd_permission(struct inode *inode, int mask)
|
|
{
|
|
int rv = generic_permission(inode, mask);
|
|
if (rv == 0)
|
|
return 0;
|
|
if (task_pid(current) == proc_pid(inode))
|
|
rv = 0;
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* proc directories can do almost nothing..
|
|
*/
|
|
static const struct inode_operations proc_fd_inode_operations = {
|
|
.lookup = proc_lookupfd,
|
|
.permission = proc_fd_permission,
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
|
|
struct dentry *dentry, struct task_struct *task, const void *ptr)
|
|
{
|
|
unsigned fd = *(unsigned *)ptr;
|
|
struct inode *inode;
|
|
struct proc_inode *ei;
|
|
struct dentry *error = ERR_PTR(-ENOENT);
|
|
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
if (!inode)
|
|
goto out;
|
|
ei = PROC_I(inode);
|
|
ei->fd = fd;
|
|
inode->i_mode = S_IFREG | S_IRUSR;
|
|
inode->i_fop = &proc_fdinfo_file_operations;
|
|
d_set_d_op(dentry, &tid_fd_dentry_operations);
|
|
d_add(dentry, inode);
|
|
/* Close the race of the process dying before we return the dentry */
|
|
if (tid_fd_revalidate(dentry, NULL))
|
|
error = NULL;
|
|
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static struct dentry *proc_lookupfdinfo(struct inode *dir,
|
|
struct dentry *dentry,
|
|
struct nameidata *nd)
|
|
{
|
|
return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
|
|
}
|
|
|
|
static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
|
|
{
|
|
return proc_readfd_common(filp, dirent, filldir,
|
|
proc_fdinfo_instantiate);
|
|
}
|
|
|
|
static const struct file_operations proc_fdinfo_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_readfdinfo,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
/*
|
|
* proc directories can do almost nothing..
|
|
*/
|
|
static const struct inode_operations proc_fdinfo_inode_operations = {
|
|
.lookup = proc_lookupfdinfo,
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
|
|
static struct dentry *proc_pident_instantiate(struct inode *dir,
|
|
struct dentry *dentry, struct task_struct *task, const void *ptr)
|
|
{
|
|
const struct pid_entry *p = ptr;
|
|
struct inode *inode;
|
|
struct proc_inode *ei;
|
|
struct dentry *error = ERR_PTR(-ENOENT);
|
|
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
if (!inode)
|
|
goto out;
|
|
|
|
ei = PROC_I(inode);
|
|
inode->i_mode = p->mode;
|
|
if (S_ISDIR(inode->i_mode))
|
|
set_nlink(inode, 2); /* Use getattr to fix if necessary */
|
|
if (p->iop)
|
|
inode->i_op = p->iop;
|
|
if (p->fop)
|
|
inode->i_fop = p->fop;
|
|
ei->op = p->op;
|
|
d_set_d_op(dentry, &pid_dentry_operations);
|
|
d_add(dentry, inode);
|
|
/* Close the race of the process dying before we return the dentry */
|
|
if (pid_revalidate(dentry, NULL))
|
|
error = NULL;
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static struct dentry *proc_pident_lookup(struct inode *dir,
|
|
struct dentry *dentry,
|
|
const struct pid_entry *ents,
|
|
unsigned int nents)
|
|
{
|
|
struct dentry *error;
|
|
struct task_struct *task = get_proc_task(dir);
|
|
const struct pid_entry *p, *last;
|
|
|
|
error = ERR_PTR(-ENOENT);
|
|
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
/*
|
|
* Yes, it does not scale. And it should not. Don't add
|
|
* new entries into /proc/<tgid>/ without very good reasons.
|
|
*/
|
|
last = &ents[nents - 1];
|
|
for (p = ents; p <= last; p++) {
|
|
if (p->len != dentry->d_name.len)
|
|
continue;
|
|
if (!memcmp(dentry->d_name.name, p->name, p->len))
|
|
break;
|
|
}
|
|
if (p > last)
|
|
goto out;
|
|
|
|
error = proc_pident_instantiate(dir, dentry, task, p);
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return error;
|
|
}
|
|
|
|
static int proc_pident_fill_cache(struct file *filp, void *dirent,
|
|
filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
|
|
{
|
|
return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
|
|
proc_pident_instantiate, task, p);
|
|
}
|
|
|
|
static int proc_pident_readdir(struct file *filp,
|
|
void *dirent, filldir_t filldir,
|
|
const struct pid_entry *ents, unsigned int nents)
|
|
{
|
|
int i;
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
struct inode *inode = dentry->d_inode;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
const struct pid_entry *p, *last;
|
|
ino_t ino;
|
|
int ret;
|
|
|
|
ret = -ENOENT;
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
ret = 0;
|
|
i = filp->f_pos;
|
|
switch (i) {
|
|
case 0:
|
|
ino = inode->i_ino;
|
|
if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
|
|
goto out;
|
|
i++;
|
|
filp->f_pos++;
|
|
/* fall through */
|
|
case 1:
|
|
ino = parent_ino(dentry);
|
|
if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
|
|
goto out;
|
|
i++;
|
|
filp->f_pos++;
|
|
/* fall through */
|
|
default:
|
|
i -= 2;
|
|
if (i >= nents) {
|
|
ret = 1;
|
|
goto out;
|
|
}
|
|
p = ents + i;
|
|
last = &ents[nents - 1];
|
|
while (p <= last) {
|
|
if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
|
|
goto out;
|
|
filp->f_pos++;
|
|
p++;
|
|
}
|
|
}
|
|
|
|
ret = 1;
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_SECURITY
|
|
static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
char *p = NULL;
|
|
ssize_t length;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
|
|
length = security_getprocattr(task,
|
|
(char*)file->f_path.dentry->d_name.name,
|
|
&p);
|
|
put_task_struct(task);
|
|
if (length > 0)
|
|
length = simple_read_from_buffer(buf, count, ppos, p, length);
|
|
kfree(p);
|
|
return length;
|
|
}
|
|
|
|
static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
char *page;
|
|
ssize_t length;
|
|
struct task_struct *task = get_proc_task(inode);
|
|
|
|
length = -ESRCH;
|
|
if (!task)
|
|
goto out_no_task;
|
|
if (count > PAGE_SIZE)
|
|
count = PAGE_SIZE;
|
|
|
|
/* No partial writes. */
|
|
length = -EINVAL;
|
|
if (*ppos != 0)
|
|
goto out;
|
|
|
|
length = -ENOMEM;
|
|
page = (char*)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
goto out;
|
|
|
|
length = -EFAULT;
|
|
if (copy_from_user(page, buf, count))
|
|
goto out_free;
|
|
|
|
/* Guard against adverse ptrace interaction */
|
|
length = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
|
|
if (length < 0)
|
|
goto out_free;
|
|
|
|
length = security_setprocattr(task,
|
|
(char*)file->f_path.dentry->d_name.name,
|
|
(void*)page, count);
|
|
mutex_unlock(&task->signal->cred_guard_mutex);
|
|
out_free:
|
|
free_page((unsigned long) page);
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return length;
|
|
}
|
|
|
|
static const struct file_operations proc_pid_attr_operations = {
|
|
.read = proc_pid_attr_read,
|
|
.write = proc_pid_attr_write,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static const struct pid_entry attr_dir_stuff[] = {
|
|
REG("current", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
|
|
REG("prev", S_IRUGO, proc_pid_attr_operations),
|
|
REG("exec", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
|
|
REG("fscreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
|
|
REG("keycreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
|
|
REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
|
|
};
|
|
|
|
static int proc_attr_dir_readdir(struct file * filp,
|
|
void * dirent, filldir_t filldir)
|
|
{
|
|
return proc_pident_readdir(filp,dirent,filldir,
|
|
attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff));
|
|
}
|
|
|
|
static const struct file_operations proc_attr_dir_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_attr_dir_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
static struct dentry *proc_attr_dir_lookup(struct inode *dir,
|
|
struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
return proc_pident_lookup(dir, dentry,
|
|
attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
|
|
}
|
|
|
|
static const struct inode_operations proc_attr_dir_inode_operations = {
|
|
.lookup = proc_attr_dir_lookup,
|
|
.getattr = pid_getattr,
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_ELF_CORE
|
|
static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
|
|
struct mm_struct *mm;
|
|
char buffer[PROC_NUMBUF];
|
|
size_t len;
|
|
int ret;
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
|
|
ret = 0;
|
|
mm = get_task_mm(task);
|
|
if (mm) {
|
|
len = snprintf(buffer, sizeof(buffer), "%08lx\n",
|
|
((mm->flags & MMF_DUMP_FILTER_MASK) >>
|
|
MMF_DUMP_FILTER_SHIFT));
|
|
mmput(mm);
|
|
ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
|
|
}
|
|
|
|
put_task_struct(task);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t proc_coredump_filter_write(struct file *file,
|
|
const char __user *buf,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
struct task_struct *task;
|
|
struct mm_struct *mm;
|
|
char buffer[PROC_NUMBUF], *end;
|
|
unsigned int val;
|
|
int ret;
|
|
int i;
|
|
unsigned long mask;
|
|
|
|
ret = -EFAULT;
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (count > sizeof(buffer) - 1)
|
|
count = sizeof(buffer) - 1;
|
|
if (copy_from_user(buffer, buf, count))
|
|
goto out_no_task;
|
|
|
|
ret = -EINVAL;
|
|
val = (unsigned int)simple_strtoul(buffer, &end, 0);
|
|
if (*end == '\n')
|
|
end++;
|
|
if (end - buffer == 0)
|
|
goto out_no_task;
|
|
|
|
ret = -ESRCH;
|
|
task = get_proc_task(file->f_dentry->d_inode);
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
ret = end - buffer;
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out_no_mm;
|
|
|
|
for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
|
|
if (val & mask)
|
|
set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
|
|
else
|
|
clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
|
|
}
|
|
|
|
mmput(mm);
|
|
out_no_mm:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_coredump_filter_operations = {
|
|
.read = proc_coredump_filter_read,
|
|
.write = proc_coredump_filter_write,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
* /proc/self:
|
|
*/
|
|
static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
|
|
int buflen)
|
|
{
|
|
struct pid_namespace *ns = dentry->d_sb->s_fs_info;
|
|
pid_t tgid = task_tgid_nr_ns(current, ns);
|
|
char tmp[PROC_NUMBUF];
|
|
if (!tgid)
|
|
return -ENOENT;
|
|
sprintf(tmp, "%d", tgid);
|
|
return vfs_readlink(dentry,buffer,buflen,tmp);
|
|
}
|
|
|
|
static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
struct pid_namespace *ns = dentry->d_sb->s_fs_info;
|
|
pid_t tgid = task_tgid_nr_ns(current, ns);
|
|
char *name = ERR_PTR(-ENOENT);
|
|
if (tgid) {
|
|
name = __getname();
|
|
if (!name)
|
|
name = ERR_PTR(-ENOMEM);
|
|
else
|
|
sprintf(name, "%d", tgid);
|
|
}
|
|
nd_set_link(nd, name);
|
|
return NULL;
|
|
}
|
|
|
|
static void proc_self_put_link(struct dentry *dentry, struct nameidata *nd,
|
|
void *cookie)
|
|
{
|
|
char *s = nd_get_link(nd);
|
|
if (!IS_ERR(s))
|
|
__putname(s);
|
|
}
|
|
|
|
static const struct inode_operations proc_self_inode_operations = {
|
|
.readlink = proc_self_readlink,
|
|
.follow_link = proc_self_follow_link,
|
|
.put_link = proc_self_put_link,
|
|
};
|
|
|
|
/*
|
|
* proc base
|
|
*
|
|
* These are the directory entries in the root directory of /proc
|
|
* that properly belong to the /proc filesystem, as they describe
|
|
* describe something that is process related.
|
|
*/
|
|
static const struct pid_entry proc_base_stuff[] = {
|
|
NOD("self", S_IFLNK|S_IRWXUGO,
|
|
&proc_self_inode_operations, NULL, {}),
|
|
};
|
|
|
|
static struct dentry *proc_base_instantiate(struct inode *dir,
|
|
struct dentry *dentry, struct task_struct *task, const void *ptr)
|
|
{
|
|
const struct pid_entry *p = ptr;
|
|
struct inode *inode;
|
|
struct proc_inode *ei;
|
|
struct dentry *error;
|
|
|
|
/* Allocate the inode */
|
|
error = ERR_PTR(-ENOMEM);
|
|
inode = new_inode(dir->i_sb);
|
|
if (!inode)
|
|
goto out;
|
|
|
|
/* Initialize the inode */
|
|
ei = PROC_I(inode);
|
|
inode->i_ino = get_next_ino();
|
|
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
|
|
|
|
/*
|
|
* grab the reference to the task.
|
|
*/
|
|
ei->pid = get_task_pid(task, PIDTYPE_PID);
|
|
if (!ei->pid)
|
|
goto out_iput;
|
|
|
|
inode->i_mode = p->mode;
|
|
if (S_ISDIR(inode->i_mode))
|
|
set_nlink(inode, 2);
|
|
if (S_ISLNK(inode->i_mode))
|
|
inode->i_size = 64;
|
|
if (p->iop)
|
|
inode->i_op = p->iop;
|
|
if (p->fop)
|
|
inode->i_fop = p->fop;
|
|
ei->op = p->op;
|
|
d_add(dentry, inode);
|
|
error = NULL;
|
|
out:
|
|
return error;
|
|
out_iput:
|
|
iput(inode);
|
|
goto out;
|
|
}
|
|
|
|
static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
struct dentry *error;
|
|
struct task_struct *task = get_proc_task(dir);
|
|
const struct pid_entry *p, *last;
|
|
|
|
error = ERR_PTR(-ENOENT);
|
|
|
|
if (!task)
|
|
goto out_no_task;
|
|
|
|
/* Lookup the directory entry */
|
|
last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1];
|
|
for (p = proc_base_stuff; p <= last; p++) {
|
|
if (p->len != dentry->d_name.len)
|
|
continue;
|
|
if (!memcmp(dentry->d_name.name, p->name, p->len))
|
|
break;
|
|
}
|
|
if (p > last)
|
|
goto out;
|
|
|
|
error = proc_base_instantiate(dir, dentry, task, p);
|
|
|
|
out:
|
|
put_task_struct(task);
|
|
out_no_task:
|
|
return error;
|
|
}
|
|
|
|
static int proc_base_fill_cache(struct file *filp, void *dirent,
|
|
filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
|
|
{
|
|
return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
|
|
proc_base_instantiate, task, p);
|
|
}
|
|
|
|
#ifdef CONFIG_TASK_IO_ACCOUNTING
|
|
static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
|
|
{
|
|
struct task_io_accounting acct = task->ioac;
|
|
unsigned long flags;
|
|
int result;
|
|
|
|
result = mutex_lock_killable(&task->signal->cred_guard_mutex);
|
|
if (result)
|
|
return result;
|
|
|
|
if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
|
|
result = -EACCES;
|
|
goto out_unlock;
|
|
}
|
|
|
|
if (whole && lock_task_sighand(task, &flags)) {
|
|
struct task_struct *t = task;
|
|
|
|
task_io_accounting_add(&acct, &task->signal->ioac);
|
|
while_each_thread(task, t)
|
|
task_io_accounting_add(&acct, &t->ioac);
|
|
|
|
unlock_task_sighand(task, &flags);
|
|
}
|
|
result = sprintf(buffer,
|
|
"rchar: %llu\n"
|
|
"wchar: %llu\n"
|
|
"syscr: %llu\n"
|
|
"syscw: %llu\n"
|
|
"read_bytes: %llu\n"
|
|
"write_bytes: %llu\n"
|
|
"cancelled_write_bytes: %llu\n",
|
|
(unsigned long long)acct.rchar,
|
|
(unsigned long long)acct.wchar,
|
|
(unsigned long long)acct.syscr,
|
|
(unsigned long long)acct.syscw,
|
|
(unsigned long long)acct.read_bytes,
|
|
(unsigned long long)acct.write_bytes,
|
|
(unsigned long long)acct.cancelled_write_bytes);
|
|
out_unlock:
|
|
mutex_unlock(&task->signal->cred_guard_mutex);
|
|
return result;
|
|
}
|
|
|
|
static int proc_tid_io_accounting(struct task_struct *task, char *buffer)
|
|
{
|
|
return do_io_accounting(task, buffer, 0);
|
|
}
|
|
|
|
static int proc_tgid_io_accounting(struct task_struct *task, char *buffer)
|
|
{
|
|
return do_io_accounting(task, buffer, 1);
|
|
}
|
|
#endif /* CONFIG_TASK_IO_ACCOUNTING */
|
|
|
|
static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
int err = lock_trace(task);
|
|
if (!err) {
|
|
seq_printf(m, "%08x\n", task->personality);
|
|
unlock_trace(task);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Thread groups
|
|
*/
|
|
static const struct file_operations proc_task_operations;
|
|
static const struct inode_operations proc_task_inode_operations;
|
|
|
|
static const struct pid_entry tgid_base_stuff[] = {
|
|
DIR("task", S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),
|
|
DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
|
|
#ifdef CONFIG_CHECKPOINT_RESTORE
|
|
DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
|
|
#endif
|
|
DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
|
|
DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
|
|
#ifdef CONFIG_NET
|
|
DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
|
|
#endif
|
|
REG("environ", S_IRUSR, proc_environ_operations),
|
|
INF("auxv", S_IRUSR, proc_pid_auxv),
|
|
ONE("status", S_IRUGO, proc_pid_status),
|
|
ONE("personality", S_IRUGO, proc_pid_personality),
|
|
INF("limits", S_IRUGO, proc_pid_limits),
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations),
|
|
#endif
|
|
#ifdef CONFIG_SCHED_AUTOGROUP
|
|
REG("autogroup", S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
|
|
#endif
|
|
REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
|
|
#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
|
|
INF("syscall", S_IRUGO, proc_pid_syscall),
|
|
#endif
|
|
INF("cmdline", S_IRUGO, proc_pid_cmdline),
|
|
ONE("stat", S_IRUGO, proc_tgid_stat),
|
|
ONE("statm", S_IRUGO, proc_pid_statm),
|
|
REG("maps", S_IRUGO, proc_maps_operations),
|
|
#ifdef CONFIG_NUMA
|
|
REG("numa_maps", S_IRUGO, proc_numa_maps_operations),
|
|
#endif
|
|
REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),
|
|
LNK("cwd", proc_cwd_link),
|
|
LNK("root", proc_root_link),
|
|
LNK("exe", proc_exe_link),
|
|
REG("mounts", S_IRUGO, proc_mounts_operations),
|
|
REG("mountinfo", S_IRUGO, proc_mountinfo_operations),
|
|
REG("mountstats", S_IRUSR, proc_mountstats_operations),
|
|
#ifdef CONFIG_PROC_PAGE_MONITOR
|
|
REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
|
|
REG("smaps", S_IRUGO, proc_smaps_operations),
|
|
REG("pagemap", S_IRUGO, proc_pagemap_operations),
|
|
#endif
|
|
#ifdef CONFIG_SECURITY
|
|
DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
|
|
#endif
|
|
#ifdef CONFIG_KALLSYMS
|
|
INF("wchan", S_IRUGO, proc_pid_wchan),
|
|
#endif
|
|
#ifdef CONFIG_STACKTRACE
|
|
ONE("stack", S_IRUGO, proc_pid_stack),
|
|
#endif
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
INF("schedstat", S_IRUGO, proc_pid_schedstat),
|
|
#endif
|
|
#ifdef CONFIG_LATENCYTOP
|
|
REG("latency", S_IRUGO, proc_lstats_operations),
|
|
#endif
|
|
#ifdef CONFIG_PROC_PID_CPUSET
|
|
REG("cpuset", S_IRUGO, proc_cpuset_operations),
|
|
#endif
|
|
#ifdef CONFIG_CGROUPS
|
|
REG("cgroup", S_IRUGO, proc_cgroup_operations),
|
|
#endif
|
|
INF("oom_score", S_IRUGO, proc_oom_score),
|
|
REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
|
|
REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
|
|
#ifdef CONFIG_AUDITSYSCALL
|
|
REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations),
|
|
REG("sessionid", S_IRUGO, proc_sessionid_operations),
|
|
#endif
|
|
#ifdef CONFIG_FAULT_INJECTION
|
|
REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
|
|
#endif
|
|
#ifdef CONFIG_ELF_CORE
|
|
REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
|
|
#endif
|
|
#ifdef CONFIG_TASK_IO_ACCOUNTING
|
|
INF("io", S_IRUSR, proc_tgid_io_accounting),
|
|
#endif
|
|
#ifdef CONFIG_HARDWALL
|
|
INF("hardwall", S_IRUGO, proc_pid_hardwall),
|
|
#endif
|
|
};
|
|
|
|
static int proc_tgid_base_readdir(struct file * filp,
|
|
void * dirent, filldir_t filldir)
|
|
{
|
|
return proc_pident_readdir(filp,dirent,filldir,
|
|
tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
|
|
}
|
|
|
|
static const struct file_operations proc_tgid_base_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_tgid_base_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
|
|
return proc_pident_lookup(dir, dentry,
|
|
tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
|
|
}
|
|
|
|
static const struct inode_operations proc_tgid_base_inode_operations = {
|
|
.lookup = proc_tgid_base_lookup,
|
|
.getattr = pid_getattr,
|
|
.setattr = proc_setattr,
|
|
.permission = proc_pid_permission,
|
|
};
|
|
|
|
static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
|
|
{
|
|
struct dentry *dentry, *leader, *dir;
|
|
char buf[PROC_NUMBUF];
|
|
struct qstr name;
|
|
|
|
name.name = buf;
|
|
name.len = snprintf(buf, sizeof(buf), "%d", pid);
|
|
dentry = d_hash_and_lookup(mnt->mnt_root, &name);
|
|
if (dentry) {
|
|
shrink_dcache_parent(dentry);
|
|
d_drop(dentry);
|
|
dput(dentry);
|
|
}
|
|
|
|
name.name = buf;
|
|
name.len = snprintf(buf, sizeof(buf), "%d", tgid);
|
|
leader = d_hash_and_lookup(mnt->mnt_root, &name);
|
|
if (!leader)
|
|
goto out;
|
|
|
|
name.name = "task";
|
|
name.len = strlen(name.name);
|
|
dir = d_hash_and_lookup(leader, &name);
|
|
if (!dir)
|
|
goto out_put_leader;
|
|
|
|
name.name = buf;
|
|
name.len = snprintf(buf, sizeof(buf), "%d", pid);
|
|
dentry = d_hash_and_lookup(dir, &name);
|
|
if (dentry) {
|
|
shrink_dcache_parent(dentry);
|
|
d_drop(dentry);
|
|
dput(dentry);
|
|
}
|
|
|
|
dput(dir);
|
|
out_put_leader:
|
|
dput(leader);
|
|
out:
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* proc_flush_task - Remove dcache entries for @task from the /proc dcache.
|
|
* @task: task that should be flushed.
|
|
*
|
|
* When flushing dentries from proc, one needs to flush them from global
|
|
* proc (proc_mnt) and from all the namespaces' procs this task was seen
|
|
* in. This call is supposed to do all of this job.
|
|
*
|
|
* Looks in the dcache for
|
|
* /proc/@pid
|
|
* /proc/@tgid/task/@pid
|
|
* if either directory is present flushes it and all of it'ts children
|
|
* from the dcache.
|
|
*
|
|
* It is safe and reasonable to cache /proc entries for a task until
|
|
* that task exits. After that they just clog up the dcache with
|
|
* useless entries, possibly causing useful dcache entries to be
|
|
* flushed instead. This routine is proved to flush those useless
|
|
* dcache entries at process exit time.
|
|
*
|
|
* NOTE: This routine is just an optimization so it does not guarantee
|
|
* that no dcache entries will exist at process exit time it
|
|
* just makes it very unlikely that any will persist.
|
|
*/
|
|
|
|
void proc_flush_task(struct task_struct *task)
|
|
{
|
|
int i;
|
|
struct pid *pid, *tgid;
|
|
struct upid *upid;
|
|
|
|
pid = task_pid(task);
|
|
tgid = task_tgid(task);
|
|
|
|
for (i = 0; i <= pid->level; i++) {
|
|
upid = &pid->numbers[i];
|
|
proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
|
|
tgid->numbers[i].nr);
|
|
}
|
|
|
|
upid = &pid->numbers[pid->level];
|
|
if (upid->nr == 1)
|
|
pid_ns_release_proc(upid->ns);
|
|
}
|
|
|
|
static struct dentry *proc_pid_instantiate(struct inode *dir,
|
|
struct dentry * dentry,
|
|
struct task_struct *task, const void *ptr)
|
|
{
|
|
struct dentry *error = ERR_PTR(-ENOENT);
|
|
struct inode *inode;
|
|
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
if (!inode)
|
|
goto out;
|
|
|
|
inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
|
|
inode->i_op = &proc_tgid_base_inode_operations;
|
|
inode->i_fop = &proc_tgid_base_operations;
|
|
inode->i_flags|=S_IMMUTABLE;
|
|
|
|
set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff,
|
|
ARRAY_SIZE(tgid_base_stuff)));
|
|
|
|
d_set_d_op(dentry, &pid_dentry_operations);
|
|
|
|
d_add(dentry, inode);
|
|
/* Close the race of the process dying before we return the dentry */
|
|
if (pid_revalidate(dentry, NULL))
|
|
error = NULL;
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
|
|
{
|
|
struct dentry *result;
|
|
struct task_struct *task;
|
|
unsigned tgid;
|
|
struct pid_namespace *ns;
|
|
|
|
result = proc_base_lookup(dir, dentry);
|
|
if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
|
|
goto out;
|
|
|
|
tgid = name_to_int(dentry);
|
|
if (tgid == ~0U)
|
|
goto out;
|
|
|
|
ns = dentry->d_sb->s_fs_info;
|
|
rcu_read_lock();
|
|
task = find_task_by_pid_ns(tgid, ns);
|
|
if (task)
|
|
get_task_struct(task);
|
|
rcu_read_unlock();
|
|
if (!task)
|
|
goto out;
|
|
|
|
result = proc_pid_instantiate(dir, dentry, task, NULL);
|
|
put_task_struct(task);
|
|
out:
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Find the first task with tgid >= tgid
|
|
*
|
|
*/
|
|
struct tgid_iter {
|
|
unsigned int tgid;
|
|
struct task_struct *task;
|
|
};
|
|
static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)
|
|
{
|
|
struct pid *pid;
|
|
|
|
if (iter.task)
|
|
put_task_struct(iter.task);
|
|
rcu_read_lock();
|
|
retry:
|
|
iter.task = NULL;
|
|
pid = find_ge_pid(iter.tgid, ns);
|
|
if (pid) {
|
|
iter.tgid = pid_nr_ns(pid, ns);
|
|
iter.task = pid_task(pid, PIDTYPE_PID);
|
|
/* What we to know is if the pid we have find is the
|
|
* pid of a thread_group_leader. Testing for task
|
|
* being a thread_group_leader is the obvious thing
|
|
* todo but there is a window when it fails, due to
|
|
* the pid transfer logic in de_thread.
|
|
*
|
|
* So we perform the straight forward test of seeing
|
|
* if the pid we have found is the pid of a thread
|
|
* group leader, and don't worry if the task we have
|
|
* found doesn't happen to be a thread group leader.
|
|
* As we don't care in the case of readdir.
|
|
*/
|
|
if (!iter.task || !has_group_leader_pid(iter.task)) {
|
|
iter.tgid += 1;
|
|
goto retry;
|
|
}
|
|
get_task_struct(iter.task);
|
|
}
|
|
rcu_read_unlock();
|
|
return iter;
|
|
}
|
|
|
|
#define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff))
|
|
|
|
static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
|
|
struct tgid_iter iter)
|
|
{
|
|
char name[PROC_NUMBUF];
|
|
int len = snprintf(name, sizeof(name), "%d", iter.tgid);
|
|
return proc_fill_cache(filp, dirent, filldir, name, len,
|
|
proc_pid_instantiate, iter.task, NULL);
|
|
}
|
|
|
|
static int fake_filldir(void *buf, const char *name, int namelen,
|
|
loff_t offset, u64 ino, unsigned d_type)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* for the /proc/ directory itself, after non-process stuff has been done */
|
|
int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
|
|
{
|
|
unsigned int nr;
|
|
struct task_struct *reaper;
|
|
struct tgid_iter iter;
|
|
struct pid_namespace *ns;
|
|
filldir_t __filldir;
|
|
|
|
if (filp->f_pos >= PID_MAX_LIMIT + TGID_OFFSET)
|
|
goto out_no_task;
|
|
nr = filp->f_pos - FIRST_PROCESS_ENTRY;
|
|
|
|
reaper = get_proc_task(filp->f_path.dentry->d_inode);
|
|
if (!reaper)
|
|
goto out_no_task;
|
|
|
|
for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) {
|
|
const struct pid_entry *p = &proc_base_stuff[nr];
|
|
if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0)
|
|
goto out;
|
|
}
|
|
|
|
ns = filp->f_dentry->d_sb->s_fs_info;
|
|
iter.task = NULL;
|
|
iter.tgid = filp->f_pos - TGID_OFFSET;
|
|
for (iter = next_tgid(ns, iter);
|
|
iter.task;
|
|
iter.tgid += 1, iter = next_tgid(ns, iter)) {
|
|
if (has_pid_permissions(ns, iter.task, 2))
|
|
__filldir = filldir;
|
|
else
|
|
__filldir = fake_filldir;
|
|
|
|
filp->f_pos = iter.tgid + TGID_OFFSET;
|
|
if (proc_pid_fill_cache(filp, dirent, __filldir, iter) < 0) {
|
|
put_task_struct(iter.task);
|
|
goto out;
|
|
}
|
|
}
|
|
filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET;
|
|
out:
|
|
put_task_struct(reaper);
|
|
out_no_task:
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Tasks
|
|
*/
|
|
static const struct pid_entry tid_base_stuff[] = {
|
|
DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
|
|
DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
|
|
DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
|
|
REG("environ", S_IRUSR, proc_environ_operations),
|
|
INF("auxv", S_IRUSR, proc_pid_auxv),
|
|
ONE("status", S_IRUGO, proc_pid_status),
|
|
ONE("personality", S_IRUGO, proc_pid_personality),
|
|
INF("limits", S_IRUGO, proc_pid_limits),
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations),
|
|
#endif
|
|
REG("comm", S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
|
|
#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
|
|
INF("syscall", S_IRUGO, proc_pid_syscall),
|
|
#endif
|
|
INF("cmdline", S_IRUGO, proc_pid_cmdline),
|
|
ONE("stat", S_IRUGO, proc_tid_stat),
|
|
ONE("statm", S_IRUGO, proc_pid_statm),
|
|
REG("maps", S_IRUGO, proc_maps_operations),
|
|
#ifdef CONFIG_NUMA
|
|
REG("numa_maps", S_IRUGO, proc_numa_maps_operations),
|
|
#endif
|
|
REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),
|
|
LNK("cwd", proc_cwd_link),
|
|
LNK("root", proc_root_link),
|
|
LNK("exe", proc_exe_link),
|
|
REG("mounts", S_IRUGO, proc_mounts_operations),
|
|
REG("mountinfo", S_IRUGO, proc_mountinfo_operations),
|
|
#ifdef CONFIG_PROC_PAGE_MONITOR
|
|
REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
|
|
REG("smaps", S_IRUGO, proc_smaps_operations),
|
|
REG("pagemap", S_IRUGO, proc_pagemap_operations),
|
|
#endif
|
|
#ifdef CONFIG_SECURITY
|
|
DIR("attr", S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
|
|
#endif
|
|
#ifdef CONFIG_KALLSYMS
|
|
INF("wchan", S_IRUGO, proc_pid_wchan),
|
|
#endif
|
|
#ifdef CONFIG_STACKTRACE
|
|
ONE("stack", S_IRUGO, proc_pid_stack),
|
|
#endif
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
INF("schedstat", S_IRUGO, proc_pid_schedstat),
|
|
#endif
|
|
#ifdef CONFIG_LATENCYTOP
|
|
REG("latency", S_IRUGO, proc_lstats_operations),
|
|
#endif
|
|
#ifdef CONFIG_PROC_PID_CPUSET
|
|
REG("cpuset", S_IRUGO, proc_cpuset_operations),
|
|
#endif
|
|
#ifdef CONFIG_CGROUPS
|
|
REG("cgroup", S_IRUGO, proc_cgroup_operations),
|
|
#endif
|
|
INF("oom_score", S_IRUGO, proc_oom_score),
|
|
REG("oom_adj", S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
|
|
REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
|
|
#ifdef CONFIG_AUDITSYSCALL
|
|
REG("loginuid", S_IWUSR|S_IRUGO, proc_loginuid_operations),
|
|
REG("sessionid", S_IRUGO, proc_sessionid_operations),
|
|
#endif
|
|
#ifdef CONFIG_FAULT_INJECTION
|
|
REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
|
|
#endif
|
|
#ifdef CONFIG_TASK_IO_ACCOUNTING
|
|
INF("io", S_IRUSR, proc_tid_io_accounting),
|
|
#endif
|
|
#ifdef CONFIG_HARDWALL
|
|
INF("hardwall", S_IRUGO, proc_pid_hardwall),
|
|
#endif
|
|
};
|
|
|
|
static int proc_tid_base_readdir(struct file * filp,
|
|
void * dirent, filldir_t filldir)
|
|
{
|
|
return proc_pident_readdir(filp,dirent,filldir,
|
|
tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
|
|
}
|
|
|
|
static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
|
|
return proc_pident_lookup(dir, dentry,
|
|
tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
|
|
}
|
|
|
|
static const struct file_operations proc_tid_base_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_tid_base_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
static const struct inode_operations proc_tid_base_inode_operations = {
|
|
.lookup = proc_tid_base_lookup,
|
|
.getattr = pid_getattr,
|
|
.setattr = proc_setattr,
|
|
};
|
|
|
|
static struct dentry *proc_task_instantiate(struct inode *dir,
|
|
struct dentry *dentry, struct task_struct *task, const void *ptr)
|
|
{
|
|
struct dentry *error = ERR_PTR(-ENOENT);
|
|
struct inode *inode;
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
|
|
if (!inode)
|
|
goto out;
|
|
inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
|
|
inode->i_op = &proc_tid_base_inode_operations;
|
|
inode->i_fop = &proc_tid_base_operations;
|
|
inode->i_flags|=S_IMMUTABLE;
|
|
|
|
set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff,
|
|
ARRAY_SIZE(tid_base_stuff)));
|
|
|
|
d_set_d_op(dentry, &pid_dentry_operations);
|
|
|
|
d_add(dentry, inode);
|
|
/* Close the race of the process dying before we return the dentry */
|
|
if (pid_revalidate(dentry, NULL))
|
|
error = NULL;
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
|
|
{
|
|
struct dentry *result = ERR_PTR(-ENOENT);
|
|
struct task_struct *task;
|
|
struct task_struct *leader = get_proc_task(dir);
|
|
unsigned tid;
|
|
struct pid_namespace *ns;
|
|
|
|
if (!leader)
|
|
goto out_no_task;
|
|
|
|
tid = name_to_int(dentry);
|
|
if (tid == ~0U)
|
|
goto out;
|
|
|
|
ns = dentry->d_sb->s_fs_info;
|
|
rcu_read_lock();
|
|
task = find_task_by_pid_ns(tid, ns);
|
|
if (task)
|
|
get_task_struct(task);
|
|
rcu_read_unlock();
|
|
if (!task)
|
|
goto out;
|
|
if (!same_thread_group(leader, task))
|
|
goto out_drop_task;
|
|
|
|
result = proc_task_instantiate(dir, dentry, task, NULL);
|
|
out_drop_task:
|
|
put_task_struct(task);
|
|
out:
|
|
put_task_struct(leader);
|
|
out_no_task:
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Find the first tid of a thread group to return to user space.
|
|
*
|
|
* Usually this is just the thread group leader, but if the users
|
|
* buffer was too small or there was a seek into the middle of the
|
|
* directory we have more work todo.
|
|
*
|
|
* In the case of a short read we start with find_task_by_pid.
|
|
*
|
|
* In the case of a seek we start with the leader and walk nr
|
|
* threads past it.
|
|
*/
|
|
static struct task_struct *first_tid(struct task_struct *leader,
|
|
int tid, int nr, struct pid_namespace *ns)
|
|
{
|
|
struct task_struct *pos;
|
|
|
|
rcu_read_lock();
|
|
/* Attempt to start with the pid of a thread */
|
|
if (tid && (nr > 0)) {
|
|
pos = find_task_by_pid_ns(tid, ns);
|
|
if (pos && (pos->group_leader == leader))
|
|
goto found;
|
|
}
|
|
|
|
/* If nr exceeds the number of threads there is nothing todo */
|
|
pos = NULL;
|
|
if (nr && nr >= get_nr_threads(leader))
|
|
goto out;
|
|
|
|
/* If we haven't found our starting place yet start
|
|
* with the leader and walk nr threads forward.
|
|
*/
|
|
for (pos = leader; nr > 0; --nr) {
|
|
pos = next_thread(pos);
|
|
if (pos == leader) {
|
|
pos = NULL;
|
|
goto out;
|
|
}
|
|
}
|
|
found:
|
|
get_task_struct(pos);
|
|
out:
|
|
rcu_read_unlock();
|
|
return pos;
|
|
}
|
|
|
|
/*
|
|
* Find the next thread in the thread list.
|
|
* Return NULL if there is an error or no next thread.
|
|
*
|
|
* The reference to the input task_struct is released.
|
|
*/
|
|
static struct task_struct *next_tid(struct task_struct *start)
|
|
{
|
|
struct task_struct *pos = NULL;
|
|
rcu_read_lock();
|
|
if (pid_alive(start)) {
|
|
pos = next_thread(start);
|
|
if (thread_group_leader(pos))
|
|
pos = NULL;
|
|
else
|
|
get_task_struct(pos);
|
|
}
|
|
rcu_read_unlock();
|
|
put_task_struct(start);
|
|
return pos;
|
|
}
|
|
|
|
static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
|
|
struct task_struct *task, int tid)
|
|
{
|
|
char name[PROC_NUMBUF];
|
|
int len = snprintf(name, sizeof(name), "%d", tid);
|
|
return proc_fill_cache(filp, dirent, filldir, name, len,
|
|
proc_task_instantiate, task, NULL);
|
|
}
|
|
|
|
/* for the /proc/TGID/task/ directories */
|
|
static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
|
|
{
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
struct inode *inode = dentry->d_inode;
|
|
struct task_struct *leader = NULL;
|
|
struct task_struct *task;
|
|
int retval = -ENOENT;
|
|
ino_t ino;
|
|
int tid;
|
|
struct pid_namespace *ns;
|
|
|
|
task = get_proc_task(inode);
|
|
if (!task)
|
|
goto out_no_task;
|
|
rcu_read_lock();
|
|
if (pid_alive(task)) {
|
|
leader = task->group_leader;
|
|
get_task_struct(leader);
|
|
}
|
|
rcu_read_unlock();
|
|
put_task_struct(task);
|
|
if (!leader)
|
|
goto out_no_task;
|
|
retval = 0;
|
|
|
|
switch ((unsigned long)filp->f_pos) {
|
|
case 0:
|
|
ino = inode->i_ino;
|
|
if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) < 0)
|
|
goto out;
|
|
filp->f_pos++;
|
|
/* fall through */
|
|
case 1:
|
|
ino = parent_ino(dentry);
|
|
if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) < 0)
|
|
goto out;
|
|
filp->f_pos++;
|
|
/* fall through */
|
|
}
|
|
|
|
/* f_version caches the tgid value that the last readdir call couldn't
|
|
* return. lseek aka telldir automagically resets f_version to 0.
|
|
*/
|
|
ns = filp->f_dentry->d_sb->s_fs_info;
|
|
tid = (int)filp->f_version;
|
|
filp->f_version = 0;
|
|
for (task = first_tid(leader, tid, filp->f_pos - 2, ns);
|
|
task;
|
|
task = next_tid(task), filp->f_pos++) {
|
|
tid = task_pid_nr_ns(task, ns);
|
|
if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) {
|
|
/* returning this tgid failed, save it as the first
|
|
* pid for the next readir call */
|
|
filp->f_version = (u64)tid;
|
|
put_task_struct(task);
|
|
break;
|
|
}
|
|
}
|
|
out:
|
|
put_task_struct(leader);
|
|
out_no_task:
|
|
return retval;
|
|
}
|
|
|
|
static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
struct task_struct *p = get_proc_task(inode);
|
|
generic_fillattr(inode, stat);
|
|
|
|
if (p) {
|
|
stat->nlink += get_nr_threads(p);
|
|
put_task_struct(p);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct inode_operations proc_task_inode_operations = {
|
|
.lookup = proc_task_lookup,
|
|
.getattr = proc_task_getattr,
|
|
.setattr = proc_setattr,
|
|
.permission = proc_pid_permission,
|
|
};
|
|
|
|
static const struct file_operations proc_task_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_task_readdir,
|
|
.llseek = default_llseek,
|
|
};
|