mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 04:34:11 +08:00
87c31b39ab
Pull user namespace related fixes from Eric Biederman: "As these are bug fixes almost all of thes changes are marked for backporting to stable. The first change (implicitly adding MNT_NODEV on remount) addresses a regression that was created when security issues with unprivileged remount were closed. I go on to update the remount test to make it easy to detect if this issue reoccurs. Then there are a handful of mount and umount related fixes. Then half of the changes deal with the a recently discovered design bug in the permission checks of gid_map. Unix since the beginning has allowed setting group permissions on files to less than the user and other permissions (aka ---rwx---rwx). As the unix permission checks stop as soon as a group matches, and setgroups allows setting groups that can not later be dropped, results in a situtation where it is possible to legitimately use a group to assign fewer privileges to a process. Which means dropping a group can increase a processes privileges. The fix I have adopted is that gid_map is now no longer writable without privilege unless the new file /proc/self/setgroups has been set to permanently disable setgroups. The bulk of user namespace using applications even the applications using applications using user namespaces without privilege remain unaffected by this change. Unfortunately this ix breaks a couple user space applications, that were relying on the problematic behavior (one of which was tools/selftests/mount/unprivileged-remount-test.c). To hopefully prevent needing a regression fix on top of my security fix I rounded folks who work with the container implementations mostly like to be affected and encouraged them to test the changes. > So far nothing broke on my libvirt-lxc test bed. :-) > Tested with openSUSE 13.2 and libvirt 1.2.9. > Tested-by: Richard Weinberger <richard@nod.at> > Tested on Fedora20 with libvirt 1.2.11, works fine. > Tested-by: Chen Hanxiao <chenhanxiao@cn.fujitsu.com> > Ok, thanks - yes, unprivileged lxc is working fine with your kernels. > Just to be sure I was testing the right thing I also tested using > my unprivileged nsexec testcases, and they failed on setgroup/setgid > as now expected, and succeeded there without your patches. > Tested-by: Serge Hallyn <serge.hallyn@ubuntu.com> > I tested this with Sandstorm. It breaks as is and it works if I add > the setgroups thing. > Tested-by: Andy Lutomirski <luto@amacapital.net> # breaks things as designed :(" * 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace: userns: Unbreak the unprivileged remount tests userns; Correct the comment in map_write userns: Allow setting gid_maps without privilege when setgroups is disabled userns: Add a knob to disable setgroups on a per user namespace basis userns: Rename id_map_mutex to userns_state_mutex userns: Only allow the creator of the userns unprivileged mappings userns: Check euid no fsuid when establishing an unprivileged uid mapping userns: Don't allow unprivileged creation of gid mappings userns: Don't allow setgroups until a gid mapping has been setablished userns: Document what the invariant required for safe unprivileged mappings. groups: Consolidate the setgroups permission checks mnt: Clear mnt_expire during pivot_root mnt: Carefully set CL_UNPRIVILEGED in clone_mnt mnt: Move the clear of MNT_LOCKED from copy_tree to it's callers. umount: Do not allow unmounting rootfs. umount: Disallow unprivileged mount force mnt: Update unprivileged remount test mnt: Implicitly add MNT_NODEV on remount when it was implicitly added by mount
3203 lines
76 KiB
C
3203 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 {
|
|
const 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 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 seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
/*
|
|
* Rely on struct seq_operations::show() being called once
|
|
* per internal buffer allocation. See single_open(), traverse().
|
|
*/
|
|
BUG_ON(m->size < PAGE_SIZE);
|
|
m->count += get_cmdline(task, m->buf, PAGE_SIZE);
|
|
return 0;
|
|
}
|
|
|
|
static int proc_pid_auxv(struct seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ);
|
|
if (mm && !IS_ERR(mm)) {
|
|
unsigned int nwords = 0;
|
|
do {
|
|
nwords += 2;
|
|
} while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
|
|
seq_write(m, mm->saved_auxv, nwords * sizeof(mm->saved_auxv[0]));
|
|
mmput(mm);
|
|
return 0;
|
|
} else
|
|
return PTR_ERR(mm);
|
|
}
|
|
|
|
|
|
#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 seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
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 seq_printf(m, "%lu", wchan);
|
|
else
|
|
return seq_printf(m, "%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 seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
return seq_printf(m, "%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
|
|
|
|
static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
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 seq_printf(m, "%lu\n", points);
|
|
}
|
|
|
|
struct limit_names {
|
|
const char *name;
|
|
const 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 seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
unsigned int i;
|
|
unsigned long flags;
|
|
|
|
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
|
|
*/
|
|
seq_printf(m, "%-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)
|
|
seq_printf(m, "%-25s %-20s ",
|
|
lnames[i].name, "unlimited");
|
|
else
|
|
seq_printf(m, "%-25s %-20lu ",
|
|
lnames[i].name, rlim[i].rlim_cur);
|
|
|
|
if (rlim[i].rlim_max == RLIM_INFINITY)
|
|
seq_printf(m, "%-20s ", "unlimited");
|
|
else
|
|
seq_printf(m, "%-20lu ", rlim[i].rlim_max);
|
|
|
|
if (lnames[i].unit)
|
|
seq_printf(m, "%-10s\n", lnames[i].unit);
|
|
else
|
|
seq_putc(m, '\n');
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
|
|
static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
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))
|
|
seq_puts(m, "running\n");
|
|
else if (nr < 0)
|
|
seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
|
|
else
|
|
seq_printf(m,
|
|
"%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,
|
|
};
|
|
|
|
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,
|
|
};
|
|
|
|
|
|
struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode)
|
|
{
|
|
struct task_struct *task = get_proc_task(inode);
|
|
struct mm_struct *mm = ERR_PTR(-ESRCH);
|
|
|
|
if (task) {
|
|
mm = mm_access(task, mode);
|
|
put_task_struct(task);
|
|
|
|
if (!IS_ERR_OR_NULL(mm)) {
|
|
/* ensure this mm_struct can't be freed */
|
|
atomic_inc(&mm->mm_count);
|
|
/* but do not pin its memory */
|
|
mmput(mm);
|
|
}
|
|
}
|
|
|
|
return mm;
|
|
}
|
|
|
|
static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
|
|
{
|
|
struct mm_struct *mm = proc_mem_open(inode, mode);
|
|
|
|
if (IS_ERR(mm))
|
|
return PTR_ERR(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;
|
|
if (make_it_fail < 0 || make_it_fail > 1)
|
|
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;
|
|
}
|
|
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:
|
|
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;
|
|
|
|
rc = -ENOENT;
|
|
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 const char * const 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, struct seq_file *m, 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 = seq_printf(m,
|
|
"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 seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
return do_io_accounting(task, m, 0);
|
|
}
|
|
|
|
static int proc_tgid_io_accounting(struct seq_file *m, struct pid_namespace *ns,
|
|
struct pid *pid, struct task_struct *task)
|
|
{
|
|
return do_io_accounting(task, m, 1);
|
|
}
|
|
#endif /* CONFIG_TASK_IO_ACCOUNTING */
|
|
|
|
#ifdef CONFIG_USER_NS
|
|
static int proc_id_map_open(struct inode *inode, struct file *file,
|
|
const 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,
|
|
};
|
|
|
|
static int proc_setgroups_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct user_namespace *ns = NULL;
|
|
struct task_struct *task;
|
|
int ret;
|
|
|
|
ret = -ESRCH;
|
|
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;
|
|
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
ret = -EACCES;
|
|
if (!ns_capable(ns, CAP_SYS_ADMIN))
|
|
goto err_put_ns;
|
|
}
|
|
|
|
ret = single_open(file, &proc_setgroups_show, ns);
|
|
if (ret)
|
|
goto err_put_ns;
|
|
|
|
return 0;
|
|
err_put_ns:
|
|
put_user_ns(ns);
|
|
err:
|
|
return ret;
|
|
}
|
|
|
|
static int proc_setgroups_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct seq_file *seq = file->private_data;
|
|
struct user_namespace *ns = seq->private;
|
|
int ret = single_release(inode, file);
|
|
put_user_ns(ns);
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations proc_setgroups_operations = {
|
|
.open = proc_setgroups_open,
|
|
.write = proc_setgroups_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = proc_setgroups_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),
|
|
ONE("auxv", S_IRUSR, proc_pid_auxv),
|
|
ONE("status", S_IRUGO, proc_pid_status),
|
|
ONE("personality", S_IRUSR, proc_pid_personality),
|
|
ONE("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
|
|
ONE("syscall", S_IRUSR, proc_pid_syscall),
|
|
#endif
|
|
ONE("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_IRUSR, 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
|
|
ONE("wchan", S_IRUGO, proc_pid_wchan),
|
|
#endif
|
|
#ifdef CONFIG_STACKTRACE
|
|
ONE("stack", S_IRUSR, proc_pid_stack),
|
|
#endif
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
ONE("schedstat", S_IRUGO, proc_pid_schedstat),
|
|
#endif
|
|
#ifdef CONFIG_LATENCYTOP
|
|
REG("latency", S_IRUGO, proc_lstats_operations),
|
|
#endif
|
|
#ifdef CONFIG_PROC_PID_CPUSET
|
|
ONE("cpuset", S_IRUGO, proc_cpuset_show),
|
|
#endif
|
|
#ifdef CONFIG_CGROUPS
|
|
ONE("cgroup", S_IRUGO, proc_cgroup_show),
|
|
#endif
|
|
ONE("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
|
|
ONE("io", S_IRUSR, proc_tgid_io_accounting),
|
|
#endif
|
|
#ifdef CONFIG_HARDWALL
|
|
ONE("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),
|
|
REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_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) {
|
|
d_invalidate(dentry);
|
|
dput(dentry);
|
|
}
|
|
|
|
if (pid == tgid)
|
|
return;
|
|
|
|
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) {
|
|
d_invalidate(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 = -ENOENT;
|
|
struct task_struct *task;
|
|
unsigned tgid;
|
|
struct pid_namespace *ns;
|
|
|
|
tgid = name_to_int(&dentry->d_name);
|
|
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 + 2)
|
|
|
|
/* 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_inode(file)->i_sb->s_fs_info;
|
|
loff_t pos = ctx->pos;
|
|
|
|
if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
|
|
return 0;
|
|
|
|
if (pos == TGID_OFFSET - 2) {
|
|
struct inode *inode = ns->proc_self->d_inode;
|
|
if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
|
|
return 0;
|
|
ctx->pos = pos = pos + 1;
|
|
}
|
|
if (pos == TGID_OFFSET - 1) {
|
|
struct inode *inode = ns->proc_thread_self->d_inode;
|
|
if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK))
|
|
return 0;
|
|
ctx->pos = pos = pos + 1;
|
|
}
|
|
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),
|
|
#ifdef CONFIG_NET
|
|
DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
|
|
#endif
|
|
REG("environ", S_IRUSR, proc_environ_operations),
|
|
ONE("auxv", S_IRUSR, proc_pid_auxv),
|
|
ONE("status", S_IRUGO, proc_pid_status),
|
|
ONE("personality", S_IRUSR, proc_pid_personality),
|
|
ONE("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
|
|
ONE("syscall", S_IRUSR, proc_pid_syscall),
|
|
#endif
|
|
ONE("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_IRUSR, 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
|
|
ONE("wchan", S_IRUGO, proc_pid_wchan),
|
|
#endif
|
|
#ifdef CONFIG_STACKTRACE
|
|
ONE("stack", S_IRUSR, proc_pid_stack),
|
|
#endif
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
ONE("schedstat", S_IRUGO, proc_pid_schedstat),
|
|
#endif
|
|
#ifdef CONFIG_LATENCYTOP
|
|
REG("latency", S_IRUGO, proc_lstats_operations),
|
|
#endif
|
|
#ifdef CONFIG_PROC_PID_CPUSET
|
|
ONE("cpuset", S_IRUGO, proc_cpuset_show),
|
|
#endif
|
|
#ifdef CONFIG_CGROUPS
|
|
ONE("cgroup", S_IRUGO, proc_cgroup_show),
|
|
#endif
|
|
ONE("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
|
|
ONE("io", S_IRUSR, proc_tid_io_accounting),
|
|
#endif
|
|
#ifdef CONFIG_HARDWALL
|
|
ONE("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),
|
|
REG("setgroups", S_IRUGO|S_IWUSR, proc_setgroups_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->d_name);
|
|
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 = inode->i_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,
|
|
};
|