]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - arch/xtensa/kernel/hw_breakpoint.c
UBUNTU: Ubuntu-4.15.0-96.97
[mirror_ubuntu-bionic-kernel.git] / arch / xtensa / kernel / hw_breakpoint.c
1 /*
2 * Xtensa hardware breakpoints/watchpoints handling functions
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
6 * for more details.
7 *
8 * Copyright (C) 2016 Cadence Design Systems Inc.
9 */
10
11 #include <linux/hw_breakpoint.h>
12 #include <linux/log2.h>
13 #include <linux/percpu.h>
14 #include <linux/perf_event.h>
15 #include <variant/core.h>
16
17 /* Breakpoint currently in use for each IBREAKA. */
18 static DEFINE_PER_CPU(struct perf_event *, bp_on_reg[XCHAL_NUM_IBREAK]);
19
20 /* Watchpoint currently in use for each DBREAKA. */
21 static DEFINE_PER_CPU(struct perf_event *, wp_on_reg[XCHAL_NUM_DBREAK]);
22
23 int hw_breakpoint_slots(int type)
24 {
25 switch (type) {
26 case TYPE_INST:
27 return XCHAL_NUM_IBREAK;
28 case TYPE_DATA:
29 return XCHAL_NUM_DBREAK;
30 default:
31 pr_warn("unknown slot type: %d\n", type);
32 return 0;
33 }
34 }
35
36 int arch_check_bp_in_kernelspace(struct perf_event *bp)
37 {
38 unsigned int len;
39 unsigned long va;
40 struct arch_hw_breakpoint *info = counter_arch_bp(bp);
41
42 va = info->address;
43 len = bp->attr.bp_len;
44
45 return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE);
46 }
47
48 /*
49 * Construct an arch_hw_breakpoint from a perf_event.
50 */
51 static int arch_build_bp_info(struct perf_event *bp)
52 {
53 struct arch_hw_breakpoint *info = counter_arch_bp(bp);
54
55 /* Type */
56 switch (bp->attr.bp_type) {
57 case HW_BREAKPOINT_X:
58 info->type = XTENSA_BREAKPOINT_EXECUTE;
59 break;
60 case HW_BREAKPOINT_R:
61 info->type = XTENSA_BREAKPOINT_LOAD;
62 break;
63 case HW_BREAKPOINT_W:
64 info->type = XTENSA_BREAKPOINT_STORE;
65 break;
66 case HW_BREAKPOINT_RW:
67 info->type = XTENSA_BREAKPOINT_LOAD | XTENSA_BREAKPOINT_STORE;
68 break;
69 default:
70 return -EINVAL;
71 }
72
73 /* Len */
74 info->len = bp->attr.bp_len;
75 if (info->len < 1 || info->len > 64 || !is_power_of_2(info->len))
76 return -EINVAL;
77
78 /* Address */
79 info->address = bp->attr.bp_addr;
80 if (info->address & (info->len - 1))
81 return -EINVAL;
82
83 return 0;
84 }
85
86 int arch_validate_hwbkpt_settings(struct perf_event *bp)
87 {
88 int ret;
89
90 /* Build the arch_hw_breakpoint. */
91 ret = arch_build_bp_info(bp);
92 return ret;
93 }
94
95 int hw_breakpoint_exceptions_notify(struct notifier_block *unused,
96 unsigned long val, void *data)
97 {
98 return NOTIFY_DONE;
99 }
100
101 static void xtensa_wsr(unsigned long v, u8 sr)
102 {
103 /* We don't have indexed wsr and creating instruction dynamically
104 * doesn't seem worth it given how small XCHAL_NUM_IBREAK and
105 * XCHAL_NUM_DBREAK are. Thus the switch. In case build breaks here
106 * the switch below needs to be extended.
107 */
108 BUILD_BUG_ON(XCHAL_NUM_IBREAK > 2);
109 BUILD_BUG_ON(XCHAL_NUM_DBREAK > 2);
110
111 switch (sr) {
112 #if XCHAL_NUM_IBREAK > 0
113 case SREG_IBREAKA + 0:
114 WSR(v, SREG_IBREAKA + 0);
115 break;
116 #endif
117 #if XCHAL_NUM_IBREAK > 1
118 case SREG_IBREAKA + 1:
119 WSR(v, SREG_IBREAKA + 1);
120 break;
121 #endif
122
123 #if XCHAL_NUM_DBREAK > 0
124 case SREG_DBREAKA + 0:
125 WSR(v, SREG_DBREAKA + 0);
126 break;
127 case SREG_DBREAKC + 0:
128 WSR(v, SREG_DBREAKC + 0);
129 break;
130 #endif
131 #if XCHAL_NUM_DBREAK > 1
132 case SREG_DBREAKA + 1:
133 WSR(v, SREG_DBREAKA + 1);
134 break;
135
136 case SREG_DBREAKC + 1:
137 WSR(v, SREG_DBREAKC + 1);
138 break;
139 #endif
140 }
141 }
142
143 static int alloc_slot(struct perf_event **slot, size_t n,
144 struct perf_event *bp)
145 {
146 size_t i;
147
148 for (i = 0; i < n; ++i) {
149 if (!slot[i]) {
150 slot[i] = bp;
151 return i;
152 }
153 }
154 return -EBUSY;
155 }
156
157 static void set_ibreak_regs(int reg, struct perf_event *bp)
158 {
159 struct arch_hw_breakpoint *info = counter_arch_bp(bp);
160 unsigned long ibreakenable;
161
162 xtensa_wsr(info->address, SREG_IBREAKA + reg);
163 RSR(ibreakenable, SREG_IBREAKENABLE);
164 WSR(ibreakenable | (1 << reg), SREG_IBREAKENABLE);
165 }
166
167 static void set_dbreak_regs(int reg, struct perf_event *bp)
168 {
169 struct arch_hw_breakpoint *info = counter_arch_bp(bp);
170 unsigned long dbreakc = DBREAKC_MASK_MASK & -info->len;
171
172 if (info->type & XTENSA_BREAKPOINT_LOAD)
173 dbreakc |= DBREAKC_LOAD_MASK;
174 if (info->type & XTENSA_BREAKPOINT_STORE)
175 dbreakc |= DBREAKC_STOR_MASK;
176
177 xtensa_wsr(info->address, SREG_DBREAKA + reg);
178 xtensa_wsr(dbreakc, SREG_DBREAKC + reg);
179 }
180
181 int arch_install_hw_breakpoint(struct perf_event *bp)
182 {
183 int i;
184
185 if (counter_arch_bp(bp)->type == XTENSA_BREAKPOINT_EXECUTE) {
186 /* Breakpoint */
187 i = alloc_slot(this_cpu_ptr(bp_on_reg), XCHAL_NUM_IBREAK, bp);
188 if (i < 0)
189 return i;
190 set_ibreak_regs(i, bp);
191
192 } else {
193 /* Watchpoint */
194 i = alloc_slot(this_cpu_ptr(wp_on_reg), XCHAL_NUM_DBREAK, bp);
195 if (i < 0)
196 return i;
197 set_dbreak_regs(i, bp);
198 }
199 return 0;
200 }
201
202 static int free_slot(struct perf_event **slot, size_t n,
203 struct perf_event *bp)
204 {
205 size_t i;
206
207 for (i = 0; i < n; ++i) {
208 if (slot[i] == bp) {
209 slot[i] = NULL;
210 return i;
211 }
212 }
213 return -EBUSY;
214 }
215
216 void arch_uninstall_hw_breakpoint(struct perf_event *bp)
217 {
218 struct arch_hw_breakpoint *info = counter_arch_bp(bp);
219 int i;
220
221 if (info->type == XTENSA_BREAKPOINT_EXECUTE) {
222 unsigned long ibreakenable;
223
224 /* Breakpoint */
225 i = free_slot(this_cpu_ptr(bp_on_reg), XCHAL_NUM_IBREAK, bp);
226 if (i >= 0) {
227 RSR(ibreakenable, SREG_IBREAKENABLE);
228 WSR(ibreakenable & ~(1 << i), SREG_IBREAKENABLE);
229 }
230 } else {
231 /* Watchpoint */
232 i = free_slot(this_cpu_ptr(wp_on_reg), XCHAL_NUM_DBREAK, bp);
233 if (i >= 0)
234 xtensa_wsr(0, SREG_DBREAKC + i);
235 }
236 }
237
238 void hw_breakpoint_pmu_read(struct perf_event *bp)
239 {
240 }
241
242 void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
243 {
244 int i;
245 struct thread_struct *t = &tsk->thread;
246
247 for (i = 0; i < XCHAL_NUM_IBREAK; ++i) {
248 if (t->ptrace_bp[i]) {
249 unregister_hw_breakpoint(t->ptrace_bp[i]);
250 t->ptrace_bp[i] = NULL;
251 }
252 }
253 for (i = 0; i < XCHAL_NUM_DBREAK; ++i) {
254 if (t->ptrace_wp[i]) {
255 unregister_hw_breakpoint(t->ptrace_wp[i]);
256 t->ptrace_wp[i] = NULL;
257 }
258 }
259 }
260
261 /*
262 * Set ptrace breakpoint pointers to zero for this task.
263 * This is required in order to prevent child processes from unregistering
264 * breakpoints held by their parent.
265 */
266 void clear_ptrace_hw_breakpoint(struct task_struct *tsk)
267 {
268 memset(tsk->thread.ptrace_bp, 0, sizeof(tsk->thread.ptrace_bp));
269 memset(tsk->thread.ptrace_wp, 0, sizeof(tsk->thread.ptrace_wp));
270 }
271
272 void restore_dbreak(void)
273 {
274 int i;
275
276 for (i = 0; i < XCHAL_NUM_DBREAK; ++i) {
277 struct perf_event *bp = this_cpu_ptr(wp_on_reg)[i];
278
279 if (bp)
280 set_dbreak_regs(i, bp);
281 }
282 clear_thread_flag(TIF_DB_DISABLED);
283 }
284
285 int check_hw_breakpoint(struct pt_regs *regs)
286 {
287 if (regs->debugcause & BIT(DEBUGCAUSE_IBREAK_BIT)) {
288 int i;
289 struct perf_event **bp = this_cpu_ptr(bp_on_reg);
290
291 for (i = 0; i < XCHAL_NUM_IBREAK; ++i) {
292 if (bp[i] && !bp[i]->attr.disabled &&
293 regs->pc == bp[i]->attr.bp_addr)
294 perf_bp_event(bp[i], regs);
295 }
296 return 0;
297 } else if (regs->debugcause & BIT(DEBUGCAUSE_DBREAK_BIT)) {
298 struct perf_event **bp = this_cpu_ptr(wp_on_reg);
299 int dbnum = (regs->debugcause & DEBUGCAUSE_DBNUM_MASK) >>
300 DEBUGCAUSE_DBNUM_SHIFT;
301
302 if (dbnum < XCHAL_NUM_DBREAK && bp[dbnum]) {
303 if (user_mode(regs)) {
304 perf_bp_event(bp[dbnum], regs);
305 } else {
306 set_thread_flag(TIF_DB_DISABLED);
307 xtensa_wsr(0, SREG_DBREAKC + dbnum);
308 }
309 } else {
310 WARN_ONCE(1,
311 "Wrong/unconfigured DBNUM reported in DEBUGCAUSE: %d\n",
312 dbnum);
313 }
314 return 0;
315 }
316 return -ENOENT;
317 }