3 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
5 * Derived from "arch/m68k/kernel/ptrace.c"
6 * Copyright (C) 1994 by Hamish Macdonald
7 * Taken from linux/kernel/ptrace.c and modified for M680x0.
8 * linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
10 * Modified by Cort Dougan (cort@hq.fsmlabs.com)
11 * and Paul Mackerras (paulus@samba.org).
13 * This file is subject to the terms and conditions of the GNU General
14 * Public License. See the file README.legal in the main directory of
15 * this archive for more details.
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
21 #include <linux/smp.h>
22 #include <linux/errno.h>
23 #include <linux/ptrace.h>
24 #include <linux/regset.h>
25 #include <linux/tracehook.h>
26 #include <linux/elf.h>
27 #include <linux/user.h>
28 #include <linux/security.h>
29 #include <linux/signal.h>
30 #include <linux/seccomp.h>
31 #include <linux/audit.h>
32 #include <trace/syscall.h>
33 #include <linux/hw_breakpoint.h>
34 #include <linux/perf_event.h>
35 #include <linux/context_tracking.h>
37 #include <asm/uaccess.h>
39 #include <asm/pgtable.h>
40 #include <asm/switch_to.h>
42 #define CREATE_TRACE_POINTS
43 #include <trace/events/syscalls.h>
46 * The parameter save area on the stack is used to store arguments being passed
47 * to callee function and is located at fixed offset from stack pointer.
50 #define PARAMETER_SAVE_AREA_OFFSET 24 /* bytes */
51 #else /* CONFIG_PPC32 */
52 #define PARAMETER_SAVE_AREA_OFFSET 48 /* bytes */
55 struct pt_regs_offset
{
60 #define STR(s) #s /* convert to string */
61 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
62 #define GPR_OFFSET_NAME(num) \
63 {.name = STR(r##num), .offset = offsetof(struct pt_regs, gpr[num])}, \
64 {.name = STR(gpr##num), .offset = offsetof(struct pt_regs, gpr[num])}
65 #define REG_OFFSET_END {.name = NULL, .offset = 0}
67 #define TVSO(f) (offsetof(struct thread_vr_state, f))
68 #define TFSO(f) (offsetof(struct thread_fp_state, f))
69 #define TSO(f) (offsetof(struct thread_struct, f))
71 static const struct pt_regs_offset regoffset_table
[] = {
104 REG_OFFSET_NAME(nip
),
105 REG_OFFSET_NAME(msr
),
106 REG_OFFSET_NAME(ctr
),
107 REG_OFFSET_NAME(link
),
108 REG_OFFSET_NAME(xer
),
109 REG_OFFSET_NAME(ccr
),
111 REG_OFFSET_NAME(softe
),
115 REG_OFFSET_NAME(trap
),
116 REG_OFFSET_NAME(dar
),
117 REG_OFFSET_NAME(dsisr
),
122 * regs_query_register_offset() - query register offset from its name
123 * @name: the name of a register
125 * regs_query_register_offset() returns the offset of a register in struct
126 * pt_regs from its name. If the name is invalid, this returns -EINVAL;
128 int regs_query_register_offset(const char *name
)
130 const struct pt_regs_offset
*roff
;
131 for (roff
= regoffset_table
; roff
->name
!= NULL
; roff
++)
132 if (!strcmp(roff
->name
, name
))
138 * regs_query_register_name() - query register name from its offset
139 * @offset: the offset of a register in struct pt_regs.
141 * regs_query_register_name() returns the name of a register from its
142 * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
144 const char *regs_query_register_name(unsigned int offset
)
146 const struct pt_regs_offset
*roff
;
147 for (roff
= regoffset_table
; roff
->name
!= NULL
; roff
++)
148 if (roff
->offset
== offset
)
154 * does not yet catch signals sent when the child dies.
155 * in exit.c or in signal.c.
159 * Set of msr bits that gdb can change on behalf of a process.
161 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
162 #define MSR_DEBUGCHANGE 0
164 #define MSR_DEBUGCHANGE (MSR_SE | MSR_BE)
168 * Max register writeable via put_reg
171 #define PT_MAX_PUT_REG PT_MQ
173 #define PT_MAX_PUT_REG PT_CCR
176 static unsigned long get_user_msr(struct task_struct
*task
)
178 return task
->thread
.regs
->msr
| task
->thread
.fpexc_mode
;
181 static int set_user_msr(struct task_struct
*task
, unsigned long msr
)
183 task
->thread
.regs
->msr
&= ~MSR_DEBUGCHANGE
;
184 task
->thread
.regs
->msr
|= msr
& MSR_DEBUGCHANGE
;
188 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
189 static unsigned long get_user_ckpt_msr(struct task_struct
*task
)
191 return task
->thread
.ckpt_regs
.msr
| task
->thread
.fpexc_mode
;
194 static int set_user_ckpt_msr(struct task_struct
*task
, unsigned long msr
)
196 task
->thread
.ckpt_regs
.msr
&= ~MSR_DEBUGCHANGE
;
197 task
->thread
.ckpt_regs
.msr
|= msr
& MSR_DEBUGCHANGE
;
201 static int set_user_ckpt_trap(struct task_struct
*task
, unsigned long trap
)
203 task
->thread
.ckpt_regs
.trap
= trap
& 0xfff0;
209 static int get_user_dscr(struct task_struct
*task
, unsigned long *data
)
211 *data
= task
->thread
.dscr
;
215 static int set_user_dscr(struct task_struct
*task
, unsigned long dscr
)
217 task
->thread
.dscr
= dscr
;
218 task
->thread
.dscr_inherit
= 1;
222 static int get_user_dscr(struct task_struct
*task
, unsigned long *data
)
227 static int set_user_dscr(struct task_struct
*task
, unsigned long dscr
)
234 * We prevent mucking around with the reserved area of trap
235 * which are used internally by the kernel.
237 static int set_user_trap(struct task_struct
*task
, unsigned long trap
)
239 task
->thread
.regs
->trap
= trap
& 0xfff0;
244 * Get contents of register REGNO in task TASK.
246 int ptrace_get_reg(struct task_struct
*task
, int regno
, unsigned long *data
)
248 if ((task
->thread
.regs
== NULL
) || !data
)
251 if (regno
== PT_MSR
) {
252 *data
= get_user_msr(task
);
256 if (regno
== PT_DSCR
)
257 return get_user_dscr(task
, data
);
259 if (regno
< (sizeof(struct pt_regs
) / sizeof(unsigned long))) {
260 *data
= ((unsigned long *)task
->thread
.regs
)[regno
];
268 * Write contents of register REGNO in task TASK.
270 int ptrace_put_reg(struct task_struct
*task
, int regno
, unsigned long data
)
272 if (task
->thread
.regs
== NULL
)
276 return set_user_msr(task
, data
);
277 if (regno
== PT_TRAP
)
278 return set_user_trap(task
, data
);
279 if (regno
== PT_DSCR
)
280 return set_user_dscr(task
, data
);
282 if (regno
<= PT_MAX_PUT_REG
) {
283 ((unsigned long *)task
->thread
.regs
)[regno
] = data
;
289 static int gpr_get(struct task_struct
*target
, const struct user_regset
*regset
,
290 unsigned int pos
, unsigned int count
,
291 void *kbuf
, void __user
*ubuf
)
295 if (target
->thread
.regs
== NULL
)
298 if (!FULL_REGS(target
->thread
.regs
)) {
299 /* We have a partial register set. Fill 14-31 with bogus values */
300 for (i
= 14; i
< 32; i
++)
301 target
->thread
.regs
->gpr
[i
] = NV_REG_POISON
;
304 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
306 0, offsetof(struct pt_regs
, msr
));
308 unsigned long msr
= get_user_msr(target
);
309 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, &msr
,
310 offsetof(struct pt_regs
, msr
),
311 offsetof(struct pt_regs
, msr
) +
315 BUILD_BUG_ON(offsetof(struct pt_regs
, orig_gpr3
) !=
316 offsetof(struct pt_regs
, msr
) + sizeof(long));
319 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
320 &target
->thread
.regs
->orig_gpr3
,
321 offsetof(struct pt_regs
, orig_gpr3
),
322 sizeof(struct pt_regs
));
324 ret
= user_regset_copyout_zero(&pos
, &count
, &kbuf
, &ubuf
,
325 sizeof(struct pt_regs
), -1);
330 static int gpr_set(struct task_struct
*target
, const struct user_regset
*regset
,
331 unsigned int pos
, unsigned int count
,
332 const void *kbuf
, const void __user
*ubuf
)
337 if (target
->thread
.regs
== NULL
)
340 CHECK_FULL_REGS(target
->thread
.regs
);
342 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
344 0, PT_MSR
* sizeof(reg
));
346 if (!ret
&& count
> 0) {
347 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, ®
,
348 PT_MSR
* sizeof(reg
),
349 (PT_MSR
+ 1) * sizeof(reg
));
351 ret
= set_user_msr(target
, reg
);
354 BUILD_BUG_ON(offsetof(struct pt_regs
, orig_gpr3
) !=
355 offsetof(struct pt_regs
, msr
) + sizeof(long));
358 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
359 &target
->thread
.regs
->orig_gpr3
,
360 PT_ORIG_R3
* sizeof(reg
),
361 (PT_MAX_PUT_REG
+ 1) * sizeof(reg
));
363 if (PT_MAX_PUT_REG
+ 1 < PT_TRAP
&& !ret
)
364 ret
= user_regset_copyin_ignore(
365 &pos
, &count
, &kbuf
, &ubuf
,
366 (PT_MAX_PUT_REG
+ 1) * sizeof(reg
),
367 PT_TRAP
* sizeof(reg
));
369 if (!ret
&& count
> 0) {
370 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, ®
,
371 PT_TRAP
* sizeof(reg
),
372 (PT_TRAP
+ 1) * sizeof(reg
));
374 ret
= set_user_trap(target
, reg
);
378 ret
= user_regset_copyin_ignore(
379 &pos
, &count
, &kbuf
, &ubuf
,
380 (PT_TRAP
+ 1) * sizeof(reg
), -1);
386 * When the transaction is active, 'transact_fp' holds the current running
387 * value of all FPR registers and 'fp_state' holds the last checkpointed
388 * value of all FPR registers for the current transaction. When transaction
389 * is not active 'fp_state' holds the current running state of all the FPR
390 * registers. So this function which returns the current running values of
391 * all the FPR registers, needs to know whether any transaction is active
394 * Userspace interface buffer layout:
401 * There are two config options CONFIG_VSX and CONFIG_PPC_TRANSACTIONAL_MEM
402 * which determines the final code in this function. All the combinations of
403 * these two config options are possible except the one below as transactional
404 * memory config pulls in CONFIG_VSX automatically.
406 * !defined(CONFIG_VSX) && defined(CONFIG_PPC_TRANSACTIONAL_MEM)
408 static int fpr_get(struct task_struct
*target
, const struct user_regset
*regset
,
409 unsigned int pos
, unsigned int count
,
410 void *kbuf
, void __user
*ubuf
)
416 flush_fp_to_thread(target
);
418 #if defined(CONFIG_VSX) && defined(CONFIG_PPC_TRANSACTIONAL_MEM)
419 /* copy to local buffer then write that out */
420 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
)) {
421 flush_altivec_to_thread(target
);
422 flush_tmregs_to_thread(target
);
423 for (i
= 0; i
< 32 ; i
++)
424 buf
[i
] = target
->thread
.TS_TRANS_FPR(i
);
425 buf
[32] = target
->thread
.transact_fp
.fpscr
;
427 for (i
= 0; i
< 32 ; i
++)
428 buf
[i
] = target
->thread
.TS_FPR(i
);
429 buf
[32] = target
->thread
.fp_state
.fpscr
;
431 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, buf
, 0, -1);
434 #if defined(CONFIG_VSX) && !defined(CONFIG_PPC_TRANSACTIONAL_MEM)
435 /* copy to local buffer then write that out */
436 for (i
= 0; i
< 32 ; i
++)
437 buf
[i
] = target
->thread
.TS_FPR(i
);
438 buf
[32] = target
->thread
.fp_state
.fpscr
;
439 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, buf
, 0, -1);
442 #if !defined(CONFIG_VSX) && !defined(CONFIG_PPC_TRANSACTIONAL_MEM)
443 BUILD_BUG_ON(offsetof(struct thread_fp_state
, fpscr
) !=
444 offsetof(struct thread_fp_state
, fpr
[32]));
446 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
447 &target
->thread
.fp_state
, 0, -1);
452 * When the transaction is active, 'transact_fp' holds the current running
453 * value of all FPR registers and 'fp_state' holds the last checkpointed
454 * value of all FPR registers for the current transaction. When transaction
455 * is not active 'fp_state' holds the current running state of all the FPR
456 * registers. So this function which setss the current running values of
457 * all the FPR registers, needs to know whether any transaction is active
460 * Userspace interface buffer layout:
467 * There are two config options CONFIG_VSX and CONFIG_PPC_TRANSACTIONAL_MEM
468 * which determines the final code in this function. All the combinations of
469 * these two config options are possible except the one below as transactional
470 * memory config pulls in CONFIG_VSX automatically.
472 * !defined(CONFIG_VSX) && defined(CONFIG_PPC_TRANSACTIONAL_MEM)
474 static int fpr_set(struct task_struct
*target
, const struct user_regset
*regset
,
475 unsigned int pos
, unsigned int count
,
476 const void *kbuf
, const void __user
*ubuf
)
482 flush_fp_to_thread(target
);
484 #if defined(CONFIG_VSX) && defined(CONFIG_PPC_TRANSACTIONAL_MEM)
485 /* copy to local buffer then write that out */
486 i
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, buf
, 0, -1);
490 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
)) {
491 flush_altivec_to_thread(target
);
492 flush_tmregs_to_thread(target
);
493 for (i
= 0; i
< 32 ; i
++)
494 target
->thread
.TS_TRANS_FPR(i
) = buf
[i
];
495 target
->thread
.transact_fp
.fpscr
= buf
[32];
497 for (i
= 0; i
< 32 ; i
++)
498 target
->thread
.TS_FPR(i
) = buf
[i
];
499 target
->thread
.fp_state
.fpscr
= buf
[32];
504 #if defined(CONFIG_VSX) && !defined(CONFIG_PPC_TRANSACTIONAL_MEM)
505 /* copy to local buffer then write that out */
506 i
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, buf
, 0, -1);
509 for (i
= 0; i
< 32 ; i
++)
510 target
->thread
.TS_FPR(i
) = buf
[i
];
511 target
->thread
.fp_state
.fpscr
= buf
[32];
515 #if !defined(CONFIG_VSX) && !defined(CONFIG_PPC_TRANSACTIONAL_MEM)
516 BUILD_BUG_ON(offsetof(struct thread_fp_state
, fpscr
) !=
517 offsetof(struct thread_fp_state
, fpr
[32]));
519 return user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
520 &target
->thread
.fp_state
, 0, -1);
524 #ifdef CONFIG_ALTIVEC
526 * Get/set all the altivec registers vr0..vr31, vscr, vrsave, in one go.
527 * The transfer totals 34 quadword. Quadwords 0-31 contain the
528 * corresponding vector registers. Quadword 32 contains the vscr as the
529 * last word (offset 12) within that quadword. Quadword 33 contains the
530 * vrsave as the first word (offset 0) within the quadword.
532 * This definition of the VMX state is compatible with the current PPC32
533 * ptrace interface. This allows signal handling and ptrace to use the
534 * same structures. This also simplifies the implementation of a bi-arch
535 * (combined (32- and 64-bit) gdb.
538 static int vr_active(struct task_struct
*target
,
539 const struct user_regset
*regset
)
541 flush_altivec_to_thread(target
);
542 return target
->thread
.used_vr
? regset
->n
: 0;
546 * When the transaction is active, 'transact_vr' holds the current running
547 * value of all the VMX registers and 'vr_state' holds the last checkpointed
548 * value of all the VMX registers for the current transaction to fall back
549 * on in case it aborts. When transaction is not active 'vr_state' holds
550 * the current running state of all the VMX registers. So this function which
551 * gets the current running values of all the VMX registers, needs to know
552 * whether any transaction is active or not.
554 * Userspace interface buffer layout:
562 static int vr_get(struct task_struct
*target
, const struct user_regset
*regset
,
563 unsigned int pos
, unsigned int count
,
564 void *kbuf
, void __user
*ubuf
)
566 struct thread_vr_state
*addr
;
569 flush_altivec_to_thread(target
);
571 BUILD_BUG_ON(offsetof(struct thread_vr_state
, vscr
) !=
572 offsetof(struct thread_vr_state
, vr
[32]));
574 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
575 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
)) {
576 flush_fp_to_thread(target
);
577 flush_tmregs_to_thread(target
);
578 addr
= &target
->thread
.transact_vr
;
580 addr
= &target
->thread
.vr_state
;
583 addr
= &target
->thread
.vr_state
;
585 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
587 33 * sizeof(vector128
));
590 * Copy out only the low-order word of vrsave.
596 memset(&vrsave
, 0, sizeof(vrsave
));
598 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
599 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
600 vrsave
.word
= target
->thread
.transact_vrsave
;
602 vrsave
.word
= target
->thread
.vrsave
;
604 vrsave
.word
= target
->thread
.vrsave
;
607 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, &vrsave
,
608 33 * sizeof(vector128
), -1);
615 * When the transaction is active, 'transact_vr' holds the current running
616 * value of all the VMX registers and 'vr_state' holds the last checkpointed
617 * value of all the VMX registers for the current transaction to fall back
618 * on in case it aborts. When transaction is not active 'vr_state' holds
619 * the current running state of all the VMX registers. So this function which
620 * sets the current running values of all the VMX registers, needs to know
621 * whether any transaction is active or not.
623 * Userspace interface buffer layout:
631 static int vr_set(struct task_struct
*target
, const struct user_regset
*regset
,
632 unsigned int pos
, unsigned int count
,
633 const void *kbuf
, const void __user
*ubuf
)
635 struct thread_vr_state
*addr
;
638 flush_altivec_to_thread(target
);
640 BUILD_BUG_ON(offsetof(struct thread_vr_state
, vscr
) !=
641 offsetof(struct thread_vr_state
, vr
[32]));
643 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
644 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
)) {
645 flush_fp_to_thread(target
);
646 flush_tmregs_to_thread(target
);
647 addr
= &target
->thread
.transact_vr
;
649 addr
= &target
->thread
.vr_state
;
652 addr
= &target
->thread
.vr_state
;
654 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
656 33 * sizeof(vector128
));
657 if (!ret
&& count
> 0) {
659 * We use only the first word of vrsave.
665 memset(&vrsave
, 0, sizeof(vrsave
));
667 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
668 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
669 vrsave
.word
= target
->thread
.transact_vrsave
;
671 vrsave
.word
= target
->thread
.vrsave
;
673 vrsave
.word
= target
->thread
.vrsave
;
675 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, &vrsave
,
676 33 * sizeof(vector128
), -1);
679 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
680 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
681 target
->thread
.transact_vrsave
= vrsave
.word
;
683 target
->thread
.vrsave
= vrsave
.word
;
685 target
->thread
.vrsave
= vrsave
.word
;
692 #endif /* CONFIG_ALTIVEC */
696 * Currently to set and and get all the vsx state, you need to call
697 * the fp and VMX calls as well. This only get/sets the lower 32
698 * 128bit VSX registers.
701 static int vsr_active(struct task_struct
*target
,
702 const struct user_regset
*regset
)
704 flush_vsx_to_thread(target
);
705 return target
->thread
.used_vsr
? regset
->n
: 0;
709 * When the transaction is active, 'transact_fp' holds the current running
710 * value of all FPR registers and 'fp_state' holds the last checkpointed
711 * value of all FPR registers for the current transaction. When transaction
712 * is not active 'fp_state' holds the current running state of all the FPR
713 * registers. So this function which returns the current running values of
714 * all the FPR registers, needs to know whether any transaction is active
717 * Userspace interface buffer layout:
723 static int vsr_get(struct task_struct
*target
, const struct user_regset
*regset
,
724 unsigned int pos
, unsigned int count
,
725 void *kbuf
, void __user
*ubuf
)
730 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
731 flush_fp_to_thread(target
);
732 flush_altivec_to_thread(target
);
733 flush_tmregs_to_thread(target
);
735 flush_vsx_to_thread(target
);
737 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
738 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
)) {
739 for (i
= 0; i
< 32 ; i
++)
740 buf
[i
] = target
->thread
.
741 transact_fp
.fpr
[i
][TS_VSRLOWOFFSET
];
743 for (i
= 0; i
< 32 ; i
++)
744 buf
[i
] = target
->thread
.
745 fp_state
.fpr
[i
][TS_VSRLOWOFFSET
];
748 for (i
= 0; i
< 32 ; i
++)
749 buf
[i
] = target
->thread
.fp_state
.fpr
[i
][TS_VSRLOWOFFSET
];
751 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
752 buf
, 0, 32 * sizeof(double));
758 * When the transaction is active, 'transact_fp' holds the current running
759 * value of all FPR registers and 'fp_state' holds the last checkpointed
760 * value of all FPR registers for the current transaction. When transaction
761 * is not active 'fp_state' holds the current running state of all the FPR
762 * registers. So this function which sets the current running values of all
763 * the FPR registers, needs to know whether any transaction is active or not.
765 * Userspace interface buffer layout:
771 static int vsr_set(struct task_struct
*target
, const struct user_regset
*regset
,
772 unsigned int pos
, unsigned int count
,
773 const void *kbuf
, const void __user
*ubuf
)
778 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
779 flush_fp_to_thread(target
);
780 flush_altivec_to_thread(target
);
781 flush_tmregs_to_thread(target
);
783 flush_vsx_to_thread(target
);
785 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
786 buf
, 0, 32 * sizeof(double));
788 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
789 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
)) {
790 for (i
= 0; i
< 32 ; i
++)
791 target
->thread
.transact_fp
.
792 fpr
[i
][TS_VSRLOWOFFSET
] = buf
[i
];
794 for (i
= 0; i
< 32 ; i
++)
795 target
->thread
.fp_state
.
796 fpr
[i
][TS_VSRLOWOFFSET
] = buf
[i
];
799 for (i
= 0; i
< 32 ; i
++)
800 target
->thread
.fp_state
.fpr
[i
][TS_VSRLOWOFFSET
] = buf
[i
];
806 #endif /* CONFIG_VSX */
811 * For get_evrregs/set_evrregs functions 'data' has the following layout:
820 static int evr_active(struct task_struct
*target
,
821 const struct user_regset
*regset
)
823 flush_spe_to_thread(target
);
824 return target
->thread
.used_spe
? regset
->n
: 0;
827 static int evr_get(struct task_struct
*target
, const struct user_regset
*regset
,
828 unsigned int pos
, unsigned int count
,
829 void *kbuf
, void __user
*ubuf
)
833 flush_spe_to_thread(target
);
835 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
837 0, sizeof(target
->thread
.evr
));
839 BUILD_BUG_ON(offsetof(struct thread_struct
, acc
) + sizeof(u64
) !=
840 offsetof(struct thread_struct
, spefscr
));
843 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
845 sizeof(target
->thread
.evr
), -1);
850 static int evr_set(struct task_struct
*target
, const struct user_regset
*regset
,
851 unsigned int pos
, unsigned int count
,
852 const void *kbuf
, const void __user
*ubuf
)
856 flush_spe_to_thread(target
);
858 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
860 0, sizeof(target
->thread
.evr
));
862 BUILD_BUG_ON(offsetof(struct thread_struct
, acc
) + sizeof(u64
) !=
863 offsetof(struct thread_struct
, spefscr
));
866 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
868 sizeof(target
->thread
.evr
), -1);
872 #endif /* CONFIG_SPE */
874 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
876 * tm_cgpr_active - get active number of registers in CGPR
877 * @target: The target task.
878 * @regset: The user regset structure.
880 * This function checks for the active number of available
881 * regisers in transaction checkpointed GPR category.
883 static int tm_cgpr_active(struct task_struct
*target
,
884 const struct user_regset
*regset
)
886 if (!cpu_has_feature(CPU_FTR_TM
))
889 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
896 * tm_cgpr_get - get CGPR registers
897 * @target: The target task.
898 * @regset: The user regset structure.
899 * @pos: The buffer position.
900 * @count: Number of bytes to copy.
901 * @kbuf: Kernel buffer to copy from.
902 * @ubuf: User buffer to copy into.
904 * This function gets transaction checkpointed GPR registers.
906 * When the transaction is active, 'ckpt_regs' holds all the checkpointed
907 * GPR register values for the current transaction to fall back on if it
908 * aborts in between. This function gets those checkpointed GPR registers.
909 * The userspace interface buffer layout is as follows.
912 * struct pt_regs ckpt_regs;
915 static int tm_cgpr_get(struct task_struct
*target
,
916 const struct user_regset
*regset
,
917 unsigned int pos
, unsigned int count
,
918 void *kbuf
, void __user
*ubuf
)
922 if (!cpu_has_feature(CPU_FTR_TM
))
925 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
928 flush_fp_to_thread(target
);
929 flush_altivec_to_thread(target
);
930 flush_tmregs_to_thread(target
);
932 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
933 &target
->thread
.ckpt_regs
,
934 0, offsetof(struct pt_regs
, msr
));
936 unsigned long msr
= get_user_ckpt_msr(target
);
938 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, &msr
,
939 offsetof(struct pt_regs
, msr
),
940 offsetof(struct pt_regs
, msr
) +
944 BUILD_BUG_ON(offsetof(struct pt_regs
, orig_gpr3
) !=
945 offsetof(struct pt_regs
, msr
) + sizeof(long));
948 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
949 &target
->thread
.ckpt_regs
.orig_gpr3
,
950 offsetof(struct pt_regs
, orig_gpr3
),
951 sizeof(struct pt_regs
));
953 ret
= user_regset_copyout_zero(&pos
, &count
, &kbuf
, &ubuf
,
954 sizeof(struct pt_regs
), -1);
960 * tm_cgpr_set - set the CGPR registers
961 * @target: The target task.
962 * @regset: The user regset structure.
963 * @pos: The buffer position.
964 * @count: Number of bytes to copy.
965 * @kbuf: Kernel buffer to copy into.
966 * @ubuf: User buffer to copy from.
968 * This function sets in transaction checkpointed GPR registers.
970 * When the transaction is active, 'ckpt_regs' holds the checkpointed
971 * GPR register values for the current transaction to fall back on if it
972 * aborts in between. This function sets those checkpointed GPR registers.
973 * The userspace interface buffer layout is as follows.
976 * struct pt_regs ckpt_regs;
979 static int tm_cgpr_set(struct task_struct
*target
,
980 const struct user_regset
*regset
,
981 unsigned int pos
, unsigned int count
,
982 const void *kbuf
, const void __user
*ubuf
)
987 if (!cpu_has_feature(CPU_FTR_TM
))
990 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
993 flush_fp_to_thread(target
);
994 flush_altivec_to_thread(target
);
995 flush_tmregs_to_thread(target
);
997 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
998 &target
->thread
.ckpt_regs
,
999 0, PT_MSR
* sizeof(reg
));
1001 if (!ret
&& count
> 0) {
1002 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, ®
,
1003 PT_MSR
* sizeof(reg
),
1004 (PT_MSR
+ 1) * sizeof(reg
));
1006 ret
= set_user_ckpt_msr(target
, reg
);
1009 BUILD_BUG_ON(offsetof(struct pt_regs
, orig_gpr3
) !=
1010 offsetof(struct pt_regs
, msr
) + sizeof(long));
1013 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1014 &target
->thread
.ckpt_regs
.orig_gpr3
,
1015 PT_ORIG_R3
* sizeof(reg
),
1016 (PT_MAX_PUT_REG
+ 1) * sizeof(reg
));
1018 if (PT_MAX_PUT_REG
+ 1 < PT_TRAP
&& !ret
)
1019 ret
= user_regset_copyin_ignore(
1020 &pos
, &count
, &kbuf
, &ubuf
,
1021 (PT_MAX_PUT_REG
+ 1) * sizeof(reg
),
1022 PT_TRAP
* sizeof(reg
));
1024 if (!ret
&& count
> 0) {
1025 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, ®
,
1026 PT_TRAP
* sizeof(reg
),
1027 (PT_TRAP
+ 1) * sizeof(reg
));
1029 ret
= set_user_ckpt_trap(target
, reg
);
1033 ret
= user_regset_copyin_ignore(
1034 &pos
, &count
, &kbuf
, &ubuf
,
1035 (PT_TRAP
+ 1) * sizeof(reg
), -1);
1041 * tm_cfpr_active - get active number of registers in CFPR
1042 * @target: The target task.
1043 * @regset: The user regset structure.
1045 * This function checks for the active number of available
1046 * regisers in transaction checkpointed FPR category.
1048 static int tm_cfpr_active(struct task_struct
*target
,
1049 const struct user_regset
*regset
)
1051 if (!cpu_has_feature(CPU_FTR_TM
))
1054 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1061 * tm_cfpr_get - get CFPR registers
1062 * @target: The target task.
1063 * @regset: The user regset structure.
1064 * @pos: The buffer position.
1065 * @count: Number of bytes to copy.
1066 * @kbuf: Kernel buffer to copy from.
1067 * @ubuf: User buffer to copy into.
1069 * This function gets in transaction checkpointed FPR registers.
1071 * When the transaction is active 'fp_state' holds the checkpointed
1072 * values for the current transaction to fall back on if it aborts
1073 * in between. This function gets those checkpointed FPR registers.
1074 * The userspace interface buffer layout is as follows.
1081 static int tm_cfpr_get(struct task_struct
*target
,
1082 const struct user_regset
*regset
,
1083 unsigned int pos
, unsigned int count
,
1084 void *kbuf
, void __user
*ubuf
)
1089 if (!cpu_has_feature(CPU_FTR_TM
))
1092 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1095 flush_fp_to_thread(target
);
1096 flush_altivec_to_thread(target
);
1097 flush_tmregs_to_thread(target
);
1099 /* copy to local buffer then write that out */
1100 for (i
= 0; i
< 32 ; i
++)
1101 buf
[i
] = target
->thread
.TS_FPR(i
);
1102 buf
[32] = target
->thread
.fp_state
.fpscr
;
1103 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, buf
, 0, -1);
1107 * tm_cfpr_set - set CFPR registers
1108 * @target: The target task.
1109 * @regset: The user regset structure.
1110 * @pos: The buffer position.
1111 * @count: Number of bytes to copy.
1112 * @kbuf: Kernel buffer to copy into.
1113 * @ubuf: User buffer to copy from.
1115 * This function sets in transaction checkpointed FPR registers.
1117 * When the transaction is active 'fp_state' holds the checkpointed
1118 * FPR register values for the current transaction to fall back on
1119 * if it aborts in between. This function sets these checkpointed
1120 * FPR registers. The userspace interface buffer layout is as follows.
1127 static int tm_cfpr_set(struct task_struct
*target
,
1128 const struct user_regset
*regset
,
1129 unsigned int pos
, unsigned int count
,
1130 const void *kbuf
, const void __user
*ubuf
)
1135 if (!cpu_has_feature(CPU_FTR_TM
))
1138 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1141 flush_fp_to_thread(target
);
1142 flush_altivec_to_thread(target
);
1143 flush_tmregs_to_thread(target
);
1145 /* copy to local buffer then write that out */
1146 i
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, buf
, 0, -1);
1149 for (i
= 0; i
< 32 ; i
++)
1150 target
->thread
.TS_FPR(i
) = buf
[i
];
1151 target
->thread
.fp_state
.fpscr
= buf
[32];
1156 * tm_cvmx_active - get active number of registers in CVMX
1157 * @target: The target task.
1158 * @regset: The user regset structure.
1160 * This function checks for the active number of available
1161 * regisers in checkpointed VMX category.
1163 static int tm_cvmx_active(struct task_struct
*target
,
1164 const struct user_regset
*regset
)
1166 if (!cpu_has_feature(CPU_FTR_TM
))
1169 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1176 * tm_cvmx_get - get CMVX registers
1177 * @target: The target task.
1178 * @regset: The user regset structure.
1179 * @pos: The buffer position.
1180 * @count: Number of bytes to copy.
1181 * @kbuf: Kernel buffer to copy from.
1182 * @ubuf: User buffer to copy into.
1184 * This function gets in transaction checkpointed VMX registers.
1186 * When the transaction is active 'vr_state' and 'vr_save' hold
1187 * the checkpointed values for the current transaction to fall
1188 * back on if it aborts in between. The userspace interface buffer
1189 * layout is as follows.
1197 static int tm_cvmx_get(struct task_struct
*target
,
1198 const struct user_regset
*regset
,
1199 unsigned int pos
, unsigned int count
,
1200 void *kbuf
, void __user
*ubuf
)
1204 BUILD_BUG_ON(TVSO(vscr
) != TVSO(vr
[32]));
1206 if (!cpu_has_feature(CPU_FTR_TM
))
1209 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1212 /* Flush the state */
1213 flush_fp_to_thread(target
);
1214 flush_altivec_to_thread(target
);
1215 flush_tmregs_to_thread(target
);
1217 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1218 &target
->thread
.vr_state
, 0,
1219 33 * sizeof(vector128
));
1222 * Copy out only the low-order word of vrsave.
1228 memset(&vrsave
, 0, sizeof(vrsave
));
1229 vrsave
.word
= target
->thread
.vrsave
;
1230 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, &vrsave
,
1231 33 * sizeof(vector128
), -1);
1238 * tm_cvmx_set - set CMVX registers
1239 * @target: The target task.
1240 * @regset: The user regset structure.
1241 * @pos: The buffer position.
1242 * @count: Number of bytes to copy.
1243 * @kbuf: Kernel buffer to copy into.
1244 * @ubuf: User buffer to copy from.
1246 * This function sets in transaction checkpointed VMX registers.
1248 * When the transaction is active 'vr_state' and 'vr_save' hold
1249 * the checkpointed values for the current transaction to fall
1250 * back on if it aborts in between. The userspace interface buffer
1251 * layout is as follows.
1259 static int tm_cvmx_set(struct task_struct
*target
,
1260 const struct user_regset
*regset
,
1261 unsigned int pos
, unsigned int count
,
1262 const void *kbuf
, const void __user
*ubuf
)
1266 BUILD_BUG_ON(TVSO(vscr
) != TVSO(vr
[32]));
1268 if (!cpu_has_feature(CPU_FTR_TM
))
1271 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1274 flush_fp_to_thread(target
);
1275 flush_altivec_to_thread(target
);
1276 flush_tmregs_to_thread(target
);
1278 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1279 &target
->thread
.vr_state
, 0,
1280 33 * sizeof(vector128
));
1281 if (!ret
&& count
> 0) {
1283 * We use only the low-order word of vrsave.
1289 memset(&vrsave
, 0, sizeof(vrsave
));
1290 vrsave
.word
= target
->thread
.vrsave
;
1291 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, &vrsave
,
1292 33 * sizeof(vector128
), -1);
1294 target
->thread
.vrsave
= vrsave
.word
;
1301 * tm_cvsx_active - get active number of registers in CVSX
1302 * @target: The target task.
1303 * @regset: The user regset structure.
1305 * This function checks for the active number of available
1306 * regisers in transaction checkpointed VSX category.
1308 static int tm_cvsx_active(struct task_struct
*target
,
1309 const struct user_regset
*regset
)
1311 if (!cpu_has_feature(CPU_FTR_TM
))
1314 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1317 flush_vsx_to_thread(target
);
1318 return target
->thread
.used_vsr
? regset
->n
: 0;
1322 * tm_cvsx_get - get CVSX registers
1323 * @target: The target task.
1324 * @regset: The user regset structure.
1325 * @pos: The buffer position.
1326 * @count: Number of bytes to copy.
1327 * @kbuf: Kernel buffer to copy from.
1328 * @ubuf: User buffer to copy into.
1330 * This function gets in transaction checkpointed VSX registers.
1332 * When the transaction is active 'fp_state' holds the checkpointed
1333 * values for the current transaction to fall back on if it aborts
1334 * in between. This function gets those checkpointed VSX registers.
1335 * The userspace interface buffer layout is as follows.
1341 static int tm_cvsx_get(struct task_struct
*target
,
1342 const struct user_regset
*regset
,
1343 unsigned int pos
, unsigned int count
,
1344 void *kbuf
, void __user
*ubuf
)
1349 if (!cpu_has_feature(CPU_FTR_TM
))
1352 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1355 /* Flush the state */
1356 flush_fp_to_thread(target
);
1357 flush_altivec_to_thread(target
);
1358 flush_tmregs_to_thread(target
);
1359 flush_vsx_to_thread(target
);
1361 for (i
= 0; i
< 32 ; i
++)
1362 buf
[i
] = target
->thread
.fp_state
.fpr
[i
][TS_VSRLOWOFFSET
];
1363 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1364 buf
, 0, 32 * sizeof(double));
1370 * tm_cvsx_set - set CFPR registers
1371 * @target: The target task.
1372 * @regset: The user regset structure.
1373 * @pos: The buffer position.
1374 * @count: Number of bytes to copy.
1375 * @kbuf: Kernel buffer to copy into.
1376 * @ubuf: User buffer to copy from.
1378 * This function sets in transaction checkpointed VSX registers.
1380 * When the transaction is active 'fp_state' holds the checkpointed
1381 * VSX register values for the current transaction to fall back on
1382 * if it aborts in between. This function sets these checkpointed
1383 * FPR registers. The userspace interface buffer layout is as follows.
1389 static int tm_cvsx_set(struct task_struct
*target
,
1390 const struct user_regset
*regset
,
1391 unsigned int pos
, unsigned int count
,
1392 const void *kbuf
, const void __user
*ubuf
)
1397 if (!cpu_has_feature(CPU_FTR_TM
))
1400 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1403 /* Flush the state */
1404 flush_fp_to_thread(target
);
1405 flush_altivec_to_thread(target
);
1406 flush_tmregs_to_thread(target
);
1407 flush_vsx_to_thread(target
);
1409 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1410 buf
, 0, 32 * sizeof(double));
1411 for (i
= 0; i
< 32 ; i
++)
1412 target
->thread
.fp_state
.fpr
[i
][TS_VSRLOWOFFSET
] = buf
[i
];
1418 * tm_spr_active - get active number of registers in TM SPR
1419 * @target: The target task.
1420 * @regset: The user regset structure.
1422 * This function checks the active number of available
1423 * regisers in the transactional memory SPR category.
1425 static int tm_spr_active(struct task_struct
*target
,
1426 const struct user_regset
*regset
)
1428 if (!cpu_has_feature(CPU_FTR_TM
))
1435 * tm_spr_get - get the TM related SPR registers
1436 * @target: The target task.
1437 * @regset: The user regset structure.
1438 * @pos: The buffer position.
1439 * @count: Number of bytes to copy.
1440 * @kbuf: Kernel buffer to copy from.
1441 * @ubuf: User buffer to copy into.
1443 * This function gets transactional memory related SPR registers.
1444 * The userspace interface buffer layout is as follows.
1452 static int tm_spr_get(struct task_struct
*target
,
1453 const struct user_regset
*regset
,
1454 unsigned int pos
, unsigned int count
,
1455 void *kbuf
, void __user
*ubuf
)
1460 BUILD_BUG_ON(TSO(tm_tfhar
) + sizeof(u64
) != TSO(tm_texasr
));
1461 BUILD_BUG_ON(TSO(tm_texasr
) + sizeof(u64
) != TSO(tm_tfiar
));
1462 BUILD_BUG_ON(TSO(tm_tfiar
) + sizeof(u64
) != TSO(ckpt_regs
));
1464 if (!cpu_has_feature(CPU_FTR_TM
))
1467 /* Flush the states */
1468 flush_fp_to_thread(target
);
1469 flush_altivec_to_thread(target
);
1470 flush_tmregs_to_thread(target
);
1472 /* TFHAR register */
1473 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1474 &target
->thread
.tm_tfhar
, 0, sizeof(u64
));
1476 /* TEXASR register */
1478 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1479 &target
->thread
.tm_texasr
, sizeof(u64
),
1482 /* TFIAR register */
1484 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1485 &target
->thread
.tm_tfiar
,
1486 2 * sizeof(u64
), 3 * sizeof(u64
));
1491 * tm_spr_set - set the TM related SPR registers
1492 * @target: The target task.
1493 * @regset: The user regset structure.
1494 * @pos: The buffer position.
1495 * @count: Number of bytes to copy.
1496 * @kbuf: Kernel buffer to copy into.
1497 * @ubuf: User buffer to copy from.
1499 * This function sets transactional memory related SPR registers.
1500 * The userspace interface buffer layout is as follows.
1508 static int tm_spr_set(struct task_struct
*target
,
1509 const struct user_regset
*regset
,
1510 unsigned int pos
, unsigned int count
,
1511 const void *kbuf
, const void __user
*ubuf
)
1516 BUILD_BUG_ON(TSO(tm_tfhar
) + sizeof(u64
) != TSO(tm_texasr
));
1517 BUILD_BUG_ON(TSO(tm_texasr
) + sizeof(u64
) != TSO(tm_tfiar
));
1518 BUILD_BUG_ON(TSO(tm_tfiar
) + sizeof(u64
) != TSO(ckpt_regs
));
1520 if (!cpu_has_feature(CPU_FTR_TM
))
1523 /* Flush the states */
1524 flush_fp_to_thread(target
);
1525 flush_altivec_to_thread(target
);
1526 flush_tmregs_to_thread(target
);
1528 /* TFHAR register */
1529 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1530 &target
->thread
.tm_tfhar
, 0, sizeof(u64
));
1532 /* TEXASR register */
1534 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1535 &target
->thread
.tm_texasr
, sizeof(u64
),
1538 /* TFIAR register */
1540 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1541 &target
->thread
.tm_tfiar
,
1542 2 * sizeof(u64
), 3 * sizeof(u64
));
1546 static int tm_tar_active(struct task_struct
*target
,
1547 const struct user_regset
*regset
)
1549 if (!cpu_has_feature(CPU_FTR_TM
))
1552 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1558 static int tm_tar_get(struct task_struct
*target
,
1559 const struct user_regset
*regset
,
1560 unsigned int pos
, unsigned int count
,
1561 void *kbuf
, void __user
*ubuf
)
1565 if (!cpu_has_feature(CPU_FTR_TM
))
1568 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1571 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1572 &target
->thread
.tm_tar
, 0, sizeof(u64
));
1576 static int tm_tar_set(struct task_struct
*target
,
1577 const struct user_regset
*regset
,
1578 unsigned int pos
, unsigned int count
,
1579 const void *kbuf
, const void __user
*ubuf
)
1583 if (!cpu_has_feature(CPU_FTR_TM
))
1586 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1589 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1590 &target
->thread
.tm_tar
, 0, sizeof(u64
));
1594 static int tm_ppr_active(struct task_struct
*target
,
1595 const struct user_regset
*regset
)
1597 if (!cpu_has_feature(CPU_FTR_TM
))
1600 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1607 static int tm_ppr_get(struct task_struct
*target
,
1608 const struct user_regset
*regset
,
1609 unsigned int pos
, unsigned int count
,
1610 void *kbuf
, void __user
*ubuf
)
1614 if (!cpu_has_feature(CPU_FTR_TM
))
1617 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1620 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1621 &target
->thread
.tm_ppr
, 0, sizeof(u64
));
1625 static int tm_ppr_set(struct task_struct
*target
,
1626 const struct user_regset
*regset
,
1627 unsigned int pos
, unsigned int count
,
1628 const void *kbuf
, const void __user
*ubuf
)
1632 if (!cpu_has_feature(CPU_FTR_TM
))
1635 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1638 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1639 &target
->thread
.tm_ppr
, 0, sizeof(u64
));
1643 static int tm_dscr_active(struct task_struct
*target
,
1644 const struct user_regset
*regset
)
1646 if (!cpu_has_feature(CPU_FTR_TM
))
1649 if (MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1655 static int tm_dscr_get(struct task_struct
*target
,
1656 const struct user_regset
*regset
,
1657 unsigned int pos
, unsigned int count
,
1658 void *kbuf
, void __user
*ubuf
)
1662 if (!cpu_has_feature(CPU_FTR_TM
))
1665 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1668 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
1669 &target
->thread
.tm_dscr
, 0, sizeof(u64
));
1673 static int tm_dscr_set(struct task_struct
*target
,
1674 const struct user_regset
*regset
,
1675 unsigned int pos
, unsigned int count
,
1676 const void *kbuf
, const void __user
*ubuf
)
1680 if (!cpu_has_feature(CPU_FTR_TM
))
1683 if (!MSR_TM_ACTIVE(target
->thread
.regs
->msr
))
1686 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
1687 &target
->thread
.tm_dscr
, 0, sizeof(u64
));
1690 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
1693 * These are our native regset flavors.
1695 enum powerpc_regset
{
1698 #ifdef CONFIG_ALTIVEC
1707 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1708 REGSET_TM_CGPR
, /* TM checkpointed GPR registers */
1709 REGSET_TM_CFPR
, /* TM checkpointed FPR registers */
1710 REGSET_TM_CVMX
, /* TM checkpointed VMX registers */
1711 REGSET_TM_CVSX
, /* TM checkpointed VSX registers */
1712 REGSET_TM_SPR
, /* TM specific SPR registers */
1713 REGSET_TM_CTAR
, /* TM checkpointed TAR register */
1714 REGSET_TM_CPPR
, /* TM checkpointed PPR register */
1715 REGSET_TM_CDSCR
, /* TM checkpointed DSCR register */
1719 static const struct user_regset native_regsets
[] = {
1721 .core_note_type
= NT_PRSTATUS
, .n
= ELF_NGREG
,
1722 .size
= sizeof(long), .align
= sizeof(long),
1723 .get
= gpr_get
, .set
= gpr_set
1726 .core_note_type
= NT_PRFPREG
, .n
= ELF_NFPREG
,
1727 .size
= sizeof(double), .align
= sizeof(double),
1728 .get
= fpr_get
, .set
= fpr_set
1730 #ifdef CONFIG_ALTIVEC
1732 .core_note_type
= NT_PPC_VMX
, .n
= 34,
1733 .size
= sizeof(vector128
), .align
= sizeof(vector128
),
1734 .active
= vr_active
, .get
= vr_get
, .set
= vr_set
1739 .core_note_type
= NT_PPC_VSX
, .n
= 32,
1740 .size
= sizeof(double), .align
= sizeof(double),
1741 .active
= vsr_active
, .get
= vsr_get
, .set
= vsr_set
1746 .core_note_type
= NT_PPC_SPE
, .n
= 35,
1747 .size
= sizeof(u32
), .align
= sizeof(u32
),
1748 .active
= evr_active
, .get
= evr_get
, .set
= evr_set
1751 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1752 [REGSET_TM_CGPR
] = {
1753 .core_note_type
= NT_PPC_TM_CGPR
, .n
= ELF_NGREG
,
1754 .size
= sizeof(long), .align
= sizeof(long),
1755 .active
= tm_cgpr_active
, .get
= tm_cgpr_get
, .set
= tm_cgpr_set
1757 [REGSET_TM_CFPR
] = {
1758 .core_note_type
= NT_PPC_TM_CFPR
, .n
= ELF_NFPREG
,
1759 .size
= sizeof(double), .align
= sizeof(double),
1760 .active
= tm_cfpr_active
, .get
= tm_cfpr_get
, .set
= tm_cfpr_set
1762 [REGSET_TM_CVMX
] = {
1763 .core_note_type
= NT_PPC_TM_CVMX
, .n
= ELF_NVMX
,
1764 .size
= sizeof(vector128
), .align
= sizeof(vector128
),
1765 .active
= tm_cvmx_active
, .get
= tm_cvmx_get
, .set
= tm_cvmx_set
1767 [REGSET_TM_CVSX
] = {
1768 .core_note_type
= NT_PPC_TM_CVSX
, .n
= ELF_NVSX
,
1769 .size
= sizeof(double), .align
= sizeof(double),
1770 .active
= tm_cvsx_active
, .get
= tm_cvsx_get
, .set
= tm_cvsx_set
1773 .core_note_type
= NT_PPC_TM_SPR
, .n
= ELF_NTMSPRREG
,
1774 .size
= sizeof(u64
), .align
= sizeof(u64
),
1775 .active
= tm_spr_active
, .get
= tm_spr_get
, .set
= tm_spr_set
1777 [REGSET_TM_CTAR
] = {
1778 .core_note_type
= NT_PPC_TM_CTAR
, .n
= 1,
1779 .size
= sizeof(u64
), .align
= sizeof(u64
),
1780 .active
= tm_tar_active
, .get
= tm_tar_get
, .set
= tm_tar_set
1782 [REGSET_TM_CPPR
] = {
1783 .core_note_type
= NT_PPC_TM_CPPR
, .n
= 1,
1784 .size
= sizeof(u64
), .align
= sizeof(u64
),
1785 .active
= tm_ppr_active
, .get
= tm_ppr_get
, .set
= tm_ppr_set
1787 [REGSET_TM_CDSCR
] = {
1788 .core_note_type
= NT_PPC_TM_CDSCR
, .n
= 1,
1789 .size
= sizeof(u64
), .align
= sizeof(u64
),
1790 .active
= tm_dscr_active
, .get
= tm_dscr_get
, .set
= tm_dscr_set
1795 static const struct user_regset_view user_ppc_native_view
= {
1796 .name
= UTS_MACHINE
, .e_machine
= ELF_ARCH
, .ei_osabi
= ELF_OSABI
,
1797 .regsets
= native_regsets
, .n
= ARRAY_SIZE(native_regsets
)
1801 #include <linux/compat.h>
1803 static int gpr32_get_common(struct task_struct
*target
,
1804 const struct user_regset
*regset
,
1805 unsigned int pos
, unsigned int count
,
1806 void *kbuf
, void __user
*ubuf
, bool tm_active
)
1808 const unsigned long *regs
= &target
->thread
.regs
->gpr
[0];
1809 const unsigned long *ckpt_regs
;
1810 compat_ulong_t
*k
= kbuf
;
1811 compat_ulong_t __user
*u
= ubuf
;
1815 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1816 ckpt_regs
= &target
->thread
.ckpt_regs
.gpr
[0];
1821 if (target
->thread
.regs
== NULL
)
1824 if (!FULL_REGS(target
->thread
.regs
)) {
1826 * We have a partial register set.
1827 * Fill 14-31 with bogus values.
1829 for (i
= 14; i
< 32; i
++)
1830 target
->thread
.regs
->gpr
[i
] = NV_REG_POISON
;
1835 count
/= sizeof(reg
);
1838 for (; count
> 0 && pos
< PT_MSR
; --count
)
1841 for (; count
> 0 && pos
< PT_MSR
; --count
)
1842 if (__put_user((compat_ulong_t
) regs
[pos
++], u
++))
1845 if (count
> 0 && pos
== PT_MSR
) {
1846 reg
= get_user_msr(target
);
1849 else if (__put_user(reg
, u
++))
1856 for (; count
> 0 && pos
< PT_REGS_COUNT
; --count
)
1859 for (; count
> 0 && pos
< PT_REGS_COUNT
; --count
)
1860 if (__put_user((compat_ulong_t
) regs
[pos
++], u
++))
1866 count
*= sizeof(reg
);
1867 return user_regset_copyout_zero(&pos
, &count
, &kbuf
, &ubuf
,
1868 PT_REGS_COUNT
* sizeof(reg
), -1);
1871 static int gpr32_set_common(struct task_struct
*target
,
1872 const struct user_regset
*regset
,
1873 unsigned int pos
, unsigned int count
,
1874 const void *kbuf
, const void __user
*ubuf
, bool tm_active
)
1876 unsigned long *regs
= &target
->thread
.regs
->gpr
[0];
1877 unsigned long *ckpt_regs
;
1878 const compat_ulong_t
*k
= kbuf
;
1879 const compat_ulong_t __user
*u
= ubuf
;
1882 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1883 ckpt_regs
= &target
->thread
.ckpt_regs
.gpr
[0];
1889 regs
= &target
->thread
.regs
->gpr
[0];
1891 if (target
->thread
.regs
== NULL
)
1894 CHECK_FULL_REGS(target
->thread
.regs
);
1898 count
/= sizeof(reg
);
1901 for (; count
> 0 && pos
< PT_MSR
; --count
)
1904 for (; count
> 0 && pos
< PT_MSR
; --count
) {
1905 if (__get_user(reg
, u
++))
1911 if (count
> 0 && pos
== PT_MSR
) {
1914 else if (__get_user(reg
, u
++))
1916 set_user_msr(target
, reg
);
1922 for (; count
> 0 && pos
<= PT_MAX_PUT_REG
; --count
)
1924 for (; count
> 0 && pos
< PT_TRAP
; --count
, ++pos
)
1927 for (; count
> 0 && pos
<= PT_MAX_PUT_REG
; --count
) {
1928 if (__get_user(reg
, u
++))
1932 for (; count
> 0 && pos
< PT_TRAP
; --count
, ++pos
)
1933 if (__get_user(reg
, u
++))
1937 if (count
> 0 && pos
== PT_TRAP
) {
1940 else if (__get_user(reg
, u
++))
1942 set_user_trap(target
, reg
);
1950 count
*= sizeof(reg
);
1951 return user_regset_copyin_ignore(&pos
, &count
, &kbuf
, &ubuf
,
1952 (PT_TRAP
+ 1) * sizeof(reg
), -1);
1955 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1956 static int tm_cgpr32_get(struct task_struct
*target
,
1957 const struct user_regset
*regset
,
1958 unsigned int pos
, unsigned int count
,
1959 void *kbuf
, void __user
*ubuf
)
1961 return gpr32_get_common(target
, regset
, pos
, count
, kbuf
, ubuf
, 1);
1964 static int tm_cgpr32_set(struct task_struct
*target
,
1965 const struct user_regset
*regset
,
1966 unsigned int pos
, unsigned int count
,
1967 const void *kbuf
, const void __user
*ubuf
)
1969 return gpr32_set_common(target
, regset
, pos
, count
, kbuf
, ubuf
, 1);
1971 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
1973 static int gpr32_get(struct task_struct
*target
,
1974 const struct user_regset
*regset
,
1975 unsigned int pos
, unsigned int count
,
1976 void *kbuf
, void __user
*ubuf
)
1978 return gpr32_get_common(target
, regset
, pos
, count
, kbuf
, ubuf
, 0);
1981 static int gpr32_set(struct task_struct
*target
,
1982 const struct user_regset
*regset
,
1983 unsigned int pos
, unsigned int count
,
1984 const void *kbuf
, const void __user
*ubuf
)
1986 return gpr32_set_common(target
, regset
, pos
, count
, kbuf
, ubuf
, 0);
1990 * These are the regset flavors matching the CONFIG_PPC32 native set.
1992 static const struct user_regset compat_regsets
[] = {
1994 .core_note_type
= NT_PRSTATUS
, .n
= ELF_NGREG
,
1995 .size
= sizeof(compat_long_t
), .align
= sizeof(compat_long_t
),
1996 .get
= gpr32_get
, .set
= gpr32_set
1999 .core_note_type
= NT_PRFPREG
, .n
= ELF_NFPREG
,
2000 .size
= sizeof(double), .align
= sizeof(double),
2001 .get
= fpr_get
, .set
= fpr_set
2003 #ifdef CONFIG_ALTIVEC
2005 .core_note_type
= NT_PPC_VMX
, .n
= 34,
2006 .size
= sizeof(vector128
), .align
= sizeof(vector128
),
2007 .active
= vr_active
, .get
= vr_get
, .set
= vr_set
2012 .core_note_type
= NT_PPC_SPE
, .n
= 35,
2013 .size
= sizeof(u32
), .align
= sizeof(u32
),
2014 .active
= evr_active
, .get
= evr_get
, .set
= evr_set
2017 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2018 [REGSET_TM_CGPR
] = {
2019 .core_note_type
= NT_PPC_TM_CGPR
, .n
= ELF_NGREG
,
2020 .size
= sizeof(long), .align
= sizeof(long),
2021 .active
= tm_cgpr_active
,
2022 .get
= tm_cgpr32_get
, .set
= tm_cgpr32_set
2024 [REGSET_TM_CFPR
] = {
2025 .core_note_type
= NT_PPC_TM_CFPR
, .n
= ELF_NFPREG
,
2026 .size
= sizeof(double), .align
= sizeof(double),
2027 .active
= tm_cfpr_active
, .get
= tm_cfpr_get
, .set
= tm_cfpr_set
2029 [REGSET_TM_CVMX
] = {
2030 .core_note_type
= NT_PPC_TM_CVMX
, .n
= ELF_NVMX
,
2031 .size
= sizeof(vector128
), .align
= sizeof(vector128
),
2032 .active
= tm_cvmx_active
, .get
= tm_cvmx_get
, .set
= tm_cvmx_set
2034 [REGSET_TM_CVSX
] = {
2035 .core_note_type
= NT_PPC_TM_CVSX
, .n
= ELF_NVSX
,
2036 .size
= sizeof(double), .align
= sizeof(double),
2037 .active
= tm_cvsx_active
, .get
= tm_cvsx_get
, .set
= tm_cvsx_set
2040 .core_note_type
= NT_PPC_TM_SPR
, .n
= ELF_NTMSPRREG
,
2041 .size
= sizeof(u64
), .align
= sizeof(u64
),
2042 .active
= tm_spr_active
, .get
= tm_spr_get
, .set
= tm_spr_set
2044 [REGSET_TM_CTAR
] = {
2045 .core_note_type
= NT_PPC_TM_CTAR
, .n
= 1,
2046 .size
= sizeof(u64
), .align
= sizeof(u64
),
2047 .active
= tm_tar_active
, .get
= tm_tar_get
, .set
= tm_tar_set
2049 [REGSET_TM_CPPR
] = {
2050 .core_note_type
= NT_PPC_TM_CPPR
, .n
= 1,
2051 .size
= sizeof(u64
), .align
= sizeof(u64
),
2052 .active
= tm_ppr_active
, .get
= tm_ppr_get
, .set
= tm_ppr_set
2054 [REGSET_TM_CDSCR
] = {
2055 .core_note_type
= NT_PPC_TM_CDSCR
, .n
= 1,
2056 .size
= sizeof(u64
), .align
= sizeof(u64
),
2057 .active
= tm_dscr_active
, .get
= tm_dscr_get
, .set
= tm_dscr_set
2062 static const struct user_regset_view user_ppc_compat_view
= {
2063 .name
= "ppc", .e_machine
= EM_PPC
, .ei_osabi
= ELF_OSABI
,
2064 .regsets
= compat_regsets
, .n
= ARRAY_SIZE(compat_regsets
)
2066 #endif /* CONFIG_PPC64 */
2068 const struct user_regset_view
*task_user_regset_view(struct task_struct
*task
)
2071 if (test_tsk_thread_flag(task
, TIF_32BIT
))
2072 return &user_ppc_compat_view
;
2074 return &user_ppc_native_view
;
2078 void user_enable_single_step(struct task_struct
*task
)
2080 struct pt_regs
*regs
= task
->thread
.regs
;
2083 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2084 task
->thread
.debug
.dbcr0
&= ~DBCR0_BT
;
2085 task
->thread
.debug
.dbcr0
|= DBCR0_IDM
| DBCR0_IC
;
2086 regs
->msr
|= MSR_DE
;
2088 regs
->msr
&= ~MSR_BE
;
2089 regs
->msr
|= MSR_SE
;
2092 set_tsk_thread_flag(task
, TIF_SINGLESTEP
);
2095 void user_enable_block_step(struct task_struct
*task
)
2097 struct pt_regs
*regs
= task
->thread
.regs
;
2100 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2101 task
->thread
.debug
.dbcr0
&= ~DBCR0_IC
;
2102 task
->thread
.debug
.dbcr0
= DBCR0_IDM
| DBCR0_BT
;
2103 regs
->msr
|= MSR_DE
;
2105 regs
->msr
&= ~MSR_SE
;
2106 regs
->msr
|= MSR_BE
;
2109 set_tsk_thread_flag(task
, TIF_SINGLESTEP
);
2112 void user_disable_single_step(struct task_struct
*task
)
2114 struct pt_regs
*regs
= task
->thread
.regs
;
2117 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2119 * The logic to disable single stepping should be as
2120 * simple as turning off the Instruction Complete flag.
2121 * And, after doing so, if all debug flags are off, turn
2122 * off DBCR0(IDM) and MSR(DE) .... Torez
2124 task
->thread
.debug
.dbcr0
&= ~(DBCR0_IC
|DBCR0_BT
);
2126 * Test to see if any of the DBCR_ACTIVE_EVENTS bits are set.
2128 if (!DBCR_ACTIVE_EVENTS(task
->thread
.debug
.dbcr0
,
2129 task
->thread
.debug
.dbcr1
)) {
2131 * All debug events were off.....
2133 task
->thread
.debug
.dbcr0
&= ~DBCR0_IDM
;
2134 regs
->msr
&= ~MSR_DE
;
2137 regs
->msr
&= ~(MSR_SE
| MSR_BE
);
2140 clear_tsk_thread_flag(task
, TIF_SINGLESTEP
);
2143 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2144 void ptrace_triggered(struct perf_event
*bp
,
2145 struct perf_sample_data
*data
, struct pt_regs
*regs
)
2147 struct perf_event_attr attr
;
2150 * Disable the breakpoint request here since ptrace has defined a
2151 * one-shot behaviour for breakpoint exceptions in PPC64.
2152 * The SIGTRAP signal is generated automatically for us in do_dabr().
2153 * We don't have to do anything about that here
2156 attr
.disabled
= true;
2157 modify_user_hw_breakpoint(bp
, &attr
);
2159 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2161 static int ptrace_set_debugreg(struct task_struct
*task
, unsigned long addr
,
2164 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2166 struct thread_struct
*thread
= &(task
->thread
);
2167 struct perf_event
*bp
;
2168 struct perf_event_attr attr
;
2169 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2170 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
2171 struct arch_hw_breakpoint hw_brk
;
2174 /* For ppc64 we support one DABR and no IABR's at the moment (ppc64).
2175 * For embedded processors we support one DAC and no IAC's at the
2181 /* The bottom 3 bits in dabr are flags */
2182 if ((data
& ~0x7UL
) >= TASK_SIZE
)
2185 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
2186 /* For processors using DABR (i.e. 970), the bottom 3 bits are flags.
2187 * It was assumed, on previous implementations, that 3 bits were
2188 * passed together with the data address, fitting the design of the
2189 * DABR register, as follows:
2193 * bit 2: Breakpoint translation
2195 * Thus, we use them here as so.
2198 /* Ensure breakpoint translation bit is set */
2199 if (data
&& !(data
& HW_BRK_TYPE_TRANSLATE
))
2201 hw_brk
.address
= data
& (~HW_BRK_TYPE_DABR
);
2202 hw_brk
.type
= (data
& HW_BRK_TYPE_DABR
) | HW_BRK_TYPE_PRIV_ALL
;
2204 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2205 bp
= thread
->ptrace_bps
[0];
2206 if ((!data
) || !(hw_brk
.type
& HW_BRK_TYPE_RDWR
)) {
2208 unregister_hw_breakpoint(bp
);
2209 thread
->ptrace_bps
[0] = NULL
;
2215 attr
.bp_addr
= hw_brk
.address
;
2216 arch_bp_generic_fields(hw_brk
.type
, &attr
.bp_type
);
2218 /* Enable breakpoint */
2219 attr
.disabled
= false;
2221 ret
= modify_user_hw_breakpoint(bp
, &attr
);
2225 thread
->ptrace_bps
[0] = bp
;
2226 thread
->hw_brk
= hw_brk
;
2230 /* Create a new breakpoint request if one doesn't exist already */
2231 hw_breakpoint_init(&attr
);
2232 attr
.bp_addr
= hw_brk
.address
;
2233 arch_bp_generic_fields(hw_brk
.type
,
2236 thread
->ptrace_bps
[0] = bp
= register_user_hw_breakpoint(&attr
,
2237 ptrace_triggered
, NULL
, task
);
2239 thread
->ptrace_bps
[0] = NULL
;
2243 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2244 task
->thread
.hw_brk
= hw_brk
;
2245 #else /* CONFIG_PPC_ADV_DEBUG_REGS */
2246 /* As described above, it was assumed 3 bits were passed with the data
2247 * address, but we will assume only the mode bits will be passed
2248 * as to not cause alignment restrictions for DAC-based processors.
2251 /* DAC's hold the whole address without any mode flags */
2252 task
->thread
.debug
.dac1
= data
& ~0x3UL
;
2254 if (task
->thread
.debug
.dac1
== 0) {
2255 dbcr_dac(task
) &= ~(DBCR_DAC1R
| DBCR_DAC1W
);
2256 if (!DBCR_ACTIVE_EVENTS(task
->thread
.debug
.dbcr0
,
2257 task
->thread
.debug
.dbcr1
)) {
2258 task
->thread
.regs
->msr
&= ~MSR_DE
;
2259 task
->thread
.debug
.dbcr0
&= ~DBCR0_IDM
;
2264 /* Read or Write bits must be set */
2266 if (!(data
& 0x3UL
))
2269 /* Set the Internal Debugging flag (IDM bit 1) for the DBCR0
2271 task
->thread
.debug
.dbcr0
|= DBCR0_IDM
;
2273 /* Check for write and read flags and set DBCR0
2275 dbcr_dac(task
) &= ~(DBCR_DAC1R
|DBCR_DAC1W
);
2277 dbcr_dac(task
) |= DBCR_DAC1R
;
2279 dbcr_dac(task
) |= DBCR_DAC1W
;
2280 task
->thread
.regs
->msr
|= MSR_DE
;
2281 #endif /* CONFIG_PPC_ADV_DEBUG_REGS */
2286 * Called by kernel/ptrace.c when detaching..
2288 * Make sure single step bits etc are not set.
2290 void ptrace_disable(struct task_struct
*child
)
2292 /* make sure the single step bit is not set. */
2293 user_disable_single_step(child
);
2296 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2297 static long set_instruction_bp(struct task_struct
*child
,
2298 struct ppc_hw_breakpoint
*bp_info
)
2301 int slot1_in_use
= ((child
->thread
.debug
.dbcr0
& DBCR0_IAC1
) != 0);
2302 int slot2_in_use
= ((child
->thread
.debug
.dbcr0
& DBCR0_IAC2
) != 0);
2303 int slot3_in_use
= ((child
->thread
.debug
.dbcr0
& DBCR0_IAC3
) != 0);
2304 int slot4_in_use
= ((child
->thread
.debug
.dbcr0
& DBCR0_IAC4
) != 0);
2306 if (dbcr_iac_range(child
) & DBCR_IAC12MODE
)
2308 if (dbcr_iac_range(child
) & DBCR_IAC34MODE
)
2311 if (bp_info
->addr
>= TASK_SIZE
)
2314 if (bp_info
->addr_mode
!= PPC_BREAKPOINT_MODE_EXACT
) {
2316 /* Make sure range is valid. */
2317 if (bp_info
->addr2
>= TASK_SIZE
)
2320 /* We need a pair of IAC regsisters */
2321 if ((!slot1_in_use
) && (!slot2_in_use
)) {
2323 child
->thread
.debug
.iac1
= bp_info
->addr
;
2324 child
->thread
.debug
.iac2
= bp_info
->addr2
;
2325 child
->thread
.debug
.dbcr0
|= DBCR0_IAC1
;
2326 if (bp_info
->addr_mode
==
2327 PPC_BREAKPOINT_MODE_RANGE_EXCLUSIVE
)
2328 dbcr_iac_range(child
) |= DBCR_IAC12X
;
2330 dbcr_iac_range(child
) |= DBCR_IAC12I
;
2331 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
2332 } else if ((!slot3_in_use
) && (!slot4_in_use
)) {
2334 child
->thread
.debug
.iac3
= bp_info
->addr
;
2335 child
->thread
.debug
.iac4
= bp_info
->addr2
;
2336 child
->thread
.debug
.dbcr0
|= DBCR0_IAC3
;
2337 if (bp_info
->addr_mode
==
2338 PPC_BREAKPOINT_MODE_RANGE_EXCLUSIVE
)
2339 dbcr_iac_range(child
) |= DBCR_IAC34X
;
2341 dbcr_iac_range(child
) |= DBCR_IAC34I
;
2346 /* We only need one. If possible leave a pair free in
2347 * case a range is needed later
2349 if (!slot1_in_use
) {
2351 * Don't use iac1 if iac1-iac2 are free and either
2352 * iac3 or iac4 (but not both) are free
2354 if (slot2_in_use
|| (slot3_in_use
== slot4_in_use
)) {
2356 child
->thread
.debug
.iac1
= bp_info
->addr
;
2357 child
->thread
.debug
.dbcr0
|= DBCR0_IAC1
;
2361 if (!slot2_in_use
) {
2363 child
->thread
.debug
.iac2
= bp_info
->addr
;
2364 child
->thread
.debug
.dbcr0
|= DBCR0_IAC2
;
2365 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
2366 } else if (!slot3_in_use
) {
2368 child
->thread
.debug
.iac3
= bp_info
->addr
;
2369 child
->thread
.debug
.dbcr0
|= DBCR0_IAC3
;
2370 } else if (!slot4_in_use
) {
2372 child
->thread
.debug
.iac4
= bp_info
->addr
;
2373 child
->thread
.debug
.dbcr0
|= DBCR0_IAC4
;
2379 child
->thread
.debug
.dbcr0
|= DBCR0_IDM
;
2380 child
->thread
.regs
->msr
|= MSR_DE
;
2385 static int del_instruction_bp(struct task_struct
*child
, int slot
)
2389 if ((child
->thread
.debug
.dbcr0
& DBCR0_IAC1
) == 0)
2392 if (dbcr_iac_range(child
) & DBCR_IAC12MODE
) {
2393 /* address range - clear slots 1 & 2 */
2394 child
->thread
.debug
.iac2
= 0;
2395 dbcr_iac_range(child
) &= ~DBCR_IAC12MODE
;
2397 child
->thread
.debug
.iac1
= 0;
2398 child
->thread
.debug
.dbcr0
&= ~DBCR0_IAC1
;
2401 if ((child
->thread
.debug
.dbcr0
& DBCR0_IAC2
) == 0)
2404 if (dbcr_iac_range(child
) & DBCR_IAC12MODE
)
2405 /* used in a range */
2407 child
->thread
.debug
.iac2
= 0;
2408 child
->thread
.debug
.dbcr0
&= ~DBCR0_IAC2
;
2410 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
2412 if ((child
->thread
.debug
.dbcr0
& DBCR0_IAC3
) == 0)
2415 if (dbcr_iac_range(child
) & DBCR_IAC34MODE
) {
2416 /* address range - clear slots 3 & 4 */
2417 child
->thread
.debug
.iac4
= 0;
2418 dbcr_iac_range(child
) &= ~DBCR_IAC34MODE
;
2420 child
->thread
.debug
.iac3
= 0;
2421 child
->thread
.debug
.dbcr0
&= ~DBCR0_IAC3
;
2424 if ((child
->thread
.debug
.dbcr0
& DBCR0_IAC4
) == 0)
2427 if (dbcr_iac_range(child
) & DBCR_IAC34MODE
)
2428 /* Used in a range */
2430 child
->thread
.debug
.iac4
= 0;
2431 child
->thread
.debug
.dbcr0
&= ~DBCR0_IAC4
;
2440 static int set_dac(struct task_struct
*child
, struct ppc_hw_breakpoint
*bp_info
)
2443 (bp_info
->condition_mode
>> PPC_BREAKPOINT_CONDITION_BE_SHIFT
)
2445 int condition_mode
=
2446 bp_info
->condition_mode
& PPC_BREAKPOINT_CONDITION_MODE
;
2449 if (byte_enable
&& (condition_mode
== 0))
2452 if (bp_info
->addr
>= TASK_SIZE
)
2455 if ((dbcr_dac(child
) & (DBCR_DAC1R
| DBCR_DAC1W
)) == 0) {
2457 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_READ
)
2458 dbcr_dac(child
) |= DBCR_DAC1R
;
2459 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_WRITE
)
2460 dbcr_dac(child
) |= DBCR_DAC1W
;
2461 child
->thread
.debug
.dac1
= (unsigned long)bp_info
->addr
;
2462 #if CONFIG_PPC_ADV_DEBUG_DVCS > 0
2464 child
->thread
.debug
.dvc1
=
2465 (unsigned long)bp_info
->condition_value
;
2466 child
->thread
.debug
.dbcr2
|=
2467 ((byte_enable
<< DBCR2_DVC1BE_SHIFT
) |
2468 (condition_mode
<< DBCR2_DVC1M_SHIFT
));
2471 #ifdef CONFIG_PPC_ADV_DEBUG_DAC_RANGE
2472 } else if (child
->thread
.debug
.dbcr2
& DBCR2_DAC12MODE
) {
2473 /* Both dac1 and dac2 are part of a range */
2476 } else if ((dbcr_dac(child
) & (DBCR_DAC2R
| DBCR_DAC2W
)) == 0) {
2478 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_READ
)
2479 dbcr_dac(child
) |= DBCR_DAC2R
;
2480 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_WRITE
)
2481 dbcr_dac(child
) |= DBCR_DAC2W
;
2482 child
->thread
.debug
.dac2
= (unsigned long)bp_info
->addr
;
2483 #if CONFIG_PPC_ADV_DEBUG_DVCS > 0
2485 child
->thread
.debug
.dvc2
=
2486 (unsigned long)bp_info
->condition_value
;
2487 child
->thread
.debug
.dbcr2
|=
2488 ((byte_enable
<< DBCR2_DVC2BE_SHIFT
) |
2489 (condition_mode
<< DBCR2_DVC2M_SHIFT
));
2494 child
->thread
.debug
.dbcr0
|= DBCR0_IDM
;
2495 child
->thread
.regs
->msr
|= MSR_DE
;
2500 static int del_dac(struct task_struct
*child
, int slot
)
2503 if ((dbcr_dac(child
) & (DBCR_DAC1R
| DBCR_DAC1W
)) == 0)
2506 child
->thread
.debug
.dac1
= 0;
2507 dbcr_dac(child
) &= ~(DBCR_DAC1R
| DBCR_DAC1W
);
2508 #ifdef CONFIG_PPC_ADV_DEBUG_DAC_RANGE
2509 if (child
->thread
.debug
.dbcr2
& DBCR2_DAC12MODE
) {
2510 child
->thread
.debug
.dac2
= 0;
2511 child
->thread
.debug
.dbcr2
&= ~DBCR2_DAC12MODE
;
2513 child
->thread
.debug
.dbcr2
&= ~(DBCR2_DVC1M
| DBCR2_DVC1BE
);
2515 #if CONFIG_PPC_ADV_DEBUG_DVCS > 0
2516 child
->thread
.debug
.dvc1
= 0;
2518 } else if (slot
== 2) {
2519 if ((dbcr_dac(child
) & (DBCR_DAC2R
| DBCR_DAC2W
)) == 0)
2522 #ifdef CONFIG_PPC_ADV_DEBUG_DAC_RANGE
2523 if (child
->thread
.debug
.dbcr2
& DBCR2_DAC12MODE
)
2524 /* Part of a range */
2526 child
->thread
.debug
.dbcr2
&= ~(DBCR2_DVC2M
| DBCR2_DVC2BE
);
2528 #if CONFIG_PPC_ADV_DEBUG_DVCS > 0
2529 child
->thread
.debug
.dvc2
= 0;
2531 child
->thread
.debug
.dac2
= 0;
2532 dbcr_dac(child
) &= ~(DBCR_DAC2R
| DBCR_DAC2W
);
2538 #endif /* CONFIG_PPC_ADV_DEBUG_REGS */
2540 #ifdef CONFIG_PPC_ADV_DEBUG_DAC_RANGE
2541 static int set_dac_range(struct task_struct
*child
,
2542 struct ppc_hw_breakpoint
*bp_info
)
2544 int mode
= bp_info
->addr_mode
& PPC_BREAKPOINT_MODE_MASK
;
2546 /* We don't allow range watchpoints to be used with DVC */
2547 if (bp_info
->condition_mode
)
2551 * Best effort to verify the address range. The user/supervisor bits
2552 * prevent trapping in kernel space, but let's fail on an obvious bad
2553 * range. The simple test on the mask is not fool-proof, and any
2554 * exclusive range will spill over into kernel space.
2556 if (bp_info
->addr
>= TASK_SIZE
)
2558 if (mode
== PPC_BREAKPOINT_MODE_MASK
) {
2560 * dac2 is a bitmask. Don't allow a mask that makes a
2561 * kernel space address from a valid dac1 value
2563 if (~((unsigned long)bp_info
->addr2
) >= TASK_SIZE
)
2567 * For range breakpoints, addr2 must also be a valid address
2569 if (bp_info
->addr2
>= TASK_SIZE
)
2573 if (child
->thread
.debug
.dbcr0
&
2574 (DBCR0_DAC1R
| DBCR0_DAC1W
| DBCR0_DAC2R
| DBCR0_DAC2W
))
2577 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_READ
)
2578 child
->thread
.debug
.dbcr0
|= (DBCR0_DAC1R
| DBCR0_IDM
);
2579 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_WRITE
)
2580 child
->thread
.debug
.dbcr0
|= (DBCR0_DAC1W
| DBCR0_IDM
);
2581 child
->thread
.debug
.dac1
= bp_info
->addr
;
2582 child
->thread
.debug
.dac2
= bp_info
->addr2
;
2583 if (mode
== PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE
)
2584 child
->thread
.debug
.dbcr2
|= DBCR2_DAC12M
;
2585 else if (mode
== PPC_BREAKPOINT_MODE_RANGE_EXCLUSIVE
)
2586 child
->thread
.debug
.dbcr2
|= DBCR2_DAC12MX
;
2587 else /* PPC_BREAKPOINT_MODE_MASK */
2588 child
->thread
.debug
.dbcr2
|= DBCR2_DAC12MM
;
2589 child
->thread
.regs
->msr
|= MSR_DE
;
2593 #endif /* CONFIG_PPC_ADV_DEBUG_DAC_RANGE */
2595 static long ppc_set_hwdebug(struct task_struct
*child
,
2596 struct ppc_hw_breakpoint
*bp_info
)
2598 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2600 struct thread_struct
*thread
= &(child
->thread
);
2601 struct perf_event
*bp
;
2602 struct perf_event_attr attr
;
2603 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2604 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
2605 struct arch_hw_breakpoint brk
;
2608 if (bp_info
->version
!= 1)
2610 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2612 * Check for invalid flags and combinations
2614 if ((bp_info
->trigger_type
== 0) ||
2615 (bp_info
->trigger_type
& ~(PPC_BREAKPOINT_TRIGGER_EXECUTE
|
2616 PPC_BREAKPOINT_TRIGGER_RW
)) ||
2617 (bp_info
->addr_mode
& ~PPC_BREAKPOINT_MODE_MASK
) ||
2618 (bp_info
->condition_mode
&
2619 ~(PPC_BREAKPOINT_CONDITION_MODE
|
2620 PPC_BREAKPOINT_CONDITION_BE_ALL
)))
2622 #if CONFIG_PPC_ADV_DEBUG_DVCS == 0
2623 if (bp_info
->condition_mode
!= PPC_BREAKPOINT_CONDITION_NONE
)
2627 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_EXECUTE
) {
2628 if ((bp_info
->trigger_type
!= PPC_BREAKPOINT_TRIGGER_EXECUTE
) ||
2629 (bp_info
->condition_mode
!= PPC_BREAKPOINT_CONDITION_NONE
))
2631 return set_instruction_bp(child
, bp_info
);
2633 if (bp_info
->addr_mode
== PPC_BREAKPOINT_MODE_EXACT
)
2634 return set_dac(child
, bp_info
);
2636 #ifdef CONFIG_PPC_ADV_DEBUG_DAC_RANGE
2637 return set_dac_range(child
, bp_info
);
2641 #else /* !CONFIG_PPC_ADV_DEBUG_DVCS */
2643 * We only support one data breakpoint
2645 if ((bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_RW
) == 0 ||
2646 (bp_info
->trigger_type
& ~PPC_BREAKPOINT_TRIGGER_RW
) != 0 ||
2647 bp_info
->condition_mode
!= PPC_BREAKPOINT_CONDITION_NONE
)
2650 if ((unsigned long)bp_info
->addr
>= TASK_SIZE
)
2653 brk
.address
= bp_info
->addr
& ~7UL;
2654 brk
.type
= HW_BRK_TYPE_TRANSLATE
;
2656 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_READ
)
2657 brk
.type
|= HW_BRK_TYPE_READ
;
2658 if (bp_info
->trigger_type
& PPC_BREAKPOINT_TRIGGER_WRITE
)
2659 brk
.type
|= HW_BRK_TYPE_WRITE
;
2660 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2662 * Check if the request is for 'range' breakpoints. We can
2663 * support it if range < 8 bytes.
2665 if (bp_info
->addr_mode
== PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE
)
2666 len
= bp_info
->addr2
- bp_info
->addr
;
2667 else if (bp_info
->addr_mode
== PPC_BREAKPOINT_MODE_EXACT
)
2671 bp
= thread
->ptrace_bps
[0];
2675 /* Create a new breakpoint request if one doesn't exist already */
2676 hw_breakpoint_init(&attr
);
2677 attr
.bp_addr
= (unsigned long)bp_info
->addr
& ~HW_BREAKPOINT_ALIGN
;
2679 arch_bp_generic_fields(brk
.type
, &attr
.bp_type
);
2681 thread
->ptrace_bps
[0] = bp
= register_user_hw_breakpoint(&attr
,
2682 ptrace_triggered
, NULL
, child
);
2684 thread
->ptrace_bps
[0] = NULL
;
2689 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2691 if (bp_info
->addr_mode
!= PPC_BREAKPOINT_MODE_EXACT
)
2694 if (child
->thread
.hw_brk
.address
)
2697 child
->thread
.hw_brk
= brk
;
2700 #endif /* !CONFIG_PPC_ADV_DEBUG_DVCS */
2703 static long ppc_del_hwdebug(struct task_struct
*child
, long data
)
2705 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2707 struct thread_struct
*thread
= &(child
->thread
);
2708 struct perf_event
*bp
;
2709 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2710 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2714 rc
= del_instruction_bp(child
, (int)data
);
2716 rc
= del_dac(child
, (int)data
- 4);
2719 if (!DBCR_ACTIVE_EVENTS(child
->thread
.debug
.dbcr0
,
2720 child
->thread
.debug
.dbcr1
)) {
2721 child
->thread
.debug
.dbcr0
&= ~DBCR0_IDM
;
2722 child
->thread
.regs
->msr
&= ~MSR_DE
;
2730 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2731 bp
= thread
->ptrace_bps
[0];
2733 unregister_hw_breakpoint(bp
);
2734 thread
->ptrace_bps
[0] = NULL
;
2738 #else /* CONFIG_HAVE_HW_BREAKPOINT */
2739 if (child
->thread
.hw_brk
.address
== 0)
2742 child
->thread
.hw_brk
.address
= 0;
2743 child
->thread
.hw_brk
.type
= 0;
2744 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2750 long arch_ptrace(struct task_struct
*child
, long request
,
2751 unsigned long addr
, unsigned long data
)
2754 void __user
*datavp
= (void __user
*) data
;
2755 unsigned long __user
*datalp
= datavp
;
2758 /* read the word at location addr in the USER area. */
2759 case PTRACE_PEEKUSR
: {
2760 unsigned long index
, tmp
;
2763 /* convert to index and check */
2766 if ((addr
& 3) || (index
> PT_FPSCR
)
2767 || (child
->thread
.regs
== NULL
))
2770 if ((addr
& 7) || (index
> PT_FPSCR
))
2774 CHECK_FULL_REGS(child
->thread
.regs
);
2775 if (index
< PT_FPR0
) {
2776 ret
= ptrace_get_reg(child
, (int) index
, &tmp
);
2780 unsigned int fpidx
= index
- PT_FPR0
;
2782 flush_fp_to_thread(child
);
2783 if (fpidx
< (PT_FPSCR
- PT_FPR0
))
2784 memcpy(&tmp
, &child
->thread
.TS_FPR(fpidx
),
2787 tmp
= child
->thread
.fp_state
.fpscr
;
2789 ret
= put_user(tmp
, datalp
);
2793 /* write the word at location addr in the USER area */
2794 case PTRACE_POKEUSR
: {
2795 unsigned long index
;
2798 /* convert to index and check */
2801 if ((addr
& 3) || (index
> PT_FPSCR
)
2802 || (child
->thread
.regs
== NULL
))
2805 if ((addr
& 7) || (index
> PT_FPSCR
))
2809 CHECK_FULL_REGS(child
->thread
.regs
);
2810 if (index
< PT_FPR0
) {
2811 ret
= ptrace_put_reg(child
, index
, data
);
2813 unsigned int fpidx
= index
- PT_FPR0
;
2815 flush_fp_to_thread(child
);
2816 if (fpidx
< (PT_FPSCR
- PT_FPR0
))
2817 memcpy(&child
->thread
.TS_FPR(fpidx
), &data
,
2820 child
->thread
.fp_state
.fpscr
= data
;
2826 case PPC_PTRACE_GETHWDBGINFO
: {
2827 struct ppc_debug_info dbginfo
;
2829 dbginfo
.version
= 1;
2830 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2831 dbginfo
.num_instruction_bps
= CONFIG_PPC_ADV_DEBUG_IACS
;
2832 dbginfo
.num_data_bps
= CONFIG_PPC_ADV_DEBUG_DACS
;
2833 dbginfo
.num_condition_regs
= CONFIG_PPC_ADV_DEBUG_DVCS
;
2834 dbginfo
.data_bp_alignment
= 4;
2835 dbginfo
.sizeof_condition
= 4;
2836 dbginfo
.features
= PPC_DEBUG_FEATURE_INSN_BP_RANGE
|
2837 PPC_DEBUG_FEATURE_INSN_BP_MASK
;
2838 #ifdef CONFIG_PPC_ADV_DEBUG_DAC_RANGE
2840 PPC_DEBUG_FEATURE_DATA_BP_RANGE
|
2841 PPC_DEBUG_FEATURE_DATA_BP_MASK
;
2843 #else /* !CONFIG_PPC_ADV_DEBUG_REGS */
2844 dbginfo
.num_instruction_bps
= 0;
2845 dbginfo
.num_data_bps
= 1;
2846 dbginfo
.num_condition_regs
= 0;
2848 dbginfo
.data_bp_alignment
= 8;
2850 dbginfo
.data_bp_alignment
= 4;
2852 dbginfo
.sizeof_condition
= 0;
2853 #ifdef CONFIG_HAVE_HW_BREAKPOINT
2854 dbginfo
.features
= PPC_DEBUG_FEATURE_DATA_BP_RANGE
;
2855 if (cpu_has_feature(CPU_FTR_DAWR
))
2856 dbginfo
.features
|= PPC_DEBUG_FEATURE_DATA_BP_DAWR
;
2858 dbginfo
.features
= 0;
2859 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
2860 #endif /* CONFIG_PPC_ADV_DEBUG_REGS */
2862 if (!access_ok(VERIFY_WRITE
, datavp
,
2863 sizeof(struct ppc_debug_info
)))
2865 ret
= __copy_to_user(datavp
, &dbginfo
,
2866 sizeof(struct ppc_debug_info
)) ?
2871 case PPC_PTRACE_SETHWDEBUG
: {
2872 struct ppc_hw_breakpoint bp_info
;
2874 if (!access_ok(VERIFY_READ
, datavp
,
2875 sizeof(struct ppc_hw_breakpoint
)))
2877 ret
= __copy_from_user(&bp_info
, datavp
,
2878 sizeof(struct ppc_hw_breakpoint
)) ?
2881 ret
= ppc_set_hwdebug(child
, &bp_info
);
2885 case PPC_PTRACE_DELHWDEBUG
: {
2886 ret
= ppc_del_hwdebug(child
, data
);
2890 case PTRACE_GET_DEBUGREG
: {
2891 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
2892 unsigned long dabr_fake
;
2895 /* We only support one DABR and no IABRS at the moment */
2898 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
2899 ret
= put_user(child
->thread
.debug
.dac1
, datalp
);
2901 dabr_fake
= ((child
->thread
.hw_brk
.address
& (~HW_BRK_TYPE_DABR
)) |
2902 (child
->thread
.hw_brk
.type
& HW_BRK_TYPE_DABR
));
2903 ret
= put_user(dabr_fake
, datalp
);
2908 case PTRACE_SET_DEBUGREG
:
2909 ret
= ptrace_set_debugreg(child
, addr
, data
);
2913 case PTRACE_GETREGS64
:
2915 case PTRACE_GETREGS
: /* Get all pt_regs from the child. */
2916 return copy_regset_to_user(child
, &user_ppc_native_view
,
2918 0, sizeof(struct pt_regs
),
2922 case PTRACE_SETREGS64
:
2924 case PTRACE_SETREGS
: /* Set all gp regs in the child. */
2925 return copy_regset_from_user(child
, &user_ppc_native_view
,
2927 0, sizeof(struct pt_regs
),
2930 case PTRACE_GETFPREGS
: /* Get the child FPU state (FPR0...31 + FPSCR) */
2931 return copy_regset_to_user(child
, &user_ppc_native_view
,
2933 0, sizeof(elf_fpregset_t
),
2936 case PTRACE_SETFPREGS
: /* Set the child FPU state (FPR0...31 + FPSCR) */
2937 return copy_regset_from_user(child
, &user_ppc_native_view
,
2939 0, sizeof(elf_fpregset_t
),
2942 #ifdef CONFIG_ALTIVEC
2943 case PTRACE_GETVRREGS
:
2944 return copy_regset_to_user(child
, &user_ppc_native_view
,
2946 0, (33 * sizeof(vector128
) +
2950 case PTRACE_SETVRREGS
:
2951 return copy_regset_from_user(child
, &user_ppc_native_view
,
2953 0, (33 * sizeof(vector128
) +
2958 case PTRACE_GETVSRREGS
:
2959 return copy_regset_to_user(child
, &user_ppc_native_view
,
2961 0, 32 * sizeof(double),
2964 case PTRACE_SETVSRREGS
:
2965 return copy_regset_from_user(child
, &user_ppc_native_view
,
2967 0, 32 * sizeof(double),
2971 case PTRACE_GETEVRREGS
:
2972 /* Get the child spe register state. */
2973 return copy_regset_to_user(child
, &user_ppc_native_view
,
2974 REGSET_SPE
, 0, 35 * sizeof(u32
),
2977 case PTRACE_SETEVRREGS
:
2978 /* Set the child spe register state. */
2979 return copy_regset_from_user(child
, &user_ppc_native_view
,
2980 REGSET_SPE
, 0, 35 * sizeof(u32
),
2985 ret
= ptrace_request(child
, request
, addr
, data
);
2991 #ifdef CONFIG_SECCOMP
2992 static int do_seccomp(struct pt_regs
*regs
)
2994 if (!test_thread_flag(TIF_SECCOMP
))
2998 * The ABI we present to seccomp tracers is that r3 contains
2999 * the syscall return value and orig_gpr3 contains the first
3000 * syscall parameter. This is different to the ptrace ABI where
3001 * both r3 and orig_gpr3 contain the first syscall parameter.
3003 regs
->gpr
[3] = -ENOSYS
;
3006 * We use the __ version here because we have already checked
3007 * TIF_SECCOMP. If this fails, there is nothing left to do, we
3008 * have already loaded -ENOSYS into r3, or seccomp has put
3009 * something else in r3 (via SECCOMP_RET_ERRNO/TRACE).
3011 if (__secure_computing(NULL
))
3015 * The syscall was allowed by seccomp, restore the register
3016 * state to what audit expects.
3017 * Note that we use orig_gpr3, which means a seccomp tracer can
3018 * modify the first syscall parameter (in orig_gpr3) and also
3019 * allow the syscall to proceed.
3021 regs
->gpr
[3] = regs
->orig_gpr3
;
3026 static inline int do_seccomp(struct pt_regs
*regs
) { return 0; }
3027 #endif /* CONFIG_SECCOMP */
3030 * do_syscall_trace_enter() - Do syscall tracing on kernel entry.
3031 * @regs: the pt_regs of the task to trace (current)
3033 * Performs various types of tracing on syscall entry. This includes seccomp,
3034 * ptrace, syscall tracepoints and audit.
3036 * The pt_regs are potentially visible to userspace via ptrace, so their
3039 * One or more of the tracers may modify the contents of pt_regs, in particular
3040 * to modify arguments or even the syscall number itself.
3042 * It's also possible that a tracer can choose to reject the system call. In
3043 * that case this function will return an illegal syscall number, and will put
3044 * an appropriate return value in regs->r3.
3046 * Return: the (possibly changed) syscall number.
3048 long do_syscall_trace_enter(struct pt_regs
*regs
)
3053 * The tracer may decide to abort the syscall, if so tracehook
3054 * will return !0. Note that the tracer may also just change
3055 * regs->gpr[0] to an invalid syscall number, that is handled
3056 * below on the exit path.
3058 if (test_thread_flag(TIF_SYSCALL_TRACE
) &&
3059 tracehook_report_syscall_entry(regs
))
3062 /* Run seccomp after ptrace; allow it to set gpr[3]. */
3063 if (do_seccomp(regs
))
3066 /* Avoid trace and audit when syscall is invalid. */
3067 if (regs
->gpr
[0] >= NR_syscalls
)
3070 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
3071 trace_sys_enter(regs
, regs
->gpr
[0]);
3074 if (!is_32bit_task())
3075 audit_syscall_entry(regs
->gpr
[0], regs
->gpr
[3], regs
->gpr
[4],
3076 regs
->gpr
[5], regs
->gpr
[6]);
3079 audit_syscall_entry(regs
->gpr
[0],
3080 regs
->gpr
[3] & 0xffffffff,
3081 regs
->gpr
[4] & 0xffffffff,
3082 regs
->gpr
[5] & 0xffffffff,
3083 regs
->gpr
[6] & 0xffffffff);
3085 /* Return the possibly modified but valid syscall number */
3086 return regs
->gpr
[0];
3090 * If we are aborting explicitly, or if the syscall number is
3091 * now invalid, set the return value to -ENOSYS.
3093 regs
->gpr
[3] = -ENOSYS
;
3097 void do_syscall_trace_leave(struct pt_regs
*regs
)
3101 audit_syscall_exit(regs
);
3103 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
3104 trace_sys_exit(regs
, regs
->result
);
3106 step
= test_thread_flag(TIF_SINGLESTEP
);
3107 if (step
|| test_thread_flag(TIF_SYSCALL_TRACE
))
3108 tracehook_report_syscall_exit(regs
, step
);