2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
6 * Copyright (C) 1992 Ross Biro
7 * Copyright (C) Linus Torvalds
8 * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle
9 * Copyright (C) 1996 David S. Miller
10 * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
11 * Copyright (C) 1999 MIPS Technologies, Inc.
12 * Copyright (C) 2000 Ulf Carlsson
14 * At this time Linux/MIPS64 only supports syscall tracing, even for 32-bit
17 #include <linux/compiler.h>
18 #include <linux/context_tracking.h>
19 #include <linux/elf.h>
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
23 #include <linux/errno.h>
24 #include <linux/ptrace.h>
25 #include <linux/regset.h>
26 #include <linux/smp.h>
27 #include <linux/user.h>
28 #include <linux/security.h>
29 #include <linux/tracehook.h>
30 #include <linux/audit.h>
31 #include <linux/seccomp.h>
32 #include <linux/ftrace.h>
34 #include <asm/byteorder.h>
38 #include <asm/mipsregs.h>
39 #include <asm/mipsmtregs.h>
40 #include <asm/pgtable.h>
42 #include <asm/syscall.h>
43 #include <asm/uaccess.h>
44 #include <asm/bootinfo.h>
47 #define CREATE_TRACE_POINTS
48 #include <trace/events/syscalls.h>
51 * Called by kernel/ptrace.c when detaching..
53 * Make sure single step bits etc are not set.
55 void ptrace_disable(struct task_struct *child)
57 /* Don't load the watchpoint registers for the ex-child. */
58 clear_tsk_thread_flag(child, TIF_LOAD_WATCH);
62 * Read a general register set. We always use the 64-bit format, even
63 * for 32-bit kernels and for 32-bit processes on a 64-bit kernel.
64 * Registers are sign extended to fill the available space.
66 int ptrace_getregs(struct task_struct *child, __s64 __user *data)
71 if (!access_ok(VERIFY_WRITE, data, 38 * 8))
74 regs = task_pt_regs(child);
76 for (i = 0; i < 32; i++)
77 __put_user((long)regs->regs[i], data + i);
78 __put_user((long)regs->lo, data + EF_LO - EF_R0);
79 __put_user((long)regs->hi, data + EF_HI - EF_R0);
80 __put_user((long)regs->cp0_epc, data + EF_CP0_EPC - EF_R0);
81 __put_user((long)regs->cp0_badvaddr, data + EF_CP0_BADVADDR - EF_R0);
82 __put_user((long)regs->cp0_status, data + EF_CP0_STATUS - EF_R0);
83 __put_user((long)regs->cp0_cause, data + EF_CP0_CAUSE - EF_R0);
89 * Write a general register set. As for PTRACE_GETREGS, we always use
90 * the 64-bit format. On a 32-bit kernel only the lower order half
91 * (according to endianness) will be used.
93 int ptrace_setregs(struct task_struct *child, __s64 __user *data)
98 if (!access_ok(VERIFY_READ, data, 38 * 8))
101 regs = task_pt_regs(child);
103 for (i = 0; i < 32; i++)
104 __get_user(regs->regs[i], data + i);
105 __get_user(regs->lo, data + EF_LO - EF_R0);
106 __get_user(regs->hi, data + EF_HI - EF_R0);
107 __get_user(regs->cp0_epc, data + EF_CP0_EPC - EF_R0);
109 /* badvaddr, status, and cause may not be written. */
114 int ptrace_getfpregs(struct task_struct *child, __u32 __user *data)
118 if (!access_ok(VERIFY_WRITE, data, 33 * 8))
121 if (tsk_used_math(child)) {
122 union fpureg *fregs = get_fpu_regs(child);
123 for (i = 0; i < 32; i++)
124 __put_user(get_fpr64(&fregs[i], 0),
125 i + (__u64 __user *)data);
127 for (i = 0; i < 32; i++)
128 __put_user((__u64) -1, i + (__u64 __user *) data);
131 __put_user(child->thread.fpu.fcr31, data + 64);
132 __put_user(current_cpu_data.fpu_id, data + 65);
137 int ptrace_setfpregs(struct task_struct *child, __u32 __user *data)
143 if (!access_ok(VERIFY_READ, data, 33 * 8))
146 fregs = get_fpu_regs(child);
148 for (i = 0; i < 32; i++) {
149 __get_user(fpr_val, i + (__u64 __user *)data);
150 set_fpr64(&fregs[i], 0, fpr_val);
153 __get_user(child->thread.fpu.fcr31, data + 64);
155 /* FIR may not be written. */
160 int ptrace_get_watch_regs(struct task_struct *child,
161 struct pt_watch_regs __user *addr)
163 enum pt_watch_style style;
166 if (!cpu_has_watch || current_cpu_data.watch_reg_use_cnt == 0)
168 if (!access_ok(VERIFY_WRITE, addr, sizeof(struct pt_watch_regs)))
172 style = pt_watch_style_mips32;
173 #define WATCH_STYLE mips32
175 style = pt_watch_style_mips64;
176 #define WATCH_STYLE mips64
179 __put_user(style, &addr->style);
180 __put_user(current_cpu_data.watch_reg_use_cnt,
181 &addr->WATCH_STYLE.num_valid);
182 for (i = 0; i < current_cpu_data.watch_reg_use_cnt; i++) {
183 __put_user(child->thread.watch.mips3264.watchlo[i],
184 &addr->WATCH_STYLE.watchlo[i]);
185 __put_user(child->thread.watch.mips3264.watchhi[i] & 0xfff,
186 &addr->WATCH_STYLE.watchhi[i]);
187 __put_user(current_cpu_data.watch_reg_masks[i],
188 &addr->WATCH_STYLE.watch_masks[i]);
191 __put_user(0, &addr->WATCH_STYLE.watchlo[i]);
192 __put_user(0, &addr->WATCH_STYLE.watchhi[i]);
193 __put_user(0, &addr->WATCH_STYLE.watch_masks[i]);
199 int ptrace_set_watch_regs(struct task_struct *child,
200 struct pt_watch_regs __user *addr)
203 int watch_active = 0;
204 unsigned long lt[NUM_WATCH_REGS];
205 u16 ht[NUM_WATCH_REGS];
207 if (!cpu_has_watch || current_cpu_data.watch_reg_use_cnt == 0)
209 if (!access_ok(VERIFY_READ, addr, sizeof(struct pt_watch_regs)))
211 /* Check the values. */
212 for (i = 0; i < current_cpu_data.watch_reg_use_cnt; i++) {
213 __get_user(lt[i], &addr->WATCH_STYLE.watchlo[i]);
215 if (lt[i] & __UA_LIMIT)
218 if (test_tsk_thread_flag(child, TIF_32BIT_ADDR)) {
219 if (lt[i] & 0xffffffff80000000UL)
222 if (lt[i] & __UA_LIMIT)
226 __get_user(ht[i], &addr->WATCH_STYLE.watchhi[i]);
231 for (i = 0; i < current_cpu_data.watch_reg_use_cnt; i++) {
234 child->thread.watch.mips3264.watchlo[i] = lt[i];
236 child->thread.watch.mips3264.watchhi[i] = ht[i];
240 set_tsk_thread_flag(child, TIF_LOAD_WATCH);
242 clear_tsk_thread_flag(child, TIF_LOAD_WATCH);
247 /* regset get/set implementations */
249 static int gpr_get(struct task_struct *target,
250 const struct user_regset *regset,
251 unsigned int pos, unsigned int count,
252 void *kbuf, void __user *ubuf)
254 struct pt_regs *regs = task_pt_regs(target);
256 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
257 regs, 0, sizeof(*regs));
260 static int gpr_set(struct task_struct *target,
261 const struct user_regset *regset,
262 unsigned int pos, unsigned int count,
263 const void *kbuf, const void __user *ubuf)
265 struct pt_regs newregs;
268 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
274 *task_pt_regs(target) = newregs;
279 static int fpr_get(struct task_struct *target,
280 const struct user_regset *regset,
281 unsigned int pos, unsigned int count,
282 void *kbuf, void __user *ubuf)
290 if (sizeof(target->thread.fpu.fpr[i]) == sizeof(elf_fpreg_t))
291 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
293 0, sizeof(elf_fpregset_t));
295 for (i = 0; i < NUM_FPU_REGS; i++) {
296 fpr_val = get_fpr64(&target->thread.fpu.fpr[i], 0);
297 err = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
298 &fpr_val, i * sizeof(elf_fpreg_t),
299 (i + 1) * sizeof(elf_fpreg_t));
307 static int fpr_set(struct task_struct *target,
308 const struct user_regset *regset,
309 unsigned int pos, unsigned int count,
310 const void *kbuf, const void __user *ubuf)
318 if (sizeof(target->thread.fpu.fpr[i]) == sizeof(elf_fpreg_t))
319 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
321 0, sizeof(elf_fpregset_t));
323 for (i = 0; i < NUM_FPU_REGS; i++) {
324 err = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
325 &fpr_val, i * sizeof(elf_fpreg_t),
326 (i + 1) * sizeof(elf_fpreg_t));
329 set_fpr64(&target->thread.fpu.fpr[i], 0, fpr_val);
340 static const struct user_regset mips_regsets[] = {
342 .core_note_type = NT_PRSTATUS,
344 .size = sizeof(unsigned int),
345 .align = sizeof(unsigned int),
350 .core_note_type = NT_PRFPREG,
352 .size = sizeof(elf_fpreg_t),
353 .align = sizeof(elf_fpreg_t),
359 static const struct user_regset_view user_mips_view = {
361 .e_machine = ELF_ARCH,
362 .ei_osabi = ELF_OSABI,
363 .regsets = mips_regsets,
364 .n = ARRAY_SIZE(mips_regsets),
367 static const struct user_regset mips64_regsets[] = {
369 .core_note_type = NT_PRSTATUS,
371 .size = sizeof(unsigned long),
372 .align = sizeof(unsigned long),
377 .core_note_type = NT_PRFPREG,
379 .size = sizeof(elf_fpreg_t),
380 .align = sizeof(elf_fpreg_t),
386 static const struct user_regset_view user_mips64_view = {
388 .e_machine = ELF_ARCH,
389 .ei_osabi = ELF_OSABI,
390 .regsets = mips64_regsets,
391 .n = ARRAY_SIZE(mips_regsets),
394 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
397 return &user_mips_view;
400 #ifdef CONFIG_MIPS32_O32
401 if (test_thread_flag(TIF_32BIT_REGS))
402 return &user_mips_view;
405 return &user_mips64_view;
408 long arch_ptrace(struct task_struct *child, long request,
409 unsigned long addr, unsigned long data)
412 void __user *addrp = (void __user *) addr;
413 void __user *datavp = (void __user *) data;
414 unsigned long __user *datalp = (void __user *) data;
417 /* when I and D space are separate, these will need to be fixed. */
418 case PTRACE_PEEKTEXT: /* read word at location addr. */
419 case PTRACE_PEEKDATA:
420 ret = generic_ptrace_peekdata(child, addr, data);
423 /* Read the word at location addr in the USER area. */
424 case PTRACE_PEEKUSR: {
425 struct pt_regs *regs;
427 unsigned long tmp = 0;
429 regs = task_pt_regs(child);
430 ret = 0; /* Default return value. */
434 tmp = regs->regs[addr];
436 case FPR_BASE ... FPR_BASE + 31:
437 if (!tsk_used_math(child)) {
438 /* FP not yet used */
442 fregs = get_fpu_regs(child);
445 if (test_thread_flag(TIF_32BIT_FPREGS)) {
447 * The odd registers are actually the high
448 * order bits of the values stored in the even
449 * registers - unless we're using r2k_switch.S.
451 tmp = get_fpr32(&fregs[(addr & ~1) - FPR_BASE],
456 tmp = get_fpr32(&fregs[addr - FPR_BASE], 0);
462 tmp = regs->cp0_cause;
465 tmp = regs->cp0_badvaddr;
473 #ifdef CONFIG_CPU_HAS_SMARTMIPS
479 tmp = child->thread.fpu.fcr31;
482 /* implementation / version register */
483 tmp = current_cpu_data.fpu_id;
485 case DSP_BASE ... DSP_BASE + 5: {
493 dregs = __get_dsp_regs(child);
494 tmp = (unsigned long) (dregs[addr - DSP_BASE]);
503 tmp = child->thread.dsp.dspcontrol;
510 ret = put_user(tmp, datalp);
514 /* when I and D space are separate, this will have to be fixed. */
515 case PTRACE_POKETEXT: /* write the word at location addr. */
516 case PTRACE_POKEDATA:
517 ret = generic_ptrace_pokedata(child, addr, data);
520 case PTRACE_POKEUSR: {
521 struct pt_regs *regs;
523 regs = task_pt_regs(child);
527 regs->regs[addr] = data;
529 case FPR_BASE ... FPR_BASE + 31: {
530 union fpureg *fregs = get_fpu_regs(child);
532 if (!tsk_used_math(child)) {
533 /* FP not yet used */
534 memset(&child->thread.fpu, ~0,
535 sizeof(child->thread.fpu));
536 child->thread.fpu.fcr31 = 0;
539 if (test_thread_flag(TIF_32BIT_FPREGS)) {
541 * The odd registers are actually the high
542 * order bits of the values stored in the even
543 * registers - unless we're using r2k_switch.S.
545 set_fpr32(&fregs[(addr & ~1) - FPR_BASE],
550 set_fpr64(&fregs[addr - FPR_BASE], 0, data);
554 regs->cp0_epc = data;
562 #ifdef CONFIG_CPU_HAS_SMARTMIPS
568 child->thread.fpu.fcr31 = data;
570 case DSP_BASE ... DSP_BASE + 5: {
578 dregs = __get_dsp_regs(child);
579 dregs[addr - DSP_BASE] = data;
587 child->thread.dsp.dspcontrol = data;
590 /* The rest are not allowed. */
598 ret = ptrace_getregs(child, datavp);
602 ret = ptrace_setregs(child, datavp);
605 case PTRACE_GETFPREGS:
606 ret = ptrace_getfpregs(child, datavp);
609 case PTRACE_SETFPREGS:
610 ret = ptrace_setfpregs(child, datavp);
613 case PTRACE_GET_THREAD_AREA:
614 ret = put_user(task_thread_info(child)->tp_value, datalp);
617 case PTRACE_GET_WATCH_REGS:
618 ret = ptrace_get_watch_regs(child, addrp);
621 case PTRACE_SET_WATCH_REGS:
622 ret = ptrace_set_watch_regs(child, addrp);
626 ret = ptrace_request(child, request, addr, data);
634 * Notification of system call entry/exit
635 * - triggered by current->work.syscall_trace
637 asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall)
642 if (secure_computing(syscall) == -1)
645 if (test_thread_flag(TIF_SYSCALL_TRACE) &&
646 tracehook_report_syscall_entry(regs))
649 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
650 trace_sys_enter(regs, regs->regs[2]);
652 audit_syscall_entry(syscall_get_arch(current, regs),
654 regs->regs[4], regs->regs[5],
655 regs->regs[6], regs->regs[7]);
660 * Notification of system call entry/exit
661 * - triggered by current->work.syscall_trace
663 asmlinkage void syscall_trace_leave(struct pt_regs *regs)
666 * We may come here right after calling schedule_user()
667 * or do_notify_resume(), in which case we can be in RCU
672 audit_syscall_exit(regs);
674 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
675 trace_sys_exit(regs, regs->regs[2]);
677 if (test_thread_flag(TIF_SYSCALL_TRACE))
678 tracehook_report_syscall_exit(regs, 0);