![Oleg Nesterov](/assets/img/avatar_default.png)
1. proc_task_readdir()->first_tid() path truncates f_pos to int, this is wrong even on 64bit. We could check that f_pos < PID_MAX or even INT_MAX in proc_task_readdir(), but this patch simply checks the potential overflow in first_tid(), this check is nop on 64bit. We do not care if it was negative and the new unsigned value is huge, all we need to ensure is that we never wrongly return !NULL. 2. Remove the 2nd "nr != 0" check before get_nr_threads(), nr_threads == 0 is not distinguishable from !pid_task() above. Signed-off-by: Oleg Nesterov <oleg@redhat.com> Cc: "Eric W. Biederman" <ebiederm@xmission.com> Cc: Michal Hocko <mhocko@suse.cz> Cc: Sameer Nanda <snanda@chromium.org> Cc: Sergey Dyasly <dserrg@gmail.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
3231 lines
76 KiB
C
3231 lines
76 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/printk.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/user_namespace.h>
|
|
#include <linux/fs_struct.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/flex_array.h>
|
|
#include <linux/posix-timers.h>
|
|
#ifdef CONFIG_HARDWALL
|
|
#include <asm/hardwall.h>
|
|
#endif
|
|
#include <trace/events/oom.h>
|
|
#include "internal.h"
|
|
#include "fd.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 } )
|
|
|
|
/*
|
|
* 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 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_access(task, PTRACE_MODE_READ);
|
|
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_inode(file));
|
|
|
|
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
|
|
|
|
#ifdef CONFIG_CGROUPS
|
|
static int cgroup_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct pid *pid = PROC_I(inode)->pid;
|
|
return single_open(file, proc_cgroup_show, pid);
|
|
}
|
|
|
|
static const struct file_operations proc_cgroup_operations = {
|
|
.open = cgroup_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_PROC_PID_CPUSET
|
|
|
|
static int cpuset_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct pid *pid = PROC_I(inode)->pid;
|
|
return single_open(file, proc_cpuset_show, pid);
|
|
}
|
|
|
|
static const struct file_operations proc_cpuset_operations = {
|
|
.open = cpuset_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif
|
|
|
|
static int proc_oom_score(struct task_struct *task, char *buffer)
|
|
{
|
|
unsigned long totalpages = totalram_pages + total_swap_pages;
|
|
unsigned long points = 0;
|
|
|
|
read_lock(&tasklist_lock);
|
|
if (pid_alive(task))
|
|
points = oom_badness(task, NULL, NULL, totalpages) *
|
|
1000 / totalpages;
|
|
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;
|
|
|
|
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);
|
|
if (!task)
|
|
return -ESRCH;
|
|
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_inode(file);
|
|
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, unsigned int mode)
|
|
{
|
|
struct task_struct *task = get_proc_task(file_inode(file));
|
|
struct mm_struct *mm;
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
|
|
mm = mm_access(task, mode);
|
|
put_task_struct(task);
|
|
|
|
if (IS_ERR(mm))
|
|
return PTR_ERR(mm);
|
|
|
|
if (mm) {
|
|
/* ensure this mm_struct can't be freed */
|
|
atomic_inc(&mm->mm_count);
|
|
/* but do not pin its memory */
|
|
mmput(mm);
|
|
}
|
|
|
|
file->private_data = mm;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mem_open(struct inode *inode, struct file *file)
|
|
{
|
|
int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH);
|
|
|
|
/* OK to pass negative loff_t, we can catch out-of-range */
|
|
file->f_mode |= FMODE_UNSIGNED_OFFSET;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t mem_rw(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos, int write)
|
|
{
|
|
struct mm_struct *mm = file->private_data;
|
|
unsigned long addr = *ppos;
|
|
ssize_t copied;
|
|
char *page;
|
|
|
|
if (!mm)
|
|
return 0;
|
|
|
|
page = (char *)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
return -ENOMEM;
|
|
|
|
copied = 0;
|
|
if (!atomic_inc_not_zero(&mm->mm_users))
|
|
goto free;
|
|
|
|
while (count > 0) {
|
|
int this_len = min_t(int, count, PAGE_SIZE);
|
|
|
|
if (write && copy_from_user(page, buf, this_len)) {
|
|
copied = -EFAULT;
|
|
break;
|
|
}
|
|
|
|
this_len = access_remote_vm(mm, addr, page, this_len, write);
|
|
if (!this_len) {
|
|
if (!copied)
|
|
copied = -EIO;
|
|
break;
|
|
}
|
|
|
|
if (!write && copy_to_user(buf, page, this_len)) {
|
|
copied = -EFAULT;
|
|
break;
|
|
}
|
|
|
|
buf += this_len;
|
|
addr += this_len;
|
|
copied += this_len;
|
|
count -= this_len;
|
|
}
|
|
*ppos = addr;
|
|
|
|
mmput(mm);
|
|
free:
|
|
free_page((unsigned long) page);
|
|
return copied;
|
|
}
|
|
|
|
static ssize_t mem_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
return mem_rw(file, buf, count, ppos, 0);
|
|
}
|
|
|
|
static ssize_t mem_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
return mem_rw(file, (char __user*)buf, count, ppos, 1);
|
|
}
|
|
|
|
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 int mem_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct mm_struct *mm = file->private_data;
|
|
if (mm)
|
|
mmdrop(mm);
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations proc_mem_operations = {
|
|
.llseek = mem_lseek,
|
|
.read = mem_read,
|
|
.write = mem_write,
|
|
.open = mem_open,
|
|
.release = mem_release,
|
|
};
|
|
|
|
static int environ_open(struct inode *inode, struct file *file)
|
|
{
|
|
return __mem_open(inode, file, PTRACE_MODE_READ);
|
|
}
|
|
|
|
static ssize_t environ_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
char *page;
|
|
unsigned long src = *ppos;
|
|
int ret = 0;
|
|
struct mm_struct *mm = file->private_data;
|
|
|
|
if (!mm)
|
|
return 0;
|
|
|
|
page = (char *)__get_free_page(GFP_TEMPORARY);
|
|
if (!page)
|
|
return -ENOMEM;
|
|
|
|
ret = 0;
|
|
if (!atomic_inc_not_zero(&mm->mm_users))
|
|
goto free;
|
|
while (count > 0) {
|
|
size_t this_len, max_len;
|
|
int retval;
|
|
|
|
if (src >= (mm->env_end - mm->env_start))
|
|
break;
|
|
|
|
this_len = mm->env_end - (mm->env_start + src);
|
|
|
|
max_len = min_t(size_t, PAGE_SIZE, count);
|
|
this_len = min(max_len, this_len);
|
|
|
|
retval = access_remote_vm(mm, (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);
|
|
|
|
free:
|
|
free_page((unsigned long) page);
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_environ_operations = {
|
|
.open = environ_open,
|
|
.read = environ_read,
|
|
.llseek = generic_file_llseek,
|
|
.release = mem_release,
|
|
};
|
|
|
|
static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
struct task_struct *task = get_proc_task(file_inode(file));
|
|
char buffer[PROC_NUMBUF];
|
|
int oom_adj = OOM_ADJUST_MIN;
|
|
size_t len;
|
|
unsigned long flags;
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
if (lock_task_sighand(task, &flags)) {
|
|
if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX)
|
|
oom_adj = OOM_ADJUST_MAX;
|
|
else
|
|
oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) /
|
|
OOM_SCORE_ADJ_MAX;
|
|
unlock_task_sighand(task, &flags);
|
|
}
|
|
put_task_struct(task);
|
|
len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj);
|
|
return simple_read_from_buffer(buf, count, ppos, buffer, len);
|
|
}
|
|
|
|
static ssize_t oom_adj_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct task_struct *task;
|
|
char buffer[PROC_NUMBUF];
|
|
int oom_adj;
|
|
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_adj);
|
|
if (err)
|
|
goto out;
|
|
if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) &&
|
|
oom_adj != OOM_DISABLE) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
task = get_proc_task(file_inode(file));
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
|
|
* value is always attainable.
|
|
*/
|
|
if (oom_adj == OOM_ADJUST_MAX)
|
|
oom_adj = OOM_SCORE_ADJ_MAX;
|
|
else
|
|
oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
|
|
|
|
if (oom_adj < task->signal->oom_score_adj &&
|
|
!capable(CAP_SYS_RESOURCE)) {
|
|
err = -EACCES;
|
|
goto err_sighand;
|
|
}
|
|
|
|
/*
|
|
* /proc/pid/oom_adj is provided for legacy purposes, ask users to use
|
|
* /proc/pid/oom_score_adj instead.
|
|
*/
|
|
pr_warn_once("%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_score_adj = oom_adj;
|
|
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_adj_operations = {
|
|
.read = oom_adj_read,
|
|
.write = oom_adj_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_inode(file));
|
|
char buffer[PROC_NUMBUF];
|
|
short 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), "%hd\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_inode(file));
|
|
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 ((short)oom_score_adj < task->signal->oom_score_adj_min &&
|
|
!capable(CAP_SYS_RESOURCE)) {
|
|
err = -EACCES;
|
|
goto err_sighand;
|
|
}
|
|
|
|
task->signal->oom_score_adj = (short)oom_score_adj;
|
|
if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
|
|
task->signal->oom_score_adj_min = (short)oom_score_adj;
|
|
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_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_inode(file);
|
|
struct task_struct *task = get_proc_task(inode);
|
|
ssize_t length;
|
|
char tmpbuf[TMPBUFLEN];
|
|
|
|
if (!task)
|
|
return -ESRCH;
|
|
length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
|
|
from_kuid(file->f_cred->user_ns,
|
|
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_inode(file);
|
|
char *page, *tmp;
|
|
ssize_t length;
|
|
uid_t loginuid;
|
|
kuid_t kloginuid;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
/* is userspace tring to explicitly UNSET the loginuid? */
|
|
if (loginuid == AUDIT_UID_UNSET) {
|
|
kloginuid = INVALID_UID;
|
|
} else {
|
|
kloginuid = make_kuid(file->f_cred->user_ns, loginuid);
|
|
if (!uid_valid(kloginuid)) {
|
|
length = -EINVAL;
|
|
goto out_free_page;
|
|
}
|
|
}
|
|
|
|
length = audit_set_loginuid(kloginuid);
|
|
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_inode(file);
|
|
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_inode(file));
|
|
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_inode(file));
|
|
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_inode(file);
|
|
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_inode(file);
|
|
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 = proc_sched_autogroup_set_nice(p, nice);
|
|
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_inode(file);
|
|
struct task_struct *p;
|
|
char buffer[TASK_COMM_LEN];
|
|
const size_t maxlen = sizeof(buffer) - 1;
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
if (copy_from_user(buffer, buf, count > maxlen ? maxlen : 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;
|
|
struct path path;
|
|
int error = -EACCES;
|
|
|
|
/* 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;
|
|
|
|
nd_jump_link(nd, &path);
|
|
return NULL;
|
|
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;
|
|
}
|
|
|
|
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 */
|
|
|
|
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 = GLOBAL_ROOT_UID;
|
|
stat->gid = GLOBAL_ROOT_GID;
|
|
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, unsigned int flags)
|
|
{
|
|
struct inode *inode;
|
|
struct task_struct *task;
|
|
const struct cred *cred;
|
|
|
|
if (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 = GLOBAL_ROOT_UID;
|
|
inode->i_gid = GLOBAL_ROOT_GID;
|
|
}
|
|
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 inline bool proc_inode_is_dead(struct inode *inode)
|
|
{
|
|
return !proc_pid(inode)->tasks[PIDTYPE_PID].first;
|
|
}
|
|
|
|
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_inode_is_dead(dentry->d_inode);
|
|
}
|
|
|
|
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.
|
|
*/
|
|
bool proc_fill_cache(struct file *file, struct dir_context *ctx,
|
|
const char *name, int len,
|
|
instantiate_t instantiate, struct task_struct *task, const void *ptr)
|
|
{
|
|
struct dentry *child, *dir = file->f_path.dentry;
|
|
struct qstr qname = QSTR_INIT(name, len);
|
|
struct inode *inode;
|
|
unsigned type;
|
|
ino_t ino;
|
|
|
|
child = d_hash_and_lookup(dir, &qname);
|
|
if (!child) {
|
|
child = d_alloc(dir, &qname);
|
|
if (!child)
|
|
goto end_instantiate;
|
|
if (instantiate(dir->d_inode, child, task, ptr) < 0) {
|
|
dput(child);
|
|
goto end_instantiate;
|
|
}
|
|
}
|
|
inode = child->d_inode;
|
|
ino = inode->i_ino;
|
|
type = inode->i_mode >> 12;
|
|
dput(child);
|
|
return dir_emit(ctx, name, len, ino, type);
|
|
|
|
end_instantiate:
|
|
return dir_emit(ctx, name, len, 1, DT_UNKNOWN);
|
|
}
|
|
|
|
#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, unsigned int flags)
|
|
{
|
|
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 (flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
status = -EPERM;
|
|
goto out_notask;
|
|
}
|
|
|
|
inode = dentry->d_inode;
|
|
task = get_proc_task(inode);
|
|
if (!task)
|
|
goto out_notask;
|
|
|
|
mm = mm_access(task, PTRACE_MODE_READ);
|
|
if (IS_ERR_OR_NULL(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 = GLOBAL_ROOT_UID;
|
|
inode->i_gid = GLOBAL_ROOT_GID;
|
|
}
|
|
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 {
|
|
fmode_t mode;
|
|
unsigned long len;
|
|
unsigned char name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
|
|
};
|
|
|
|
static int
|
|
proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
|
|
struct task_struct *task, const void *ptr)
|
|
{
|
|
fmode_t mode = (fmode_t)(unsigned long)ptr;
|
|
struct proc_inode *ei;
|
|
struct inode *inode;
|
|
|
|
inode = proc_pid_make_inode(dir->i_sb, task);
|
|
if (!inode)
|
|
return -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 (mode & FMODE_READ)
|
|
inode->i_mode |= S_IRUSR;
|
|
if (mode & FMODE_WRITE)
|
|
inode->i_mode |= S_IWUSR;
|
|
|
|
d_set_d_op(dentry, &tid_map_files_dentry_operations);
|
|
d_add(dentry, inode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct dentry *proc_map_files_lookup(struct inode *dir,
|
|
struct dentry *dentry, unsigned int flags)
|
|
{
|
|
unsigned long vm_start, vm_end;
|
|
struct vm_area_struct *vma;
|
|
struct task_struct *task;
|
|
int result;
|
|
struct mm_struct *mm;
|
|
|
|
result = -EPERM;
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
goto out;
|
|
|
|
result = -ENOENT;
|
|
task = get_proc_task(dir);
|
|
if (!task)
|
|
goto out;
|
|
|
|
result = -EACCES;
|
|
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
|
goto out_put_task;
|
|
|
|
result = -ENOENT;
|
|
if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
|
|
goto out_put_task;
|
|
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out_put_task;
|
|
|
|
down_read(&mm->mmap_sem);
|
|
vma = find_exact_vma(mm, vm_start, vm_end);
|
|
if (!vma)
|
|
goto out_no_vma;
|
|
|
|
if (vma->vm_file)
|
|
result = proc_map_files_instantiate(dir, dentry, task,
|
|
(void *)(unsigned long)vma->vm_file->f_mode);
|
|
|
|
out_no_vma:
|
|
up_read(&mm->mmap_sem);
|
|
mmput(mm);
|
|
out_put_task:
|
|
put_task_struct(task);
|
|
out:
|
|
return ERR_PTR(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 *file, struct dir_context *ctx)
|
|
{
|
|
struct vm_area_struct *vma;
|
|
struct task_struct *task;
|
|
struct mm_struct *mm;
|
|
unsigned long nr_files, pos, i;
|
|
struct flex_array *fa = NULL;
|
|
struct map_files_info info;
|
|
struct map_files_info *p;
|
|
int ret;
|
|
|
|
ret = -EPERM;
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
goto out;
|
|
|
|
ret = -ENOENT;
|
|
task = get_proc_task(file_inode(file));
|
|
if (!task)
|
|
goto out;
|
|
|
|
ret = -EACCES;
|
|
if (!ptrace_may_access(task, PTRACE_MODE_READ))
|
|
goto out_put_task;
|
|
|
|
ret = 0;
|
|
if (!dir_emit_dots(file, ctx))
|
|
goto out_put_task;
|
|
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
goto out_put_task;
|
|
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 > ctx->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_put_task;
|
|
}
|
|
for (i = 0, vma = mm->mmap, pos = 2; vma;
|
|
vma = vma->vm_next) {
|
|
if (!vma->vm_file)
|
|
continue;
|
|
if (++pos <= ctx->pos)
|
|
continue;
|
|
|
|
info.mode = vma->vm_file->f_mode;
|
|
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);
|
|
if (!proc_fill_cache(file, ctx,
|
|
p->name, p->len,
|
|
proc_map_files_instantiate,
|
|
task,
|
|
(void *)(unsigned long)p->mode))
|
|
break;
|
|
ctx->pos++;
|
|
}
|
|
if (fa)
|
|
flex_array_free(fa);
|
|
mmput(mm);
|
|
|
|
out_put_task:
|
|
put_task_struct(task);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_map_files_operations = {
|
|
.read = generic_read_dir,
|
|
.iterate = proc_map_files_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
struct timers_private {
|
|
struct pid *pid;
|
|
struct task_struct *task;
|
|
struct sighand_struct *sighand;
|
|
struct pid_namespace *ns;
|
|
unsigned long flags;
|
|
};
|
|
|
|
static void *timers_start(struct seq_file *m, loff_t *pos)
|
|
{
|
|
struct timers_private *tp = m->private;
|
|
|
|
tp->task = get_pid_task(tp->pid, PIDTYPE_PID);
|
|
if (!tp->task)
|
|
return ERR_PTR(-ESRCH);
|
|
|
|
tp->sighand = lock_task_sighand(tp->task, &tp->flags);
|
|
if (!tp->sighand)
|
|
return ERR_PTR(-ESRCH);
|
|
|
|
return seq_list_start(&tp->task->signal->posix_timers, *pos);
|
|
}
|
|
|
|
static void *timers_next(struct seq_file *m, void *v, loff_t *pos)
|
|
{
|
|
struct timers_private *tp = m->private;
|
|
return seq_list_next(v, &tp->task->signal->posix_timers, pos);
|
|
}
|
|
|
|
static void timers_stop(struct seq_file *m, void *v)
|
|
{
|
|
struct timers_private *tp = m->private;
|
|
|
|
if (tp->sighand) {
|
|
unlock_task_sighand(tp->task, &tp->flags);
|
|
tp->sighand = NULL;
|
|
}
|
|
|
|
if (tp->task) {
|
|
put_task_struct(tp->task);
|
|
tp->task = NULL;
|
|
}
|
|
}
|
|
|
|
static int show_timer(struct seq_file *m, void *v)
|
|
{
|
|
struct k_itimer *timer;
|
|
struct timers_private *tp = m->private;
|
|
int notify;
|
|
static char *nstr[] = {
|
|
[SIGEV_SIGNAL] = "signal",
|
|
[SIGEV_NONE] = "none",
|
|
[SIGEV_THREAD] = "thread",
|
|
};
|
|
|
|
timer = list_entry((struct list_head *)v, struct k_itimer, list);
|
|
notify = timer->it_sigev_notify;
|
|
|
|
seq_printf(m, "ID: %d\n", timer->it_id);
|
|
seq_printf(m, "signal: %d/%p\n", timer->sigq->info.si_signo,
|
|
timer->sigq->info.si_value.sival_ptr);
|
|
seq_printf(m, "notify: %s/%s.%d\n",
|
|
nstr[notify & ~SIGEV_THREAD_ID],
|
|
(notify & SIGEV_THREAD_ID) ? "tid" : "pid",
|
|
pid_nr_ns(timer->it_pid, tp->ns));
|
|
seq_printf(m, "ClockID: %d\n", timer->it_clock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct seq_operations proc_timers_seq_ops = {
|
|
.start = timers_start,
|
|
.next = timers_next,
|
|
.stop = timers_stop,
|
|
.show = show_timer,
|
|
};
|
|
|
|
static int proc_timers_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct timers_private *tp;
|
|
|
|
tp = __seq_open_private(file, &proc_timers_seq_ops,
|
|
sizeof(struct timers_private));
|
|
if (!tp)
|
|
return -ENOMEM;
|
|
|
|
tp->pid = proc_pid(inode);
|
|
tp->ns = inode->i_sb->s_fs_info;
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations proc_timers_operations = {
|
|
.open = proc_timers_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = seq_release_private,
|
|
};
|
|
#endif /* CONFIG_CHECKPOINT_RESTORE */
|
|
|
|
static int 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;
|
|
|
|
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, 0))
|
|
return 0;
|
|
out:
|
|
return -ENOENT;
|
|
}
|
|
|
|
static struct dentry *proc_pident_lookup(struct inode *dir,
|
|
struct dentry *dentry,
|
|
const struct pid_entry *ents,
|
|
unsigned int nents)
|
|
{
|
|
int error;
|
|
struct task_struct *task = get_proc_task(dir);
|
|
const struct pid_entry *p, *last;
|
|
|
|
error = -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 ERR_PTR(error);
|
|
}
|
|
|
|
static int proc_pident_readdir(struct file *file, struct dir_context *ctx,
|
|
const struct pid_entry *ents, unsigned int nents)
|
|
{
|
|
struct task_struct *task = get_proc_task(file_inode(file));
|
|
const struct pid_entry *p;
|
|
|
|
if (!task)
|
|
return -ENOENT;
|
|
|
|
if (!dir_emit_dots(file, ctx))
|
|
goto out;
|
|
|
|
if (ctx->pos >= nents + 2)
|
|
goto out;
|
|
|
|
for (p = ents + (ctx->pos - 2); p <= ents + nents - 1; p++) {
|
|
if (!proc_fill_cache(file, ctx, p->name, p->len,
|
|
proc_pident_instantiate, task, p))
|
|
break;
|
|
ctx->pos++;
|
|
}
|
|
out:
|
|
put_task_struct(task);
|
|
return 0;
|
|
}
|
|
|
|
#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_inode(file);
|
|
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_inode(file);
|
|
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 *file, struct dir_context *ctx)
|
|
{
|
|
return proc_pident_readdir(file, ctx,
|
|
attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
|
|
}
|
|
|
|
static const struct file_operations proc_attr_dir_operations = {
|
|
.read = generic_read_dir,
|
|
.iterate = proc_attr_dir_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
static struct dentry *proc_attr_dir_lookup(struct inode *dir,
|
|
struct dentry *dentry, unsigned int flags)
|
|
{
|
|
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_inode(file));
|
|
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_inode(file));
|
|
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
|
|
|
|
#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 */
|
|
|
|
#ifdef CONFIG_USER_NS
|
|
static int proc_id_map_open(struct inode *inode, struct file *file,
|
|
struct seq_operations *seq_ops)
|
|
{
|
|
struct user_namespace *ns = NULL;
|
|
struct task_struct *task;
|
|
struct seq_file *seq;
|
|
int ret = -EINVAL;
|
|
|
|
task = get_proc_task(inode);
|
|
if (task) {
|
|
rcu_read_lock();
|
|
ns = get_user_ns(task_cred_xxx(task, user_ns));
|
|
rcu_read_unlock();
|
|
put_task_struct(task);
|
|
}
|
|
if (!ns)
|
|
goto err;
|
|
|
|
ret = seq_open(file, seq_ops);
|
|
if (ret)
|
|
goto err_put_ns;
|
|
|
|
seq = file->private_data;
|
|
seq->private = ns;
|
|
|
|
return 0;
|
|
err_put_ns:
|
|
put_user_ns(ns);
|
|
err:
|
|
return ret;
|
|
}
|
|
|
|
static int proc_id_map_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct seq_file *seq = file->private_data;
|
|
struct user_namespace *ns = seq->private;
|
|
put_user_ns(ns);
|
|
return seq_release(inode, file);
|
|
}
|
|
|
|
static int proc_uid_map_open(struct inode *inode, struct file *file)
|
|
{
|
|
return proc_id_map_open(inode, file, &proc_uid_seq_operations);
|
|
}
|
|
|
|
static int proc_gid_map_open(struct inode *inode, struct file *file)
|
|
{
|
|
return proc_id_map_open(inode, file, &proc_gid_seq_operations);
|
|
}
|
|
|
|
static int proc_projid_map_open(struct inode *inode, struct file *file)
|
|
{
|
|
return proc_id_map_open(inode, file, &proc_projid_seq_operations);
|
|
}
|
|
|
|
static const struct file_operations proc_uid_map_operations = {
|
|
.open = proc_uid_map_open,
|
|
.write = proc_uid_map_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = proc_id_map_release,
|
|
};
|
|
|
|
static const struct file_operations proc_gid_map_operations = {
|
|
.open = proc_gid_map_open,
|
|
.write = proc_gid_map_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = proc_id_map_release,
|
|
};
|
|
|
|
static const struct file_operations proc_projid_map_operations = {
|
|
.open = proc_projid_map_open,
|
|
.write = proc_projid_map_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = proc_id_map_release,
|
|
};
|
|
#endif /* CONFIG_USER_NS */
|
|
|
|
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_pid_maps_operations),
|
|
#ifdef CONFIG_NUMA
|
|
REG("numa_maps", S_IRUGO, proc_pid_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_pid_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_adj_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
|
|
#ifdef CONFIG_USER_NS
|
|
REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations),
|
|
REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations),
|
|
REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
|
|
#endif
|
|
#ifdef CONFIG_CHECKPOINT_RESTORE
|
|
REG("timers", S_IRUGO, proc_timers_operations),
|
|
#endif
|
|
};
|
|
|
|
static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)
|
|
{
|
|
return proc_pident_readdir(file, ctx,
|
|
tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
|
|
}
|
|
|
|
static const struct file_operations proc_tgid_base_operations = {
|
|
.read = generic_read_dir,
|
|
.iterate = proc_tgid_base_readdir,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
|
|
{
|
|
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);
|
|
/* no ->d_hash() rejects on procfs */
|
|
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);
|
|
}
|
|
}
|
|
|
|
static int proc_pid_instantiate(struct inode *dir,
|
|
struct dentry * dentry,
|
|
struct task_struct *task, const void *ptr)
|
|
{
|
|
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, 0))
|
|
return 0;
|
|
out:
|
|
return -ENOENT;
|
|
}
|
|
|
|
struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
|
|
{
|
|
int result = 0;
|
|
struct task_struct *task;
|
|
unsigned tgid;
|
|
struct pid_namespace *ns;
|
|
|
|
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 ERR_PTR(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 + 1)
|
|
|
|
/* for the /proc/ directory itself, after non-process stuff has been done */
|
|
int proc_pid_readdir(struct file *file, struct dir_context *ctx)
|
|
{
|
|
struct tgid_iter iter;
|
|
struct pid_namespace *ns = file->f_dentry->d_sb->s_fs_info;
|
|
loff_t pos = ctx->pos;
|
|
|
|
if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
|
|
return 0;
|
|
|
|
if (pos == TGID_OFFSET - 1) {
|
|
struct inode *inode = ns->proc_self->d_inode;
|
|
if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
|
|
return 0;
|
|
iter.tgid = 0;
|
|
} else {
|
|
iter.tgid = pos - TGID_OFFSET;
|
|
}
|
|
iter.task = NULL;
|
|
for (iter = next_tgid(ns, iter);
|
|
iter.task;
|
|
iter.tgid += 1, iter = next_tgid(ns, iter)) {
|
|
char name[PROC_NUMBUF];
|
|
int len;
|
|
if (!has_pid_permissions(ns, iter.task, 2))
|
|
continue;
|
|
|
|
len = snprintf(name, sizeof(name), "%d", iter.tgid);
|
|
ctx->pos = iter.tgid + TGID_OFFSET;
|
|
if (!proc_fill_cache(file, ctx, name, len,
|
|
proc_pid_instantiate, iter.task, NULL)) {
|
|
put_task_struct(iter.task);
|
|
return 0;
|
|
}
|
|
}
|
|
ctx->pos = PID_MAX_LIMIT + TGID_OFFSET;
|
|
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_tid_maps_operations),
|
|
#ifdef CONFIG_CHECKPOINT_RESTORE
|
|
REG("children", S_IRUGO, proc_tid_children_operations),
|
|
#endif
|
|
#ifdef CONFIG_NUMA
|
|
REG("numa_maps", S_IRUGO, proc_tid_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_tid_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_adj_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
|
|
#ifdef CONFIG_USER_NS
|
|
REG("uid_map", S_IRUGO|S_IWUSR, proc_uid_map_operations),
|
|
REG("gid_map", S_IRUGO|S_IWUSR, proc_gid_map_operations),
|
|
REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
|
|
#endif
|
|
};
|
|
|
|
static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx)
|
|
{
|
|
return proc_pident_readdir(file, ctx,
|
|
tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
|
|
}
|
|
|
|
static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
|
|
{
|
|
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,
|
|
.iterate = 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 int proc_task_instantiate(struct inode *dir,
|
|
struct dentry *dentry, struct task_struct *task, const void *ptr)
|
|
{
|
|
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, 0))
|
|
return 0;
|
|
out:
|
|
return -ENOENT;
|
|
}
|
|
|
|
static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
|
|
{
|
|
int result = -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 ERR_PTR(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 pid *pid, int tid, loff_t f_pos,
|
|
struct pid_namespace *ns)
|
|
{
|
|
struct task_struct *pos, *task;
|
|
unsigned long nr = f_pos;
|
|
|
|
if (nr != f_pos) /* 32bit overflow? */
|
|
return NULL;
|
|
|
|
rcu_read_lock();
|
|
task = pid_task(pid, PIDTYPE_PID);
|
|
if (!task)
|
|
goto fail;
|
|
|
|
/* Attempt to start with the tid of a thread */
|
|
if (tid && nr) {
|
|
pos = find_task_by_pid_ns(tid, ns);
|
|
if (pos && same_thread_group(pos, task))
|
|
goto found;
|
|
}
|
|
|
|
/* If nr exceeds the number of threads there is nothing todo */
|
|
if (nr >= get_nr_threads(task))
|
|
goto fail;
|
|
|
|
/* If we haven't found our starting place yet start
|
|
* with the leader and walk nr threads forward.
|
|
*/
|
|
pos = task = task->group_leader;
|
|
do {
|
|
if (!nr--)
|
|
goto found;
|
|
} while_each_thread(task, pos);
|
|
fail:
|
|
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;
|
|
}
|
|
|
|
/* for the /proc/TGID/task/ directories */
|
|
static int proc_task_readdir(struct file *file, struct dir_context *ctx)
|
|
{
|
|
struct inode *inode = file_inode(file);
|
|
struct task_struct *task;
|
|
struct pid_namespace *ns;
|
|
int tid;
|
|
|
|
if (proc_inode_is_dead(inode))
|
|
return -ENOENT;
|
|
|
|
if (!dir_emit_dots(file, ctx))
|
|
return 0;
|
|
|
|
/* f_version caches the tgid value that the last readdir call couldn't
|
|
* return. lseek aka telldir automagically resets f_version to 0.
|
|
*/
|
|
ns = file->f_dentry->d_sb->s_fs_info;
|
|
tid = (int)file->f_version;
|
|
file->f_version = 0;
|
|
for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);
|
|
task;
|
|
task = next_tid(task), ctx->pos++) {
|
|
char name[PROC_NUMBUF];
|
|
int len;
|
|
tid = task_pid_nr_ns(task, ns);
|
|
len = snprintf(name, sizeof(name), "%d", tid);
|
|
if (!proc_fill_cache(file, ctx, name, len,
|
|
proc_task_instantiate, task, NULL)) {
|
|
/* returning this tgid failed, save it as the first
|
|
* pid for the next readir call */
|
|
file->f_version = (u64)tid;
|
|
put_task_struct(task);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
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,
|
|
.iterate = proc_task_readdir,
|
|
.llseek = default_llseek,
|
|
};
|