// SPDX-License-Identifier: GPL-2.0

/*

* 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 <[email protected]>

* Edjard Mota <[email protected]>

* Ilias Biris <[email protected]>

* Mauricio Lin <[email protected]>

*

* 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 <[email protected]>:

* Smaps information related to shared, private, clean and dirty pages.

*

* Paul Mundt <[email protected]>:

* Overall revision about smaps.

*/

#include <linux/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/generic-radix-tree.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/printk.h>

#include <linux/cache.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_parser.h>

#include <linux/fs_struct.h>

#include <linux/slab.h>

#include <linux/sched/autogroup.h>

#include <linux/sched/mm.h>

#include <linux/sched/coredump.h>

#include <linux/sched/debug.h>

#include <linux/sched/stat.h>

#include <linux/posix-timers.h>

#include <linux/time_namespace.h>

#include <linux/resctrl.h>

#include <linux/cn_proc.h>

#include <linux/ksm.h>

#include <uapi/linux/lsm.h>

#include <trace/events/oom.h>

#include "internal.h"

#include "fd.h"

#include "../../lib/kstrtox.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.

*/

static u8 nlink_tid __ro_after_init;

static u8 nlink_tgid __ro_after_init;

enum proc_mem_force {

PROC_MEM_FORCE_ALWAYS,

PROC_MEM_FORCE_PTRACE,

PROC_MEM_FORCE_NEVER

};

static enum proc_mem_force proc_mem_force_override __ro_after_init =

IS_ENABLED(CONFIG_PROC_MEM_NO_FORCE) ? PROC_MEM_FORCE_NEVER :

IS_ENABLED(CONFIG_PROC_MEM_FORCE_PTRACE) ? PROC_MEM_FORCE_PTRACE :

PROC_MEM_FORCE_ALWAYS;

static const struct constant_table proc_mem_force_table[] __initconst = {

{ "always", PROC_MEM_FORCE_ALWAYS },

{ "ptrace", PROC_MEM_FORCE_PTRACE },

{ "never", PROC_MEM_FORCE_NEVER },

{ }

};

static int __init early_proc_mem_force_override(char *buf)

{

if (!buf)

return -EINVAL;

/*

* lookup_constant() defaults to proc_mem_force_override to preseve

* the initial Kconfig choice in case an invalid param gets passed.

*/

proc_mem_force_override = lookup_constant(proc_mem_force_table,

buf, proc_mem_force_override);

return 0;

}

early_param("proc_mem.force_override", early_proc_mem_force_override);

struct pid_entry {

const char *name;

unsigned 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 } )

#define ATTR(LSMID, NAME, MODE) \

NOD(NAME, (S_IFREG|(MODE)), \

NULL, &proc_pid_attr_operations, \

{ .lsmid = LSMID })

/*

* Count the number of hardlinks for the pid_entry table, excluding the .

* and .. links.

*/

static unsigned int __init pid_entry_nlink(const struct pid_entry *entries,

unsigned int n)

{

unsigned int i;

unsigned int count;

count = 2;

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(d_inode(dentry));

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(d_inode(dentry));

int result = -ENOENT;

if (task) {

result = get_task_root(task, path);

put_task_struct(task);

}

return result;

}

/*

* If the user used setproctitle(), we just get the string from

* user space at arg_start, and limit it to a maximum of one page.

*/

static ssize_t get_mm_proctitle(struct mm_struct *mm, char __user *buf,

size_t count, unsigned long pos,

unsigned long arg_start)

{

char *page;

int ret, got;

if (pos >= PAGE_SIZE)

return 0;

page = (char *)__get_free_page(GFP_KERNEL);

if (!page)

return -ENOMEM;

ret = 0;

got = access_remote_vm(mm, arg_start, page, PAGE_SIZE, FOLL_ANON);

if (got > 0) {

int len = strnlen(page, got);

/* Include the NUL character if it was found */

if (len < got)

len++;

if (len > pos) {

len -= pos;

if (len > count)

len = count;

len -= copy_to_user(buf, page+pos, len);

if (!len)

len = -EFAULT;

ret = len;

}

}

free_page((unsigned long)page);

return ret;

}

static ssize_t get_mm_cmdline(struct mm_struct *mm, char __user *buf,

size_t count, loff_t *ppos)

{

unsigned long arg_start, arg_end, env_start, env_end;

unsigned long pos, len;

char *page, c;

/* Check if process spawned far enough to have cmdline. */

if (!mm->env_end)

return 0;

spin_lock(&mm->arg_lock);

arg_start = mm->arg_start;

arg_end = mm->arg_end;

env_start = mm->env_start;

env_end = mm->env_end;

spin_unlock(&mm->arg_lock);

if (arg_start >= arg_end)

return 0;

/*

* We allow setproctitle() to overwrite the argument

* strings, and overflow past the original end. But

* only when it overflows into the environment area.

*/

if (env_start != arg_end || env_end < env_start)

env_start = env_end = arg_end;

len = env_end - arg_start;

/* We're not going to care if "*ppos" has high bits set */

pos = *ppos;

if (pos >= len)

return 0;

if (count > len - pos)

count = len - pos;

if (!count)

return 0;

/*

* Magical special case: if the argv[] end byte is not

* zero, the user has overwritten it with setproctitle(3).

*

* Possible future enhancement: do this only once when

* pos is 0, and set a flag in the 'struct file'.

*/

if (access_remote_vm(mm, arg_end-1, &c, 1, FOLL_ANON) == 1 && c)

return get_mm_proctitle(mm, buf, count, pos, arg_start);

/*

* For the non-setproctitle() case we limit things strictly

* to the [arg_start, arg_end[ range.

*/

pos += arg_start;

if (pos < arg_start || pos >= arg_end)

return 0;

if (count > arg_end - pos)

count = arg_end - pos;

page = (char *)__get_free_page(GFP_KERNEL);

if (!page)

return -ENOMEM;

len = 0;

while (count) {

int got;

size_t size = min_t(size_t, PAGE_SIZE, count);

got = access_remote_vm(mm, pos, page, size, FOLL_ANON);

if (got <= 0)

break;

got -= copy_to_user(buf, page, got);

if (unlikely(!got)) {

if (!len)

len = -EFAULT;

break;

}

pos += got;

buf += got;

len += got;

count -= got;

}

free_page((unsigned long)page);

return len;

}

static ssize_t get_task_cmdline(struct task_struct *tsk, char __user *buf,

size_t count, loff_t *pos)

{

struct mm_struct *mm;

ssize_t ret;

mm = get_task_mm(tsk);

if (!mm)

return 0;

ret = get_mm_cmdline(mm, buf, count, pos);

mmput(mm);

return ret;

}

static ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf,

size_t count, loff_t *pos)

{

struct task_struct *tsk;

ssize_t ret;

BUG_ON(*pos < 0);

tsk = get_proc_task(file_inode(file));

if (!tsk)

return -ESRCH;

ret = get_task_cmdline(tsk, buf, count, pos);

put_task_struct(tsk);

if (ret > 0)

*pos += ret;

return ret;

}

static const struct file_operations proc_pid_cmdline_ops = {

.read = proc_pid_cmdline_read,

.llseek = generic_file_llseek,

};

#ifdef CONFIG_KALLSYMS

/*

* Provides a wchan file via kallsyms in a proper one-value-per-file format.

* Returns the resolved symbol to user space.

*/

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];

if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))

goto print0;

wchan = get_wchan(task);

if (wchan && !lookup_symbol_name(wchan, symname)) {

seq_puts(m, symname);

return 0;

}

print0:

seq_putc(m, '0');

return 0;

}

#endif /* CONFIG_KALLSYMS */

static int lock_trace(struct task_struct *task)

{

int err = down_read_killable(&task->signal->exec_update_lock);

if (err)

return err;

if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) {

up_read(&task->signal->exec_update_lock);

return -EPERM;

}

return 0;

}

static void unlock_trace(struct task_struct *task)

{

up_read(&task->signal->exec_update_lock);

}

#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)

{

unsigned long *entries;

int err;

/*

* The ability to racily run the kernel stack unwinder on a running task

* and then observe the unwinder output is scary; while it is useful for

* debugging kernel issues, it can also allow an attacker to leak kernel

* stack contents.

* Doing this in a manner that is at least safe from races would require

* some work to ensure that the remote task can not be scheduled; and

* even then, this would still expose the unwinder as local attack

* surface.

* Therefore, this interface is restricted to root.

*/

if (!file_ns_capable(m->file, &init_user_ns, CAP_SYS_ADMIN))

return -EACCES;

entries = kmalloc_array(MAX_STACK_TRACE_DEPTH, sizeof(*entries),

GFP_KERNEL);

if (!entries)

return -ENOMEM;

err = lock_trace(task);

if (!err) {

unsigned int i, nr_entries;

nr_entries = stack_trace_save_tsk(task, entries,

MAX_STACK_TRACE_DEPTH, 0);

for (i = 0; i < nr_entries; i++) {

seq_printf(m, "[<0>] %pB\n", (void *)entries[i]);

}

unlock_trace(task);

}

kfree(entries);

return err;

}

#endif

#ifdef CONFIG_SCHED_INFO

/*

* Provides /proc/PID/schedstat

*/

static int proc_pid_schedstat(struct seq_file *m, struct pid_namespace *ns,

struct pid *pid, struct task_struct *task)

{

if (unlikely(!sched_info_on()))

seq_puts(m, "0 0 0\n");

else

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);

return 0;

}

#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 < LT_SAVECOUNT; 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;

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_tsk_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;

long badness;

badness = oom_badness(task, totalpages);

/*

* Special case OOM_SCORE_ADJ_MIN for all others scale the

* badness value into [0, 2000] range which we have been

* exporting for a long time so userspace might depend on it.

*/

if (badness != LONG_MIN)

points = (1000 + badness * 1000 / (long)totalpages) * 2 / 3;

seq_printf(m, "%lu\n", points);

return 0;

}

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_puts(m, "Limit "

"Soft Limit "

"Hard Limit "

"Units \n");

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)

{

struct syscall_info info;

u64 *args = &info.data.args[0];

int res;

res = lock_trace(task);

if (res)

return res;

if (task_current_syscall(task, &info))

seq_puts(m, "running\n");

else if (info.data.nr < 0)

seq_printf(m, "%d 0x%llx 0x%llx\n",

info.data.nr, info.sp, info.data.instruction_pointer);

else

seq_printf(m,

"%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",

info.data.nr,

args[0], args[1], args[2], args[3], args[4], args[5],

info.sp, info.data.instruction_pointer);

unlock_trace(task);

return 0;

}

#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */

/************************************************************************/

/* Here the fs part begins */

/************************************************************************/

/* permission checks */

static bool proc_fd_access_allowed(struct inode *inode)

{

struct task_struct *task;

bool allowed = false;

/* 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_FSCREDS);

put_task_struct(task);

}

return allowed;

}

int proc_nochmod_setattr(struct mnt_idmap *idmap, struct dentry *dentry,

struct iattr *attr)

{

int error;

struct inode *inode = d_inode(dentry);

if (attr->ia_valid & ATTR_MODE)

return -EPERM;

error = setattr_prepare(&nop_mnt_idmap, dentry, attr);

if (error)

return error;

setattr_copy(&nop_mnt_idmap, inode, attr);

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 proc_fs_info *fs_info,

struct task_struct *task,

enum proc_hidepid hide_pid_min)

{

/*

* If 'hidpid' mount option is set force a ptrace check,

* we indicate that we are using a filesystem syscall

* by passing PTRACE_MODE_READ_FSCREDS

*/

if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE)

return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);

if (fs_info->hide_pid < hide_pid_min)

return true;

if (in_group_p(fs_info->pid_gid))

return true;

return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);

}

static int proc_pid_permission(struct mnt_idmap *idmap,

struct inode *inode, int mask)

{

struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);

struct task_struct *task;

bool has_perms;

task = get_proc_task(inode);

if (!task)

return -ESRCH;

has_perms = has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS);

put_task_struct(task);

if (!has_perms) {

if (fs_info->hide_pid == HIDEPID_INVISIBLE) {

/*

* 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(&nop_mnt_idmap, inode, mask);

}

static const struct inode_operations proc_def_inode_operations = {

.setattr = proc_nochmod_setattr,

};

static int proc_single_show(struct seq_file *m, void *v)

{

struct inode *inode = m->private;

struct pid_namespace *ns = proc_pid_ns(inode->i_sb);

struct pid *pid = proc_pid(inode);

struct task_struct *task;

int ret;

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,

};

/*

* proc_mem_open() can return errno, NULL or mm_struct*.

*

* - Returns NULL if the task has no mm (PF_KTHREAD or PF_EXITING)

* - Returns mm_struct* on success

* - Returns error code on failure

*/

struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode)

{

struct task_struct *task = get_proc_task(inode);

struct mm_struct *mm;

if (!task)

return ERR_PTR(-ESRCH);

mm = mm_access(task, mode | PTRACE_MODE_FSCREDS);

put_task_struct(task);

if (IS_ERR(mm))

return mm == ERR_PTR(-ESRCH) ? NULL : mm;

/* ensure this mm_struct can't be freed */

mmgrab(mm);

/* 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_OR_NULL(mm))

return mm ? PTR_ERR(mm) : -ESRCH;

file->private_data = mm;

return 0;

}

static int mem_open(struct inode *inode, struct file *file)

{

if (WARN_ON_ONCE(!(file->f_op->fop_flags & FOP_UNSIGNED_OFFSET)))

return -EINVAL;

return __mem_open(inode, file, PTRACE_MODE_ATTACH);

}

static bool proc_mem_foll_force(struct file *file, struct mm_struct *mm)

{

struct task_struct *task;

bool ptrace_active = false;

switch (proc_mem_force_override) {

case PROC_MEM_FORCE_NEVER:

return false;

case PROC_MEM_FORCE_PTRACE:

task = get_proc_task(file_inode(file));

if (task) {

ptrace_active = READ_ONCE(task->ptrace) &&

READ_ONCE(task->mm) == mm &&

READ_ONCE(task->parent) == current;

put_task_struct(task);

}

return ptrace_active;

default:

return true;

}

}

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;

unsigned int flags;

if (!mm)

return 0;

page = (char *)__get_free_page(GFP_KERNEL);

if (!page)

return -ENOMEM;

copied = 0;

if (!mmget_not_zero(mm))

goto free;

flags = write ? FOLL_WRITE : 0;

if (proc_mem_foll_force(file, mm))

flags |= FOLL_FORCE;

while (count > 0) {

size_t this_len = min_t(size_t, 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, flags);

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,

.fop_flags = FOP_UNSIGNED_OFFSET,

};