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
|| boot_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(boot_cpu_data
.watch_reg_use_cnt
,
181 &addr
->WATCH_STYLE
.num_valid
);
182 for (i
= 0; i
< boot_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(boot_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
|| boot_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
< boot_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
< boot_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(),
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);