1
2
3
4
5#include <linux/kernel.h>
6#include <linux/sched.h>
7#include <linux/mm.h>
8#include <linux/smp.h>
9#include <linux/errno.h>
10#include <linux/ptrace.h>
11#include <linux/user.h>
12#include <linux/signal.h>
13#include <linux/security.h>
14
15#include <asm/uaccess.h>
16#include <asm/page.h>
17#include <asm/pgtable.h>
18#include <asm/processor.h>
19#include <arch/hwregs/supp_reg.h>
20
21
22
23
24
25#define CCS_MASK 0x00087c00
26
27#define SBIT_USER (1 << (S_CCS_BITNR + CCS_SHIFT))
28
29static int put_debugreg(long pid, unsigned int regno, long data);
30static long get_debugreg(long pid, unsigned int regno);
31static unsigned long get_pseudo_pc(struct task_struct *child);
32void deconfigure_bp(long pid);
33
34extern unsigned long cris_signal_return_page;
35
36
37
38
39long get_reg(struct task_struct *task, unsigned int regno)
40{
41
42
43
44 unsigned long ret;
45
46 if (regno <= PT_EDA)
47 ret = ((unsigned long *)task_pt_regs(task))[regno];
48 else if (regno == PT_USP)
49 ret = task->thread.usp;
50 else if (regno == PT_PPC)
51 ret = get_pseudo_pc(task);
52 else if (regno <= PT_MAX)
53 ret = get_debugreg(task->pid, regno);
54 else
55 ret = 0;
56
57 return ret;
58}
59
60
61
62
63int put_reg(struct task_struct *task, unsigned int regno, unsigned long data)
64{
65 if (regno <= PT_EDA)
66 ((unsigned long *)task_pt_regs(task))[regno] = data;
67 else if (regno == PT_USP)
68 task->thread.usp = data;
69 else if (regno == PT_PPC) {
70
71 if (data != get_pseudo_pc(task))
72 task_pt_regs(task)->erp = data;
73 } else if (regno <= PT_MAX)
74 return put_debugreg(task->pid, regno, data);
75 else
76 return -1;
77 return 0;
78}
79
80void user_enable_single_step(struct task_struct *child)
81{
82 unsigned long tmp;
83
84
85
86
87
88 if (!get_reg(child, PT_SPC)) {
89
90 tmp = get_reg(child, PT_ERP) & ~1;
91 put_reg(child, PT_SPC, tmp);
92 }
93 tmp = get_reg(child, PT_CCS) | SBIT_USER;
94 put_reg(child, PT_CCS, tmp);
95}
96
97void user_disable_single_step(struct task_struct *child)
98{
99 put_reg(child, PT_SPC, 0);
100
101 if (!get_debugreg(child->pid, PT_BP_CTRL)) {
102 unsigned long tmp;
103
104 tmp = get_reg(child, PT_CCS) & ~SBIT_USER;
105 put_reg(child, PT_CCS, tmp);
106 }
107}
108
109
110
111
112
113
114void
115ptrace_disable(struct task_struct *child)
116{
117
118 user_disable_single_step(child);
119 put_reg(child, PT_SPC, 0);
120
121
122 deconfigure_bp(child->pid);
123}
124
125
126long arch_ptrace(struct task_struct *child, long request,
127 unsigned long addr, unsigned long data)
128{
129 int ret;
130 unsigned int regno = addr >> 2;
131 unsigned long __user *datap = (unsigned long __user *)data;
132
133 switch (request) {
134
135 case PTRACE_PEEKTEXT:
136 case PTRACE_PEEKDATA: {
137 unsigned long tmp;
138 int copied;
139
140 ret = -EIO;
141
142
143
144
145
146 if ((addr & PAGE_MASK) == cris_signal_return_page) {
147
148 tmp = *(unsigned long*)addr;
149 } else {
150 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
151
152 if (copied != sizeof(tmp))
153 break;
154 }
155
156 ret = put_user(tmp,datap);
157 break;
158 }
159
160
161 case PTRACE_PEEKUSR: {
162 unsigned long tmp;
163
164 ret = -EIO;
165 if ((addr & 3) || regno > PT_MAX)
166 break;
167
168 tmp = get_reg(child, regno);
169 ret = put_user(tmp, datap);
170 break;
171 }
172
173
174 case PTRACE_POKETEXT:
175 case PTRACE_POKEDATA:
176 ret = generic_ptrace_pokedata(child, addr, data);
177 break;
178
179
180 case PTRACE_POKEUSR:
181 ret = -EIO;
182 if ((addr & 3) || regno > PT_MAX)
183 break;
184
185 if (regno == PT_CCS) {
186
187
188
189 data &= CCS_MASK;
190 data |= get_reg(child, PT_CCS) & ~CCS_MASK;
191 }
192 if (put_reg(child, regno, data))
193 break;
194 ret = 0;
195 break;
196
197
198 case PTRACE_GETREGS: {
199 int i;
200 unsigned long tmp;
201
202 for (i = 0; i <= PT_MAX; i++) {
203 tmp = get_reg(child, i);
204
205 if (put_user(tmp, datap)) {
206 ret = -EFAULT;
207 goto out_tsk;
208 }
209
210 datap++;
211 }
212
213 ret = 0;
214 break;
215 }
216
217
218 case PTRACE_SETREGS: {
219 int i;
220 unsigned long tmp;
221
222 for (i = 0; i <= PT_MAX; i++) {
223 if (get_user(tmp, datap)) {
224 ret = -EFAULT;
225 goto out_tsk;
226 }
227
228 if (i == PT_CCS) {
229 tmp &= CCS_MASK;
230 tmp |= get_reg(child, PT_CCS) & ~CCS_MASK;
231 }
232
233 put_reg(child, i, tmp);
234 datap++;
235 }
236
237 ret = 0;
238 break;
239 }
240
241 default:
242 ret = ptrace_request(child, request, addr, data);
243 break;
244 }
245
246out_tsk:
247 return ret;
248}
249
250void do_syscall_trace(void)
251{
252 if (!test_thread_flag(TIF_SYSCALL_TRACE))
253 return;
254
255 if (!(current->ptrace & PT_PTRACED))
256 return;
257
258
259
260 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
261 ? 0x80 : 0));
262
263
264
265
266
267 if (current->exit_code) {
268 send_sig(current->exit_code, current, 1);
269 current->exit_code = 0;
270 }
271}
272
273
274
275static int insn_size(struct task_struct *child, unsigned long pc)
276{
277 unsigned long opcode;
278 int copied;
279 int opsize = 0;
280
281
282 copied = access_process_vm(child, pc, &opcode, sizeof(opcode), 0);
283 if (copied != sizeof(opcode))
284 return 0;
285
286 switch ((opcode & 0x0f00) >> 8) {
287 case 0x0:
288 case 0x9:
289 case 0xb:
290 opsize = 2;
291 break;
292 case 0xe:
293 case 0xf:
294 opsize = 6;
295 break;
296 case 0xd:
297
298 if ((opcode & 0xff) == 0xff)
299 opsize = 4;
300 else
301 opsize = 6;
302 break;
303 default:
304 panic("ERROR: Couldn't find size of opcode 0x%lx at 0x%lx\n",
305 opcode, pc);
306 }
307
308 return opsize;
309}
310
311static unsigned long get_pseudo_pc(struct task_struct *child)
312{
313
314 unsigned long pc = get_reg(child, PT_ERP);
315
316 if (pc & 0x1) {
317 unsigned long spc = get_reg(child, PT_SPC);
318
319
320 if (spc) {
321
322
323
324 pc = spc;
325 } else {
326
327
328 pc += insn_size(child, pc & ~1) - 1;
329 }
330 }
331 return pc;
332}
333
334static long bp_owner = 0;
335
336
337void deconfigure_bp(long pid)
338{
339 int bp;
340
341
342 if (bp_owner != pid)
343 return;
344
345 for (bp = 0; bp < 6; bp++) {
346 unsigned long tmp;
347
348 put_debugreg(pid, PT_BP + 3 + (bp * 2), 0);
349 put_debugreg(pid, PT_BP + 4 + (bp * 2), 0);
350
351
352 tmp = get_debugreg(pid, PT_BP_CTRL) & ~(3 << (2 + (bp * 4)));
353 put_debugreg(pid, PT_BP_CTRL, tmp);
354 }
355
356 bp_owner = 0;
357}
358
359static int put_debugreg(long pid, unsigned int regno, long data)
360{
361 int ret = 0;
362 register int old_srs;
363
364#ifdef CONFIG_ETRAX_KGDB
365
366
367 return (data == 0) ? ret : -1;
368#endif
369
370
371 if (!bp_owner)
372 bp_owner = pid;
373 else if (bp_owner != pid) {
374
375
376 return (data == 0) ? ret : -1;
377 }
378
379
380 SPEC_REG_RD(SPEC_REG_SRS, old_srs);
381
382 SUPP_BANK_SEL(BANK_BP);
383
384 switch (regno - PT_BP) {
385 case 0:
386 SUPP_REG_WR(0, data); break;
387 case 1:
388 case 2:
389 if (data)
390 ret = -1;
391 break;
392 case 3:
393 SUPP_REG_WR(3, data); break;
394 case 4:
395 SUPP_REG_WR(4, data); break;
396 case 5:
397 SUPP_REG_WR(5, data); break;
398 case 6:
399 SUPP_REG_WR(6, data); break;
400 case 7:
401 SUPP_REG_WR(7, data); break;
402 case 8:
403 SUPP_REG_WR(8, data); break;
404 case 9:
405 SUPP_REG_WR(9, data); break;
406 case 10:
407 SUPP_REG_WR(10, data); break;
408 case 11:
409 SUPP_REG_WR(11, data); break;
410 case 12:
411 SUPP_REG_WR(12, data); break;
412 case 13:
413 SUPP_REG_WR(13, data); break;
414 case 14:
415 SUPP_REG_WR(14, data); break;
416 default:
417 ret = -1;
418 break;
419 }
420
421
422 SPEC_REG_WR(SPEC_REG_SRS, old_srs);
423
424 NOP();
425 NOP();
426 NOP();
427
428 return ret;
429}
430
431static long get_debugreg(long pid, unsigned int regno)
432{
433 register int old_srs;
434 register long data;
435
436 if (pid != bp_owner) {
437 return 0;
438 }
439
440
441 SPEC_REG_RD(SPEC_REG_SRS, old_srs);
442
443 SUPP_BANK_SEL(BANK_BP);
444
445 switch (regno - PT_BP) {
446 case 0:
447 SUPP_REG_RD(0, data); break;
448 case 1:
449 case 2:
450
451 data = 0;
452 break;
453 case 3:
454 SUPP_REG_RD(3, data); break;
455 case 4:
456 SUPP_REG_RD(4, data); break;
457 case 5:
458 SUPP_REG_RD(5, data); break;
459 case 6:
460 SUPP_REG_RD(6, data); break;
461 case 7:
462 SUPP_REG_RD(7, data); break;
463 case 8:
464 SUPP_REG_RD(8, data); break;
465 case 9:
466 SUPP_REG_RD(9, data); break;
467 case 10:
468 SUPP_REG_RD(10, data); break;
469 case 11:
470 SUPP_REG_RD(11, data); break;
471 case 12:
472 SUPP_REG_RD(12, data); break;
473 case 13:
474 SUPP_REG_RD(13, data); break;
475 case 14:
476 SUPP_REG_RD(14, data); break;
477 default:
478
479 data = 0;
480 }
481
482
483 SPEC_REG_WR(SPEC_REG_SRS, old_srs);
484
485 NOP();
486 NOP();
487 NOP();
488
489 return data;
490}
491