2019-05-28 16:57:20 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2008-01-30 12:31:44 +00:00
|
|
|
/*
|
|
|
|
* User-mode machine state access
|
|
|
|
*
|
|
|
|
* Copyright (C) 2007 Red Hat, Inc. All rights reserved.
|
|
|
|
*
|
|
|
|
* Red Hat Author: Roland McGrath.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _LINUX_REGSET_H
|
|
|
|
#define _LINUX_REGSET_H 1
|
|
|
|
|
|
|
|
#include <linux/compiler.h>
|
|
|
|
#include <linux/types.h>
|
2011-11-24 01:12:59 +00:00
|
|
|
#include <linux/bug.h>
|
2008-01-30 12:31:45 +00:00
|
|
|
#include <linux/uaccess.h>
|
2008-01-30 12:31:44 +00:00
|
|
|
struct task_struct;
|
|
|
|
struct user_regset;
|
|
|
|
|
regset: new method and helpers for it
->regset_get() takes task+regset+buffer, returns the amount of free space
left in the buffer on success and -E... on error.
buffer is represented as struct membuf - a pair of (kernel) pointer
and amount of space left
Primitives for writing to such:
* membuf_write(buf, data, size)
* membuf_zero(buf, size)
* membuf_store(buf, value)
These are implemented as inlines (in case of membuf_store - a macro).
All writes are sequential; they become no-ops when there's no space
left. Return value of all primitives is the amount of space left
after the operation, so they can be used as return values of ->regset_get().
Example of use:
// stores pt_regs of task + 64 bytes worth of zeroes + 32bit PID of task
int foo_get(struct task_struct *task, const struct regset *regset,
struct membuf to)
{
membuf_write(&to, task_pt_regs(task), sizeof(struct pt_regs));
membuf_zero(&to, 64);
return membuf_store(&to, (u32)task_tgid_vnr(task));
}
regset_get()/regset_get_alloc() taught to use that thing if present.
By the end of the series all users of ->get() will be converted;
then ->get() and ->get_size() can go.
Note that unlike ->get() this thing always starts at offset 0 and,
since it only writes to kernel buffer, can't fail on copyout.
It can, of course, fail for other reasons, but those tend to
be less numerous.
The caller guarantees that the buffer size won't be bigger than
regset->n * regset->size. That simplifies life for quite a few
instances.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-02-21 01:48:16 +00:00
|
|
|
struct membuf {
|
|
|
|
void *p;
|
|
|
|
size_t left;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline int membuf_zero(struct membuf *s, size_t size)
|
|
|
|
{
|
|
|
|
if (s->left) {
|
|
|
|
if (size > s->left)
|
|
|
|
size = s->left;
|
|
|
|
memset(s->p, 0, size);
|
|
|
|
s->p += size;
|
|
|
|
s->left -= size;
|
|
|
|
}
|
|
|
|
return s->left;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int membuf_write(struct membuf *s, const void *v, size_t size)
|
|
|
|
{
|
|
|
|
if (s->left) {
|
|
|
|
if (size > s->left)
|
|
|
|
size = s->left;
|
|
|
|
memcpy(s->p, v, size);
|
|
|
|
s->p += size;
|
|
|
|
s->left -= size;
|
|
|
|
}
|
|
|
|
return s->left;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* current s->p must be aligned for v; v must be a scalar */
|
|
|
|
#define membuf_store(s, v) \
|
|
|
|
({ \
|
|
|
|
struct membuf *__s = (s); \
|
|
|
|
if (__s->left) { \
|
|
|
|
typeof(v) __v = (v); \
|
|
|
|
size_t __size = sizeof(__v); \
|
|
|
|
if (unlikely(__size > __s->left)) { \
|
|
|
|
__size = __s->left; \
|
|
|
|
memcpy(__s->p, &__v, __size); \
|
|
|
|
} else { \
|
|
|
|
*(typeof(__v + 0) *)__s->p = __v; \
|
|
|
|
} \
|
|
|
|
__s->p += __size; \
|
|
|
|
__s->left -= __size; \
|
|
|
|
} \
|
|
|
|
__s->left;})
|
2008-01-30 12:31:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* user_regset_active_fn - type of @active function in &struct user_regset
|
|
|
|
* @target: thread being examined
|
|
|
|
* @regset: regset being examined
|
|
|
|
*
|
|
|
|
* Return -%ENODEV if not available on the hardware found.
|
|
|
|
* Return %0 if no interesting state in this thread.
|
|
|
|
* Return >%0 number of @size units of interesting state.
|
|
|
|
* Any get call fetching state beyond that number will
|
|
|
|
* see the default initialization state for this data,
|
|
|
|
* so a caller that knows what the default state is need
|
|
|
|
* not copy it all out.
|
|
|
|
* This call is optional; the pointer is %NULL if there
|
|
|
|
* is no inexpensive check to yield a value < @n.
|
|
|
|
*/
|
|
|
|
typedef int user_regset_active_fn(struct task_struct *target,
|
|
|
|
const struct user_regset *regset);
|
|
|
|
|
regset: new method and helpers for it
->regset_get() takes task+regset+buffer, returns the amount of free space
left in the buffer on success and -E... on error.
buffer is represented as struct membuf - a pair of (kernel) pointer
and amount of space left
Primitives for writing to such:
* membuf_write(buf, data, size)
* membuf_zero(buf, size)
* membuf_store(buf, value)
These are implemented as inlines (in case of membuf_store - a macro).
All writes are sequential; they become no-ops when there's no space
left. Return value of all primitives is the amount of space left
after the operation, so they can be used as return values of ->regset_get().
Example of use:
// stores pt_regs of task + 64 bytes worth of zeroes + 32bit PID of task
int foo_get(struct task_struct *task, const struct regset *regset,
struct membuf to)
{
membuf_write(&to, task_pt_regs(task), sizeof(struct pt_regs));
membuf_zero(&to, 64);
return membuf_store(&to, (u32)task_tgid_vnr(task));
}
regset_get()/regset_get_alloc() taught to use that thing if present.
By the end of the series all users of ->get() will be converted;
then ->get() and ->get_size() can go.
Note that unlike ->get() this thing always starts at offset 0 and,
since it only writes to kernel buffer, can't fail on copyout.
It can, of course, fail for other reasons, but those tend to
be less numerous.
The caller guarantees that the buffer size won't be bigger than
regset->n * regset->size. That simplifies life for quite a few
instances.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-02-21 01:48:16 +00:00
|
|
|
typedef int user_regset_get2_fn(struct task_struct *target,
|
|
|
|
const struct user_regset *regset,
|
|
|
|
struct membuf to);
|
|
|
|
|
2008-01-30 12:31:44 +00:00
|
|
|
/**
|
|
|
|
* user_regset_set_fn - type of @set function in &struct user_regset
|
|
|
|
* @target: thread being examined
|
|
|
|
* @regset: regset being examined
|
|
|
|
* @pos: offset into the regset data to access, in bytes
|
|
|
|
* @count: amount of data to copy, in bytes
|
|
|
|
* @kbuf: if not %NULL, a kernel-space pointer to copy from
|
|
|
|
* @ubuf: if @kbuf is %NULL, a user-space pointer to copy from
|
|
|
|
*
|
|
|
|
* Store register values. Return %0 on success; -%EIO or -%ENODEV
|
|
|
|
* are usual failure returns. The @pos and @count values are in
|
|
|
|
* bytes, but must be properly aligned. If @kbuf is non-null, that
|
|
|
|
* buffer is used and @ubuf is ignored. If @kbuf is %NULL, then
|
|
|
|
* ubuf gives a userland pointer to access directly, and an -%EFAULT
|
|
|
|
* return value is possible.
|
|
|
|
*/
|
|
|
|
typedef int user_regset_set_fn(struct task_struct *target,
|
|
|
|
const struct user_regset *regset,
|
|
|
|
unsigned int pos, unsigned int count,
|
|
|
|
const void *kbuf, const void __user *ubuf);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* user_regset_writeback_fn - type of @writeback function in &struct user_regset
|
|
|
|
* @target: thread being examined
|
|
|
|
* @regset: regset being examined
|
|
|
|
* @immediate: zero if writeback at completion of next context switch is OK
|
|
|
|
*
|
|
|
|
* This call is optional; usually the pointer is %NULL. When
|
|
|
|
* provided, there is some user memory associated with this regset's
|
|
|
|
* hardware, such as memory backing cached register data on register
|
|
|
|
* window machines; the regset's data controls what user memory is
|
|
|
|
* used (e.g. via the stack pointer value).
|
|
|
|
*
|
|
|
|
* Write register data back to user memory. If the @immediate flag
|
|
|
|
* is nonzero, it must be written to the user memory so uaccess or
|
|
|
|
* access_process_vm() can see it when this call returns; if zero,
|
|
|
|
* then it must be written back by the time the task completes a
|
|
|
|
* context switch (as synchronized with wait_task_inactive()).
|
|
|
|
* Return %0 on success or if there was nothing to do, -%EFAULT for
|
|
|
|
* a memory problem (bad stack pointer or whatever), or -%EIO for a
|
|
|
|
* hardware problem.
|
|
|
|
*/
|
|
|
|
typedef int user_regset_writeback_fn(struct task_struct *target,
|
|
|
|
const struct user_regset *regset,
|
|
|
|
int immediate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct user_regset - accessible thread CPU state
|
|
|
|
* @n: Number of slots (registers).
|
|
|
|
* @size: Size in bytes of a slot (register).
|
|
|
|
* @align: Required alignment, in bytes.
|
|
|
|
* @bias: Bias from natural indexing.
|
|
|
|
* @core_note_type: ELF note @n_type value used in core dumps.
|
|
|
|
* @get: Function to fetch values.
|
|
|
|
* @set: Function to store values.
|
|
|
|
* @active: Function to report if regset is active, or %NULL.
|
|
|
|
* @writeback: Function to write data back to user memory, or %NULL.
|
|
|
|
*
|
|
|
|
* This data structure describes a machine resource we call a register set.
|
|
|
|
* This is part of the state of an individual thread, not necessarily
|
|
|
|
* actual CPU registers per se. A register set consists of a number of
|
|
|
|
* similar slots, given by @n. Each slot is @size bytes, and aligned to
|
2017-10-31 15:50:53 +00:00
|
|
|
* @align bytes (which is at least @size). For dynamically-sized
|
|
|
|
* regsets, @n must contain the maximum possible number of slots for the
|
2020-06-17 13:57:08 +00:00
|
|
|
* regset.
|
2017-10-31 15:50:53 +00:00
|
|
|
*
|
|
|
|
* For backward compatibility, the @get and @set methods must pad to, or
|
|
|
|
* accept, @n * @size bytes, even if the current regset size is smaller.
|
|
|
|
* The precise semantics of these operations depend on the regset being
|
|
|
|
* accessed.
|
|
|
|
*
|
|
|
|
* The functions to which &struct user_regset members point must be
|
|
|
|
* called only on the current thread or on a thread that is in
|
|
|
|
* %TASK_STOPPED or %TASK_TRACED state, that we are guaranteed will not
|
|
|
|
* be woken up and return to user mode, and that we have called
|
|
|
|
* wait_task_inactive() on. (The target thread always might wake up for
|
|
|
|
* SIGKILL while these functions are working, in which case that
|
|
|
|
* thread's user_regset state might be scrambled.)
|
2008-01-30 12:31:44 +00:00
|
|
|
*
|
|
|
|
* The @pos argument must be aligned according to @align; the @count
|
|
|
|
* argument must be a multiple of @size. These functions are not
|
|
|
|
* responsible for checking for invalid arguments.
|
|
|
|
*
|
|
|
|
* When there is a natural value to use as an index, @bias gives the
|
|
|
|
* difference between the natural index and the slot index for the
|
|
|
|
* register set. For example, x86 GDT segment descriptors form a regset;
|
|
|
|
* the segment selector produces a natural index, but only a subset of
|
|
|
|
* that index space is available as a regset (the TLS slots); subtracting
|
|
|
|
* @bias from a segment selector index value computes the regset slot.
|
|
|
|
*
|
|
|
|
* If nonzero, @core_note_type gives the n_type field (NT_* value)
|
|
|
|
* of the core file note in which this regset's data appears.
|
|
|
|
* NT_PRSTATUS is a special case in that the regset data starts at
|
|
|
|
* offsetof(struct elf_prstatus, pr_reg) into the note data; that is
|
|
|
|
* part of the per-machine ELF formats userland knows about. In
|
|
|
|
* other cases, the core file note contains exactly the whole regset
|
|
|
|
* (@n * @size) and nothing else. The core file note is normally
|
|
|
|
* omitted when there is an @active function and it returns zero.
|
|
|
|
*/
|
|
|
|
struct user_regset {
|
regset: new method and helpers for it
->regset_get() takes task+regset+buffer, returns the amount of free space
left in the buffer on success and -E... on error.
buffer is represented as struct membuf - a pair of (kernel) pointer
and amount of space left
Primitives for writing to such:
* membuf_write(buf, data, size)
* membuf_zero(buf, size)
* membuf_store(buf, value)
These are implemented as inlines (in case of membuf_store - a macro).
All writes are sequential; they become no-ops when there's no space
left. Return value of all primitives is the amount of space left
after the operation, so they can be used as return values of ->regset_get().
Example of use:
// stores pt_regs of task + 64 bytes worth of zeroes + 32bit PID of task
int foo_get(struct task_struct *task, const struct regset *regset,
struct membuf to)
{
membuf_write(&to, task_pt_regs(task), sizeof(struct pt_regs));
membuf_zero(&to, 64);
return membuf_store(&to, (u32)task_tgid_vnr(task));
}
regset_get()/regset_get_alloc() taught to use that thing if present.
By the end of the series all users of ->get() will be converted;
then ->get() and ->get_size() can go.
Note that unlike ->get() this thing always starts at offset 0 and,
since it only writes to kernel buffer, can't fail on copyout.
It can, of course, fail for other reasons, but those tend to
be less numerous.
The caller guarantees that the buffer size won't be bigger than
regset->n * regset->size. That simplifies life for quite a few
instances.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-02-21 01:48:16 +00:00
|
|
|
user_regset_get2_fn *regset_get;
|
2008-01-30 12:31:44 +00:00
|
|
|
user_regset_set_fn *set;
|
|
|
|
user_regset_active_fn *active;
|
|
|
|
user_regset_writeback_fn *writeback;
|
|
|
|
unsigned int n;
|
|
|
|
unsigned int size;
|
|
|
|
unsigned int align;
|
|
|
|
unsigned int bias;
|
|
|
|
unsigned int core_note_type;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct user_regset_view - available regsets
|
|
|
|
* @name: Identifier, e.g. UTS_MACHINE string.
|
|
|
|
* @regsets: Array of @n regsets available in this view.
|
|
|
|
* @n: Number of elements in @regsets.
|
|
|
|
* @e_machine: ELF header @e_machine %EM_* value written in core dumps.
|
|
|
|
* @e_flags: ELF header @e_flags value written in core dumps.
|
|
|
|
* @ei_osabi: ELF header @e_ident[%EI_OSABI] value written in core dumps.
|
|
|
|
*
|
|
|
|
* A regset view is a collection of regsets (&struct user_regset,
|
|
|
|
* above). This describes all the state of a thread that can be seen
|
|
|
|
* from a given architecture/ABI environment. More than one view might
|
|
|
|
* refer to the same &struct user_regset, or more than one regset
|
|
|
|
* might refer to the same machine-specific state in the thread. For
|
|
|
|
* example, a 32-bit thread's state could be examined from the 32-bit
|
|
|
|
* view or from the 64-bit view. Either method reaches the same thread
|
|
|
|
* register state, doing appropriate widening or truncation.
|
|
|
|
*/
|
|
|
|
struct user_regset_view {
|
|
|
|
const char *name;
|
|
|
|
const struct user_regset *regsets;
|
|
|
|
unsigned int n;
|
|
|
|
u32 e_flags;
|
|
|
|
u16 e_machine;
|
|
|
|
u8 ei_osabi;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is documented here rather than at the definition sites because its
|
|
|
|
* implementation is machine-dependent but its interface is universal.
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* task_user_regset_view - Return the process's native regset view.
|
|
|
|
* @tsk: a thread of the process in question
|
|
|
|
*
|
|
|
|
* Return the &struct user_regset_view that is native for the given process.
|
|
|
|
* For example, what it would access when it called ptrace().
|
|
|
|
* Throughout the life of the process, this only changes at exec.
|
|
|
|
*/
|
|
|
|
const struct user_regset_view *task_user_regset_view(struct task_struct *tsk);
|
|
|
|
|
2008-01-30 12:31:45 +00:00
|
|
|
static inline int user_regset_copyin(unsigned int *pos, unsigned int *count,
|
|
|
|
const void **kbuf,
|
|
|
|
const void __user **ubuf, void *data,
|
|
|
|
const int start_pos, const int end_pos)
|
|
|
|
{
|
|
|
|
if (*count == 0)
|
|
|
|
return 0;
|
|
|
|
BUG_ON(*pos < start_pos);
|
|
|
|
if (end_pos < 0 || *pos < end_pos) {
|
|
|
|
unsigned int copy = (end_pos < 0 ? *count
|
|
|
|
: min(*count, end_pos - *pos));
|
|
|
|
data += *pos - start_pos;
|
|
|
|
if (*kbuf) {
|
|
|
|
memcpy(data, *kbuf, copy);
|
|
|
|
*kbuf += copy;
|
|
|
|
} else if (__copy_from_user(data, *ubuf, copy))
|
|
|
|
return -EFAULT;
|
|
|
|
else
|
|
|
|
*ubuf += copy;
|
|
|
|
*pos += copy;
|
|
|
|
*count -= copy;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int user_regset_copyin_ignore(unsigned int *pos,
|
|
|
|
unsigned int *count,
|
|
|
|
const void **kbuf,
|
|
|
|
const void __user **ubuf,
|
|
|
|
const int start_pos,
|
|
|
|
const int end_pos)
|
|
|
|
{
|
|
|
|
if (*count == 0)
|
|
|
|
return 0;
|
|
|
|
BUG_ON(*pos < start_pos);
|
|
|
|
if (end_pos < 0 || *pos < end_pos) {
|
|
|
|
unsigned int copy = (end_pos < 0 ? *count
|
|
|
|
: min(*count, end_pos - *pos));
|
|
|
|
if (*kbuf)
|
|
|
|
*kbuf += copy;
|
|
|
|
else
|
|
|
|
*ubuf += copy;
|
|
|
|
*pos += copy;
|
|
|
|
*count -= copy;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-01 23:42:40 +00:00
|
|
|
extern int regset_get(struct task_struct *target,
|
|
|
|
const struct user_regset *regset,
|
|
|
|
unsigned int size, void *data);
|
|
|
|
|
|
|
|
extern int regset_get_alloc(struct task_struct *target,
|
|
|
|
const struct user_regset *regset,
|
|
|
|
unsigned int size,
|
|
|
|
void **data);
|
|
|
|
|
2020-02-17 17:25:14 +00:00
|
|
|
extern int copy_regset_to_user(struct task_struct *target,
|
|
|
|
const struct user_regset_view *view,
|
|
|
|
unsigned int setno, unsigned int offset,
|
|
|
|
unsigned int size, void __user *data);
|
2008-01-30 12:31:47 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* copy_regset_from_user - store into thread's user_regset data from user memory
|
|
|
|
* @target: thread to be examined
|
|
|
|
* @view: &struct user_regset_view describing user thread machine state
|
|
|
|
* @setno: index in @view->regsets
|
|
|
|
* @offset: offset into the regset data, in bytes
|
|
|
|
* @size: amount of data to copy, in bytes
|
|
|
|
* @data: user-mode pointer to copy from
|
|
|
|
*/
|
|
|
|
static inline int copy_regset_from_user(struct task_struct *target,
|
|
|
|
const struct user_regset_view *view,
|
|
|
|
unsigned int setno,
|
|
|
|
unsigned int offset, unsigned int size,
|
|
|
|
const void __user *data)
|
|
|
|
{
|
|
|
|
const struct user_regset *regset = &view->regsets[setno];
|
|
|
|
|
2012-03-02 18:43:48 +00:00
|
|
|
if (!regset->set)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
Remove 'type' argument from access_ok() function
Nobody has actually used the type (VERIFY_READ vs VERIFY_WRITE) argument
of the user address range verification function since we got rid of the
old racy i386-only code to walk page tables by hand.
It existed because the original 80386 would not honor the write protect
bit when in kernel mode, so you had to do COW by hand before doing any
user access. But we haven't supported that in a long time, and these
days the 'type' argument is a purely historical artifact.
A discussion about extending 'user_access_begin()' to do the range
checking resulted this patch, because there is no way we're going to
move the old VERIFY_xyz interface to that model. And it's best done at
the end of the merge window when I've done most of my merges, so let's
just get this done once and for all.
This patch was mostly done with a sed-script, with manual fix-ups for
the cases that weren't of the trivial 'access_ok(VERIFY_xyz' form.
There were a couple of notable cases:
- csky still had the old "verify_area()" name as an alias.
- the iter_iov code had magical hardcoded knowledge of the actual
values of VERIFY_{READ,WRITE} (not that they mattered, since nothing
really used it)
- microblaze used the type argument for a debug printout
but other than those oddities this should be a total no-op patch.
I tried to fix up all architectures, did fairly extensive grepping for
access_ok() uses, and the changes are trivial, but I may have missed
something. Any missed conversion should be trivially fixable, though.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-01-04 02:57:57 +00:00
|
|
|
if (!access_ok(data, size))
|
2012-03-02 18:43:49 +00:00
|
|
|
return -EFAULT;
|
2008-01-30 12:31:47 +00:00
|
|
|
|
|
|
|
return regset->set(target, regset, offset, size, NULL, data);
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:31:44 +00:00
|
|
|
#endif /* <linux/regset.h> */
|