?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.26-rc5
[linux-2.6/openmoko-kernel/knife-kernel.git] / arch / m32r / kernel / ptrace.c
blob9aa615d3a5b24372cdd1a193ee7869cd4c5ce78e
1 /*
2 * linux/arch/m32r/kernel/ptrace.c
3 *
4 * Copyright (C) 2002 Hirokazu Takata, Takeo Takahashi
5 * Copyright (C) 2004 Hirokazu Takata, Kei Sakamoto
6 *
7 * Original x86 implementation:
8 * By Ross Biro 1/23/92
9 * edited by Linus Torvalds
10 *
11 * Some code taken from sh version:
12 * Copyright (C) 1999, 2000 Kaz Kojima & Niibe Yutaka
13 * Some code taken from arm version:
14 * Copyright (C) 2000 Russell King
15 */
16
17 #include <linux/kernel.h>
18 #include <linux/sched.h>
19 #include <linux/mm.h>
20 #include <linux/err.h>
21 #include <linux/smp.h>
22 #include <linux/smp_lock.h>
23 #include <linux/errno.h>
24 #include <linux/ptrace.h>
25 #include <linux/user.h>
26 #include <linux/string.h>
27 #include <linux/signal.h>
28
29 #include <asm/cacheflush.h>
30 #include <asm/io.h>
31 #include <asm/uaccess.h>
32 #include <asm/pgtable.h>
33 #include <asm/system.h>
34 #include <asm/processor.h>
35 #include <asm/mmu_context.h>
36
37 /*
38 * This routine will get a word off of the process kernel stack.
39 */
40 static inline unsigned long int
41 get_stack_long(struct task_struct *task, int offset)
42 {
43 unsigned long *stack;
44
45 stack = (unsigned long *)task_pt_regs(task);
46
47 return stack[offset];
48 }
49
50 /*
51 * This routine will put a word on the process kernel stack.
52 */
53 static inline int
54 put_stack_long(struct task_struct *task, int offset, unsigned long data)
55 {
56 unsigned long *stack;
57
58 stack = (unsigned long *)task_pt_regs(task);
59 stack[offset] = data;
60
61 return 0;
62 }
63
64 static int reg_offset[] = {
65 PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
66 PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_FP, PT_LR, PT_SPU,
67 };
68
69 /*
70 * Read the word at offset "off" into the "struct user". We
71 * actually access the pt_regs stored on the kernel stack.
72 */
73 static int ptrace_read_user(struct task_struct *tsk, unsigned long off,
74 unsigned long __user *data)
75 {
76 unsigned long tmp;
77 #ifndef NO_FPU
78 struct user * dummy = NULL;
79 #endif
80
81 if ((off & 3) || (off < 0) || (off > sizeof(struct user) - 3))
82 return -EIO;
83
84 off >>= 2;
85 switch (off) {
86 case PT_EVB:
87 __asm__ __volatile__ (
88 "mvfc %0, cr5 \n\t"
89 : "=r" (tmp)
90 );
91 break;
92 case PT_CBR: {
93 unsigned long psw;
94 psw = get_stack_long(tsk, PT_PSW);
95 tmp = ((psw >> 8) & 1);
96 }
97 break;
98 case PT_PSW: {
99 unsigned long psw, bbpsw;
100 psw = get_stack_long(tsk, PT_PSW);
101 bbpsw = get_stack_long(tsk, PT_BBPSW);
102 tmp = ((psw >> 8) & 0xff) | ((bbpsw & 0xff) << 8);
103 }
104 break;
105 case PT_PC:
106 tmp = get_stack_long(tsk, PT_BPC);
107 break;
108 case PT_BPC:
109 off = PT_BBPC;
110 /* fall through */
111 default:
112 if (off < (sizeof(struct pt_regs) >> 2))
113 tmp = get_stack_long(tsk, off);
114 #ifndef NO_FPU
115 else if (off >= (long)(&dummy->fpu >> 2) &&
116 off < (long)(&dummy->u_fpvalid >> 2)) {
117 if (!tsk_used_math(tsk)) {
118 if (off == (long)(&dummy->fpu.fpscr >> 2))
119 tmp = FPSCR_INIT;
120 else
121 tmp = 0;
122 } else
123 tmp = ((long *)(&tsk->thread.fpu >> 2))
124 [off - (long)&dummy->fpu];
125 } else if (off == (long)(&dummy->u_fpvalid >> 2))
126 tmp = !!tsk_used_math(tsk);
127 #endif /* not NO_FPU */
128 else
129 tmp = 0;
130 }
131
132 return put_user(tmp, data);
133 }
134
135 static int ptrace_write_user(struct task_struct *tsk, unsigned long off,
136 unsigned long data)
137 {
138 int ret = -EIO;
139 #ifndef NO_FPU
140 struct user * dummy = NULL;
141 #endif
142
143 if ((off & 3) || off < 0 ||
144 off > sizeof(struct user) - 3)
145 return -EIO;
146
147 off >>= 2;
148 switch (off) {
149 case PT_EVB:
150 case PT_BPC:
151 case PT_SPI:
152 /* We don't allow to modify evb. */
153 ret = 0;
154 break;
155 case PT_PSW:
156 case PT_CBR: {
157 /* We allow to modify only cbr in psw */
158 unsigned long psw;
159 psw = get_stack_long(tsk, PT_PSW);
160 psw = (psw & ~0x100) | ((data & 1) << 8);
161 ret = put_stack_long(tsk, PT_PSW, psw);
162 }
163 break;
164 case PT_PC:
165 off = PT_BPC;
166 data &= ~1;
167 /* fall through */
168 default:
169 if (off < (sizeof(struct pt_regs) >> 2))
170 ret = put_stack_long(tsk, off, data);
171 #ifndef NO_FPU
172 else if (off >= (long)(&dummy->fpu >> 2) &&
173 off < (long)(&dummy->u_fpvalid >> 2)) {
174 set_stopped_child_used_math(tsk);
175 ((long *)&tsk->thread.fpu)
176 [off - (long)&dummy->fpu] = data;
177 ret = 0;
178 } else if (off == (long)(&dummy->u_fpvalid >> 2)) {
179 conditional_stopped_child_used_math(data, tsk);
180 ret = 0;
181 }
182 #endif /* not NO_FPU */
183 break;
184 }
185
186 return ret;
187 }
188
189 /*
190 * Get all user integer registers.
191 */
192 static int ptrace_getregs(struct task_struct *tsk, void __user *uregs)
193 {
194 struct pt_regs *regs = task_pt_regs(tsk);
195
196 return copy_to_user(uregs, regs, sizeof(struct pt_regs)) ? -EFAULT : 0;
197 }
198
199 /*
200 * Set all user integer registers.
201 */
202 static int ptrace_setregs(struct task_struct *tsk, void __user *uregs)
203 {
204 struct pt_regs newregs;
205 int ret;
206
207 ret = -EFAULT;
208 if (copy_from_user(&newregs, uregs, sizeof(struct pt_regs)) == 0) {
209 struct pt_regs *regs = task_pt_regs(tsk);
210 *regs = newregs;
211 ret = 0;
212 }
213
214 return ret;
215 }
216
217
218 static inline int
219 check_condition_bit(struct task_struct *child)
220 {
221 return (int)((get_stack_long(child, PT_PSW) >> 8) & 1);
222 }
223
224 static int
225 check_condition_src(unsigned long op, unsigned long regno1,
226 unsigned long regno2, struct task_struct *child)
227 {
228 unsigned long reg1, reg2;
229
230 reg2 = get_stack_long(child, reg_offset[regno2]);
231
232 switch (op) {
233 case 0x0: /* BEQ */
234 reg1 = get_stack_long(child, reg_offset[regno1]);
235 return reg1 == reg2;
236 case 0x1: /* BNE */
237 reg1 = get_stack_long(child, reg_offset[regno1]);
238 return reg1 != reg2;
239 case 0x8: /* BEQZ */
240 return reg2 == 0;
241 case 0x9: /* BNEZ */
242 return reg2 != 0;
243 case 0xa: /* BLTZ */
244 return (int)reg2 < 0;
245 case 0xb: /* BGEZ */
246 return (int)reg2 >= 0;
247 case 0xc: /* BLEZ */
248 return (int)reg2 <= 0;
249 case 0xd: /* BGTZ */
250 return (int)reg2 > 0;
251 default:
252 /* never reached */
253 return 0;
254 }
255 }
256
257 static void
258 compute_next_pc_for_16bit_insn(unsigned long insn, unsigned long pc,
259 unsigned long *next_pc,
260 struct task_struct *child)
261 {
262 unsigned long op, op2, op3;
263 unsigned long disp;
264 unsigned long regno;
265 int parallel = 0;
266
267 if (insn & 0x00008000)
268 parallel = 1;
269 if (pc & 3)
270 insn &= 0x7fff; /* right slot */
271 else
272 insn >>= 16; /* left slot */
273
274 op = (insn >> 12) & 0xf;
275 op2 = (insn >> 8) & 0xf;
276 op3 = (insn >> 4) & 0xf;
277
278 if (op == 0x7) {
279 switch (op2) {
280 case 0xd: /* BNC */
281 case 0x9: /* BNCL */
282 if (!check_condition_bit(child)) {
283 disp = (long)(insn << 24) >> 22;
284 *next_pc = (pc & ~0x3) + disp;
285 return;
286 }
287 break;
288 case 0x8: /* BCL */
289 case 0xc: /* BC */
290 if (check_condition_bit(child)) {
291 disp = (long)(insn << 24) >> 22;
292 *next_pc = (pc & ~0x3) + disp;
293 return;
294 }
295 break;
296 case 0xe: /* BL */
297 case 0xf: /* BRA */
298 disp = (long)(insn << 24) >> 22;
299 *next_pc = (pc & ~0x3) + disp;
300 return;
301 break;
302 }
303 } else if (op == 0x1) {
304 switch (op2) {
305 case 0x0:
306 if (op3 == 0xf) { /* TRAP */
307 #if 1
308 /* pass through */
309 #else
310 /* kernel space is not allowed as next_pc */
311 unsigned long evb;
312 unsigned long trapno;
313 trapno = insn & 0xf;
314 __asm__ __volatile__ (
315 "mvfc %0, cr5\n"
316 :"=r"(evb)
317 :
318 );
319 *next_pc = evb + (trapno << 2);
320 return;
321 #endif
322 } else if (op3 == 0xd) { /* RTE */
323 *next_pc = get_stack_long(child, PT_BPC);
324 return;
325 }
326 break;
327 case 0xc: /* JC */
328 if (op3 == 0xc && check_condition_bit(child)) {
329 regno = insn & 0xf;
330 *next_pc = get_stack_long(child,
331 reg_offset[regno]);
332 return;
333 }
334 break;
335 case 0xd: /* JNC */
336 if (op3 == 0xc && !check_condition_bit(child)) {
337 regno = insn & 0xf;
338 *next_pc = get_stack_long(child,
339 reg_offset[regno]);
340 return;
341 }
342 break;
343 case 0xe: /* JL */
344 case 0xf: /* JMP */
345 if (op3 == 0xc) { /* JMP */
346 regno = insn & 0xf;
347 *next_pc = get_stack_long(child,
348 reg_offset[regno]);
349 return;
350 }
351 break;
352 }
353 }
354 if (parallel)
355 *next_pc = pc + 4;
356 else
357 *next_pc = pc + 2;
358 }
359
360 static void
361 compute_next_pc_for_32bit_insn(unsigned long insn, unsigned long pc,
362 unsigned long *next_pc,
363 struct task_struct *child)
364 {
365 unsigned long op;
366 unsigned long op2;
367 unsigned long disp;
368 unsigned long regno1, regno2;
369
370 op = (insn >> 28) & 0xf;
371 if (op == 0xf) { /* branch 24-bit relative */
372 op2 = (insn >> 24) & 0xf;
373 switch (op2) {
374 case 0xd: /* BNC */
375 case 0x9: /* BNCL */
376 if (!check_condition_bit(child)) {
377 disp = (long)(insn << 8) >> 6;
378 *next_pc = (pc & ~0x3) + disp;
379 return;
380 }
381 break;
382 case 0x8: /* BCL */
383 case 0xc: /* BC */
384 if (check_condition_bit(child)) {
385 disp = (long)(insn << 8) >> 6;
386 *next_pc = (pc & ~0x3) + disp;
387 return;
388 }
389 break;
390 case 0xe: /* BL */
391 case 0xf: /* BRA */
392 disp = (long)(insn << 8) >> 6;
393 *next_pc = (pc & ~0x3) + disp;
394 return;
395 }
396 } else if (op == 0xb) { /* branch 16-bit relative */
397 op2 = (insn >> 20) & 0xf;
398 switch (op2) {
399 case 0x0: /* BEQ */
400 case 0x1: /* BNE */
401 case 0x8: /* BEQZ */
402 case 0x9: /* BNEZ */
403 case 0xa: /* BLTZ */
404 case 0xb: /* BGEZ */
405 case 0xc: /* BLEZ */
406 case 0xd: /* BGTZ */
407 regno1 = ((insn >> 24) & 0xf);
408 regno2 = ((insn >> 16) & 0xf);
409 if (check_condition_src(op2, regno1, regno2, child)) {
410 disp = (long)(insn << 16) >> 14;
411 *next_pc = (pc & ~0x3) + disp;
412 return;
413 }
414 break;
415 }
416 }
417 *next_pc = pc + 4;
418 }
419
420 static inline void
421 compute_next_pc(unsigned long insn, unsigned long pc,
422 unsigned long *next_pc, struct task_struct *child)
423 {
424 if (insn & 0x80000000)
425 compute_next_pc_for_32bit_insn(insn, pc, next_pc, child);
426 else
427 compute_next_pc_for_16bit_insn(insn, pc, next_pc, child);
428 }
429
430 static int
431 register_debug_trap(struct task_struct *child, unsigned long next_pc,
432 unsigned long next_insn, unsigned long *code)
433 {
434 struct debug_trap *p = &child->thread.debug_trap;
435 unsigned long addr = next_pc & ~3;
436
437 if (p->nr_trap == MAX_TRAPS) {
438 printk("kernel BUG at %s %d: p->nr_trap = %d\n",
439 __FILE__, __LINE__, p->nr_trap);
440 return -1;
441 }
442 p->addr[p->nr_trap] = addr;
443 p->insn[p->nr_trap] = next_insn;
444 p->nr_trap++;
445 if (next_pc & 3) {
446 *code = (next_insn & 0xffff0000) | 0x10f1;
447 /* xxx --> TRAP1 */
448 } else {
449 if ((next_insn & 0x80000000) || (next_insn & 0x8000)) {
450 *code = 0x10f17000;
451 /* TRAP1 --> NOP */
452 } else {
453 *code = (next_insn & 0xffff) | 0x10f10000;
454 /* TRAP1 --> xxx */
455 }
456 }
457 return 0;
458 }
459
460 static int
461 unregister_debug_trap(struct task_struct *child, unsigned long addr,
462 unsigned long *code)
463 {
464 struct debug_trap *p = &child->thread.debug_trap;
465 int i;
466
467 /* Search debug trap entry. */
468 for (i = 0; i < p->nr_trap; i++) {
469 if (p->addr[i] == addr)
470 break;
471 }
472 if (i >= p->nr_trap) {
473 /* The trap may be requested from debugger.
474 * ptrace should do nothing in this case.
475 */
476 return 0;
477 }
478
479 /* Recover original instruction code. */
480 *code = p->insn[i];
481
482 /* Shift debug trap entries. */
483 while (i < p->nr_trap - 1) {
484 p->insn[i] = p->insn[i + 1];
485 p->addr[i] = p->addr[i + 1];
486 i++;
487 }
488 p->nr_trap--;
489 return 1;
490 }
491
492 static void
493 unregister_all_debug_traps(struct task_struct *child)
494 {
495 struct debug_trap *p = &child->thread.debug_trap;
496 int i;
497
498 for (i = 0; i < p->nr_trap; i++)
499 access_process_vm(child, p->addr[i], &p->insn[i], sizeof(p->insn[i]), 1);
500 p->nr_trap = 0;
501 }
502
503 static inline void
504 invalidate_cache(void)
505 {
506 #if defined(CONFIG_CHIP_M32700) || defined(CONFIG_CHIP_OPSP)
507
508 _flush_cache_copyback_all();
509
510 #else /* ! CONFIG_CHIP_M32700 */
511
512 /* Invalidate cache */
513 __asm__ __volatile__ (
514 "ldi r0, #-1 \n\t"
515 "ldi r1, #0 \n\t"
516 "stb r1, @r0 ; cache off \n\t"
517 "; \n\t"
518 "ldi r0, #-2 \n\t"
519 "ldi r1, #1 \n\t"
520 "stb r1, @r0 ; cache invalidate \n\t"
521 ".fillinsn \n"
522 "0: \n\t"
523 "ldb r1, @r0 ; invalidate check \n\t"
524 "bnez r1, 0b \n\t"
525 "; \n\t"
526 "ldi r0, #-1 \n\t"
527 "ldi r1, #1 \n\t"
528 "stb r1, @r0 ; cache on \n\t"
529 : : : "r0", "r1", "memory"
530 );
531 /* FIXME: copying-back d-cache and invalidating i-cache are needed.
532 */
533 #endif /* CONFIG_CHIP_M32700 */
534 }
535
536 /* Embed a debug trap (TRAP1) code */
537 static int
538 embed_debug_trap(struct task_struct *child, unsigned long next_pc)
539 {
540 unsigned long next_insn, code;
541 unsigned long addr = next_pc & ~3;
542
543 if (access_process_vm(child, addr, &next_insn, sizeof(next_insn), 0)
544 != sizeof(next_insn)) {
545 return -1; /* error */
546 }
547
548 /* Set a trap code. */
549 if (register_debug_trap(child, next_pc, next_insn, &code)) {
550 return -1; /* error */
551 }
552 if (access_process_vm(child, addr, &code, sizeof(code), 1)
553 != sizeof(code)) {
554 return -1; /* error */
555 }
556 return 0; /* success */
557 }
558
559 void
560 withdraw_debug_trap(struct pt_regs *regs)
561 {
562 unsigned long addr;
563 unsigned long code;
564
565 addr = (regs->bpc - 2) & ~3;
566 regs->bpc -= 2;
567 if (unregister_debug_trap(current, addr, &code)) {
568 access_process_vm(current, addr, &code, sizeof(code), 1);
569 invalidate_cache();
570 }
571 }
572
573 void
574 init_debug_traps(struct task_struct *child)
575 {
576 struct debug_trap *p = &child->thread.debug_trap;
577 int i;
578 p->nr_trap = 0;
579 for (i = 0; i < MAX_TRAPS; i++) {
580 p->addr[i] = 0;
581 p->insn[i] = 0;
582 }
583 }
584
585
586 /*
587 * Called by kernel/ptrace.c when detaching..
588 *
589 * Make sure single step bits etc are not set.
590 */
591 void ptrace_disable(struct task_struct *child)
592 {
593 /* nothing to do.. */
594 }
595
596 long
597 arch_ptrace(struct task_struct *child, long request, long addr, long data)
598 {
599 int ret;
600
601 switch (request) {
602 /*
603 * read word at location "addr" in the child process.
604 */
605 case PTRACE_PEEKTEXT:
606 case PTRACE_PEEKDATA:
607 ret = generic_ptrace_peekdata(child, addr, data);
608 break;
609
610 /*
611 * read the word at location addr in the USER area.
612 */
613 case PTRACE_PEEKUSR:
614 ret = ptrace_read_user(child, addr,
615 (unsigned long __user *)data);
616 break;
617
618 /*
619 * write the word at location addr.
620 */
621 case PTRACE_POKETEXT:
622 case PTRACE_POKEDATA:
623 ret = generic_ptrace_pokedata(child, addr, data);
624 if (ret == 0 && request == PTRACE_POKETEXT)
625 invalidate_cache();
626 break;
627
628 /*
629 * write the word at location addr in the USER area.
630 */
631 case PTRACE_POKEUSR:
632 ret = ptrace_write_user(child, addr, data);
633 break;
634
635 /*
636 * continue/restart and stop at next (return from) syscall
637 */
638 case PTRACE_SYSCALL:
639 case PTRACE_CONT:
640 ret = -EIO;
641 if (!valid_signal(data))
642 break;
643 if (request == PTRACE_SYSCALL)
644 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
645 else
646 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
647 child->exit_code = data;
648 wake_up_process(child);
649 ret = 0;
650 break;
651
652 /*
653 * make the child exit. Best I can do is send it a sigkill.
654 * perhaps it should be put in the status that it wants to
655 * exit.
656 */
657 case PTRACE_KILL: {
658 ret = 0;
659 unregister_all_debug_traps(child);
660 invalidate_cache();
661 if (child->exit_state == EXIT_ZOMBIE) /* already dead */
662 break;
663 child->exit_code = SIGKILL;
664 wake_up_process(child);
665 break;
666 }
667
668 /*
669 * execute single instruction.
670 */
671 case PTRACE_SINGLESTEP: {
672 unsigned long next_pc;
673 unsigned long pc, insn;
674
675 ret = -EIO;
676 if (!valid_signal(data))
677 break;
678 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
679 if ((child->ptrace & PT_DTRACE) == 0) {
680 /* Spurious delayed TF traps may occur */
681 child->ptrace |= PT_DTRACE;
682 }
683
684 /* Compute next pc. */
685 pc = get_stack_long(child, PT_BPC);
686
687 if (access_process_vm(child, pc&~3, &insn, sizeof(insn), 0)
688 != sizeof(insn))
689 break;
690
691 compute_next_pc(insn, pc, &next_pc, child);
692 if (next_pc & 0x80000000)
693 break;
694
695 if (embed_debug_trap(child, next_pc))
696 break;
697
698 invalidate_cache();
699 child->exit_code = data;
700
701 /* give it a chance to run. */
702 wake_up_process(child);
703 ret = 0;
704 break;
705 }
706
707 case PTRACE_GETREGS:
708 ret = ptrace_getregs(child, (void __user *)data);
709 break;
710
711 case PTRACE_SETREGS:
712 ret = ptrace_setregs(child, (void __user *)data);
713 break;
714
715 default:
716 ret = ptrace_request(child, request, addr, data);
717 break;
718 }
719
720 return ret;
721 }
722
723 /* notification of system call entry/exit
724 * - triggered by current->work.syscall_trace
725 */
726 void do_syscall_trace(void)
727 {
728 if (!test_thread_flag(TIF_SYSCALL_TRACE))
729 return;
730 if (!(current->ptrace & PT_PTRACED))
731 return;
732 /* the 0x80 provides a way for the tracing parent to distinguish
733 between a syscall stop and SIGTRAP delivery */
734 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
735 ? 0x80 : 0));
736
737 /*
738 * this isn't the same as continuing with a signal, but it will do
739 * for normal use. strace only continues with a signal if the
740 * stopping signal is not SIGTRAP. -brl
741 */
742 if (current->exit_code) {
743 send_sig(current->exit_code, current, 1);
744 current->exit_code = 0;
745 }
746 }
Community contributions to the Openmoko Kernel