[mirror_ubuntu-bionic-kernel.git] / arch / x86 / kernel / perf_regs.c

#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/sched/task_stack.h>
#include <linux/perf_event.h>
#include <linux/bug.h>
#include <linux/stddef.h>
#include <asm/perf_regs.h>
#include <asm/ptrace.h>

#ifdef CONFIG_X86_32
#define PERF_REG_X86_MAX PERF_REG_X86_32_MAX
#else
#define PERF_REG_X86_MAX PERF_REG_X86_64_MAX
#endif

#define PT_REGS_OFFSET(id, r) [id] = offsetof(struct pt_regs, r)

static unsigned int pt_regs_offset[PERF_REG_X86_MAX] = {
	PT_REGS_OFFSET(PERF_REG_X86_AX, ax),
	PT_REGS_OFFSET(PERF_REG_X86_BX, bx),
	PT_REGS_OFFSET(PERF_REG_X86_CX, cx),
	PT_REGS_OFFSET(PERF_REG_X86_DX, dx),
	PT_REGS_OFFSET(PERF_REG_X86_SI, si),
	PT_REGS_OFFSET(PERF_REG_X86_DI, di),
	PT_REGS_OFFSET(PERF_REG_X86_BP, bp),
	PT_REGS_OFFSET(PERF_REG_X86_SP, sp),
	PT_REGS_OFFSET(PERF_REG_X86_IP, ip),
	PT_REGS_OFFSET(PERF_REG_X86_FLAGS, flags),
	PT_REGS_OFFSET(PERF_REG_X86_CS, cs),
	PT_REGS_OFFSET(PERF_REG_X86_SS, ss),
#ifdef CONFIG_X86_32
	PT_REGS_OFFSET(PERF_REG_X86_DS, ds),
	PT_REGS_OFFSET(PERF_REG_X86_ES, es),
	PT_REGS_OFFSET(PERF_REG_X86_FS, fs),
	PT_REGS_OFFSET(PERF_REG_X86_GS, gs),
#else
	/*
	 * The pt_regs struct does not store
	 * ds, es, fs, gs in 64 bit mode.
	 */
	(unsigned int) -1,
	(unsigned int) -1,
	(unsigned int) -1,
	(unsigned int) -1,
#endif
#ifdef CONFIG_X86_64
	PT_REGS_OFFSET(PERF_REG_X86_R8, r8),
	PT_REGS_OFFSET(PERF_REG_X86_R9, r9),
	PT_REGS_OFFSET(PERF_REG_X86_R10, r10),
	PT_REGS_OFFSET(PERF_REG_X86_R11, r11),
	PT_REGS_OFFSET(PERF_REG_X86_R12, r12),
	PT_REGS_OFFSET(PERF_REG_X86_R13, r13),
	PT_REGS_OFFSET(PERF_REG_X86_R14, r14),
	PT_REGS_OFFSET(PERF_REG_X86_R15, r15),
#endif
};

u64 perf_reg_value(struct pt_regs *regs, int idx)
{
	if (WARN_ON_ONCE(idx >= ARRAY_SIZE(pt_regs_offset)))
		return 0;

	return regs_get_register(regs, pt_regs_offset[idx]);
}

#define REG_RESERVED (~((1ULL << PERF_REG_X86_MAX) - 1ULL))

#ifdef CONFIG_X86_32
int perf_reg_validate(u64 mask)
{
	if (!mask || mask & REG_RESERVED)
		return -EINVAL;

	return 0;
}

u64 perf_reg_abi(struct task_struct *task)
{
	return PERF_SAMPLE_REGS_ABI_32;
}

void perf_get_regs_user(struct perf_regs *regs_user,
			struct pt_regs *regs,
			struct pt_regs *regs_user_copy)
{
	regs_user->regs = task_pt_regs(current);
	regs_user->abi = perf_reg_abi(current);
}
#else /* CONFIG_X86_64 */
#define REG_NOSUPPORT ((1ULL << PERF_REG_X86_DS) | \
		       (1ULL << PERF_REG_X86_ES) | \
		       (1ULL << PERF_REG_X86_FS) | \
		       (1ULL << PERF_REG_X86_GS))

int perf_reg_validate(u64 mask)
{
	if (!mask || mask & REG_RESERVED)
		return -EINVAL;

	if (mask & REG_NOSUPPORT)
		return -EINVAL;

	return 0;
}

u64 perf_reg_abi(struct task_struct *task)
{
	if (test_tsk_thread_flag(task, TIF_IA32))
		return PERF_SAMPLE_REGS_ABI_32;
	else
		return PERF_SAMPLE_REGS_ABI_64;
}

void perf_get_regs_user(struct perf_regs *regs_user,
			struct pt_regs *regs,
			struct pt_regs *regs_user_copy)
{
	struct pt_regs *user_regs = task_pt_regs(current);

	/*
	 * If we're in an NMI that interrupted task_pt_regs setup, then
	 * we can't sample user regs at all.  This check isn't really
	 * sufficient, though, as we could be in an NMI inside an interrupt
	 * that happened during task_pt_regs setup.
	 */
	if (regs->sp > (unsigned long)&user_regs->r11 &&
	    regs->sp <= (unsigned long)(user_regs + 1)) {
		regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
		regs_user->regs = NULL;
		return;
	}

	/*
	 * These registers are always saved on 64-bit syscall entry.
	 * On 32-bit entry points, they are saved too except r8..r11.
	 */
	regs_user_copy->ip = user_regs->ip;
	regs_user_copy->ax = user_regs->ax;
	regs_user_copy->cx = user_regs->cx;
	regs_user_copy->dx = user_regs->dx;
	regs_user_copy->si = user_regs->si;
	regs_user_copy->di = user_regs->di;
	regs_user_copy->r8 = user_regs->r8;
	regs_user_copy->r9 = user_regs->r9;
	regs_user_copy->r10 = user_regs->r10;
	regs_user_copy->r11 = user_regs->r11;
	regs_user_copy->orig_ax = user_regs->orig_ax;
	regs_user_copy->flags = user_regs->flags;
	regs_user_copy->sp = user_regs->sp;
	regs_user_copy->cs = user_regs->cs;
	regs_user_copy->ss = user_regs->ss;

	/*
	 * Most system calls don't save these registers, don't report them.
	 */
	regs_user_copy->bx = -1;
	regs_user_copy->bp = -1;
	regs_user_copy->r12 = -1;
	regs_user_copy->r13 = -1;
	regs_user_copy->r14 = -1;
	regs_user_copy->r15 = -1;

	/*
	 * For this to be at all useful, we need a reasonable guess for
	 * the ABI.  Be careful: we're in NMI context, and we're
	 * considering current to be the current task, so we should
	 * be careful not to look at any other percpu variables that might
	 * change during context switches.
	 */
	regs_user->abi = user_64bit_mode(user_regs) ?
		PERF_SAMPLE_REGS_ABI_64 : PERF_SAMPLE_REGS_ABI_32;

	regs_user->regs = regs_user_copy;
}
#endif /* CONFIG_X86_32 */
Commit	Line	Data
c5e63197 JO	1	#include <linux/errno.h>
c5e63197 JO	2	#include <linux/kernel.h>
4018994f	3	#include <linux/sched.h>
68db0cf1	4	#include <linux/sched/task_stack.h>
4018994f	5	#include <linux/perf_event.h>
c5e63197 JO	6	#include <linux/bug.h>
	7	#include <linux/stddef.h>
	8	#include <asm/perf_regs.h>
	9	#include <asm/ptrace.h>
	10
	11	#ifdef CONFIG_X86_32
	12	#define PERF_REG_X86_MAX PERF_REG_X86_32_MAX
	13	#else
	14	#define PERF_REG_X86_MAX PERF_REG_X86_64_MAX
	15	#endif
	16
	17	#define PT_REGS_OFFSET(id, r) [id] = offsetof(struct pt_regs, r)
	18
	19	static unsigned int pt_regs_offset[PERF_REG_X86_MAX] = {
	20	PT_REGS_OFFSET(PERF_REG_X86_AX, ax),
	21	PT_REGS_OFFSET(PERF_REG_X86_BX, bx),
	22	PT_REGS_OFFSET(PERF_REG_X86_CX, cx),
	23	PT_REGS_OFFSET(PERF_REG_X86_DX, dx),
	24	PT_REGS_OFFSET(PERF_REG_X86_SI, si),
	25	PT_REGS_OFFSET(PERF_REG_X86_DI, di),
	26	PT_REGS_OFFSET(PERF_REG_X86_BP, bp),
	27	PT_REGS_OFFSET(PERF_REG_X86_SP, sp),
	28	PT_REGS_OFFSET(PERF_REG_X86_IP, ip),
	29	PT_REGS_OFFSET(PERF_REG_X86_FLAGS, flags),
	30	PT_REGS_OFFSET(PERF_REG_X86_CS, cs),
	31	PT_REGS_OFFSET(PERF_REG_X86_SS, ss),
	32	#ifdef CONFIG_X86_32
	33	PT_REGS_OFFSET(PERF_REG_X86_DS, ds),
	34	PT_REGS_OFFSET(PERF_REG_X86_ES, es),
	35	PT_REGS_OFFSET(PERF_REG_X86_FS, fs),
	36	PT_REGS_OFFSET(PERF_REG_X86_GS, gs),
	37	#else
	38	/*
	39	* The pt_regs struct does not store
	40	* ds, es, fs, gs in 64 bit mode.
	41	*/
	42	(unsigned int) -1,
	43	(unsigned int) -1,
	44	(unsigned int) -1,
	45	(unsigned int) -1,
	46	#endif
	47	#ifdef CONFIG_X86_64
	48	PT_REGS_OFFSET(PERF_REG_X86_R8, r8),
	49	PT_REGS_OFFSET(PERF_REG_X86_R9, r9),
	50	PT_REGS_OFFSET(PERF_REG_X86_R10, r10),
	51	PT_REGS_OFFSET(PERF_REG_X86_R11, r11),
	52	PT_REGS_OFFSET(PERF_REG_X86_R12, r12),
	53	PT_REGS_OFFSET(PERF_REG_X86_R13, r13),
	54	PT_REGS_OFFSET(PERF_REG_X86_R14, r14),
	55	PT_REGS_OFFSET(PERF_REG_X86_R15, r15),
	56	#endif
	57	};
	58
	59	u64 perf_reg_value(struct pt_regs *regs, int idx)
	60	{
1e6dd8ad	61	if (WARN_ON_ONCE(idx >= ARRAY_SIZE(pt_regs_offset)))
c5e63197 JO	62	return 0;
	63
	64	return regs_get_register(regs, pt_regs_offset[idx]);
	65	}
	66
	67	#define REG_RESERVED (~((1ULL << PERF_REG_X86_MAX) - 1ULL))
	68
	69	#ifdef CONFIG_X86_32
	70	int perf_reg_validate(u64 mask)
	71	{
	72	if (!mask \|\| mask & REG_RESERVED)
	73	return -EINVAL;
	74
	75	return 0;
	76	}
4018994f JO	77
	78	u64 perf_reg_abi(struct task_struct *task)
	79	{
	80	return PERF_SAMPLE_REGS_ABI_32;
	81	}
88a7c26a AL	82
	83	void perf_get_regs_user(struct perf_regs *regs_user,
	84	struct pt_regs *regs,
	85	struct pt_regs *regs_user_copy)
	86	{
	87	regs_user->regs = task_pt_regs(current);
	88	regs_user->abi = perf_reg_abi(current);
	89	}
c5e63197 JO	90	#else /* CONFIG_X86_64 */
	91	#define REG_NOSUPPORT ((1ULL << PERF_REG_X86_DS) \| \
	92	(1ULL << PERF_REG_X86_ES) \| \
	93	(1ULL << PERF_REG_X86_FS) \| \
	94	(1ULL << PERF_REG_X86_GS))
	95
	96	int perf_reg_validate(u64 mask)
	97	{
	98	if (!mask \|\| mask & REG_RESERVED)
	99	return -EINVAL;
	100
	101	if (mask & REG_NOSUPPORT)
	102	return -EINVAL;
	103
	104	return 0;
	105	}
4018994f JO	106
	107	u64 perf_reg_abi(struct task_struct *task)
	108	{
	109	if (test_tsk_thread_flag(task, TIF_IA32))
	110	return PERF_SAMPLE_REGS_ABI_32;
	111	else
	112	return PERF_SAMPLE_REGS_ABI_64;
	113	}
88a7c26a AL	114
	115	void perf_get_regs_user(struct perf_regs *regs_user,
	116	struct pt_regs *regs,
	117	struct pt_regs *regs_user_copy)
	118	{
86c269fe AL	119	struct pt_regs *user_regs = task_pt_regs(current);
	120
	121	/*
	122	* If we're in an NMI that interrupted task_pt_regs setup, then
	123	* we can't sample user regs at all. This check isn't really
	124	* sufficient, though, as we could be in an NMI inside an interrupt
	125	* that happened during task_pt_regs setup.
	126	*/
	127	if (regs->sp > (unsigned long)&user_regs->r11 &&
	128	regs->sp <= (unsigned long)(user_regs + 1)) {
	129	regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
	130	regs_user->regs = NULL;
	131	return;
	132	}
	133
	134	/*
aa21df04 DV	135	* These registers are always saved on 64-bit syscall entry.
aa21df04 DV	136	* On 32-bit entry points, they are saved too except r8..r11.
86c269fe AL	137	*/
86c269fe AL	138	regs_user_copy->ip = user_regs->ip;
3b75232d	139	regs_user_copy->ax = user_regs->ax;
86c269fe AL	140	regs_user_copy->cx = user_regs->cx;
	141	regs_user_copy->dx = user_regs->dx;
	142	regs_user_copy->si = user_regs->si;
	143	regs_user_copy->di = user_regs->di;
	144	regs_user_copy->r8 = user_regs->r8;
	145	regs_user_copy->r9 = user_regs->r9;
	146	regs_user_copy->r10 = user_regs->r10;
	147	regs_user_copy->r11 = user_regs->r11;
	148	regs_user_copy->orig_ax = user_regs->orig_ax;
	149	regs_user_copy->flags = user_regs->flags;
aa21df04 DV	150	regs_user_copy->sp = user_regs->sp;
	151	regs_user_copy->cs = user_regs->cs;
	152	regs_user_copy->ss = user_regs->ss;
86c269fe AL	153
86c269fe AL	154	/*
aa21df04	155	* Most system calls don't save these registers, don't report them.
86c269fe AL	156	*/
	157	regs_user_copy->bx = -1;
	158	regs_user_copy->bp = -1;
	159	regs_user_copy->r12 = -1;
	160	regs_user_copy->r13 = -1;
	161	regs_user_copy->r14 = -1;
	162	regs_user_copy->r15 = -1;
	163
	164	/*
	165	* For this to be at all useful, we need a reasonable guess for
aa21df04	166	* the ABI. Be careful: we're in NMI context, and we're
86c269fe AL	167	* considering current to be the current task, so we should
	168	* be careful not to look at any other percpu variables that might
	169	* change during context switches.
	170	*/
32caa060 DV	171	regs_user->abi = user_64bit_mode(user_regs) ?
32caa060 DV	172	PERF_SAMPLE_REGS_ABI_64 : PERF_SAMPLE_REGS_ABI_32;
86c269fe AL	173
86c269fe AL	174	regs_user->regs = regs_user_copy;
88a7c26a	175	}
c5e63197	176	#endif /* CONFIG_X86_32 */