GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / powerpc / perf / perf_regs.c
1 /*
2  * Copyright 2016 Anju T, IBM Corporation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version
7  * 2 of the License, or (at your option) any later version.
8  */
9
10 #include <linux/errno.h>
11 #include <linux/kernel.h>
12 #include <linux/sched.h>
13 #include <linux/sched/task_stack.h>
14 #include <linux/perf_event.h>
15 #include <linux/bug.h>
16 #include <linux/stddef.h>
17 #include <asm/ptrace.h>
18 #include <asm/perf_regs.h>
19
20 #define PT_REGS_OFFSET(id, r) [id] = offsetof(struct pt_regs, r)
21
22 #define REG_RESERVED (~((1ULL << PERF_REG_POWERPC_MAX) - 1))
23
24 static unsigned int pt_regs_offset[PERF_REG_POWERPC_MAX] = {
25         PT_REGS_OFFSET(PERF_REG_POWERPC_R0,  gpr[0]),
26         PT_REGS_OFFSET(PERF_REG_POWERPC_R1,  gpr[1]),
27         PT_REGS_OFFSET(PERF_REG_POWERPC_R2,  gpr[2]),
28         PT_REGS_OFFSET(PERF_REG_POWERPC_R3,  gpr[3]),
29         PT_REGS_OFFSET(PERF_REG_POWERPC_R4,  gpr[4]),
30         PT_REGS_OFFSET(PERF_REG_POWERPC_R5,  gpr[5]),
31         PT_REGS_OFFSET(PERF_REG_POWERPC_R6,  gpr[6]),
32         PT_REGS_OFFSET(PERF_REG_POWERPC_R7,  gpr[7]),
33         PT_REGS_OFFSET(PERF_REG_POWERPC_R8,  gpr[8]),
34         PT_REGS_OFFSET(PERF_REG_POWERPC_R9,  gpr[9]),
35         PT_REGS_OFFSET(PERF_REG_POWERPC_R10, gpr[10]),
36         PT_REGS_OFFSET(PERF_REG_POWERPC_R11, gpr[11]),
37         PT_REGS_OFFSET(PERF_REG_POWERPC_R12, gpr[12]),
38         PT_REGS_OFFSET(PERF_REG_POWERPC_R13, gpr[13]),
39         PT_REGS_OFFSET(PERF_REG_POWERPC_R14, gpr[14]),
40         PT_REGS_OFFSET(PERF_REG_POWERPC_R15, gpr[15]),
41         PT_REGS_OFFSET(PERF_REG_POWERPC_R16, gpr[16]),
42         PT_REGS_OFFSET(PERF_REG_POWERPC_R17, gpr[17]),
43         PT_REGS_OFFSET(PERF_REG_POWERPC_R18, gpr[18]),
44         PT_REGS_OFFSET(PERF_REG_POWERPC_R19, gpr[19]),
45         PT_REGS_OFFSET(PERF_REG_POWERPC_R20, gpr[20]),
46         PT_REGS_OFFSET(PERF_REG_POWERPC_R21, gpr[21]),
47         PT_REGS_OFFSET(PERF_REG_POWERPC_R22, gpr[22]),
48         PT_REGS_OFFSET(PERF_REG_POWERPC_R23, gpr[23]),
49         PT_REGS_OFFSET(PERF_REG_POWERPC_R24, gpr[24]),
50         PT_REGS_OFFSET(PERF_REG_POWERPC_R25, gpr[25]),
51         PT_REGS_OFFSET(PERF_REG_POWERPC_R26, gpr[26]),
52         PT_REGS_OFFSET(PERF_REG_POWERPC_R27, gpr[27]),
53         PT_REGS_OFFSET(PERF_REG_POWERPC_R28, gpr[28]),
54         PT_REGS_OFFSET(PERF_REG_POWERPC_R29, gpr[29]),
55         PT_REGS_OFFSET(PERF_REG_POWERPC_R30, gpr[30]),
56         PT_REGS_OFFSET(PERF_REG_POWERPC_R31, gpr[31]),
57         PT_REGS_OFFSET(PERF_REG_POWERPC_NIP, nip),
58         PT_REGS_OFFSET(PERF_REG_POWERPC_MSR, msr),
59         PT_REGS_OFFSET(PERF_REG_POWERPC_ORIG_R3, orig_gpr3),
60         PT_REGS_OFFSET(PERF_REG_POWERPC_CTR, ctr),
61         PT_REGS_OFFSET(PERF_REG_POWERPC_LINK, link),
62         PT_REGS_OFFSET(PERF_REG_POWERPC_XER, xer),
63         PT_REGS_OFFSET(PERF_REG_POWERPC_CCR, ccr),
64 #ifdef CONFIG_PPC64
65         PT_REGS_OFFSET(PERF_REG_POWERPC_SOFTE, softe),
66 #else
67         PT_REGS_OFFSET(PERF_REG_POWERPC_SOFTE, mq),
68 #endif
69         PT_REGS_OFFSET(PERF_REG_POWERPC_TRAP, trap),
70         PT_REGS_OFFSET(PERF_REG_POWERPC_DAR, dar),
71         PT_REGS_OFFSET(PERF_REG_POWERPC_DSISR, dsisr),
72 };
73
74 u64 perf_reg_value(struct pt_regs *regs, int idx)
75 {
76         if (WARN_ON_ONCE(idx >= PERF_REG_POWERPC_MAX))
77                 return 0;
78
79         return regs_get_register(regs, pt_regs_offset[idx]);
80 }
81
82 int perf_reg_validate(u64 mask)
83 {
84         if (!mask || mask & REG_RESERVED)
85                 return -EINVAL;
86         return 0;
87 }
88
89 u64 perf_reg_abi(struct task_struct *task)
90 {
91 #ifdef CONFIG_PPC64
92         if (!test_tsk_thread_flag(task, TIF_32BIT))
93                 return PERF_SAMPLE_REGS_ABI_64;
94         else
95 #endif
96         return PERF_SAMPLE_REGS_ABI_32;
97 }
98
99 void perf_get_regs_user(struct perf_regs *regs_user,
100                         struct pt_regs *regs,
101                         struct pt_regs *regs_user_copy)
102 {
103         regs_user->regs = task_pt_regs(current);
104         regs_user->abi = (regs_user->regs) ? perf_reg_abi(current) :
105                          PERF_SAMPLE_REGS_ABI_NONE;
106 }