Synchronize RBS on PTRACE_ATTACH
PATCH 3/3 Synchronize RBS on PTRACE_ATTACH
When attaching to a stopped process, the RSE must be explicitly synced to user-space, so the debugger can read the correct values.
--- ptrace.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+)
arch/ia64/kernel/ptrace.c +59 -0
@@ -613,6 +613,63 @@ void ia64_sync_krbs(void)unw_init_running (do_sync_rbs, ia64_sync_kernel_rbs); } +/* +* After PTRACE_ATTACH, a thread's register backing store area in user +* space is assumed to contain correct data whenever the thread is +* stopped. arch_ptrace_stop takes care of this on tracing stops. +* But if the child was already stopped for job control when we attach +* to it, then it might not ever get into ptrace_stop by the time we +* want to examine the user memory containing the RBS. +*/ +static void +ptrace_attach_sync_user_rbs (struct task_struct *child) +{ +int stopped =0 ; +struct unw_frame_info info; + +/* +* If the child is in TASK_STOPPED, we need to change that to +* TASK_TRACED momentarily while we operate on it. This ensures +* that the child won't be woken up and return to user mode while +* we are doing the sync. (It can only be woken up for SIGKILL.) +*/ + +read_lock (&tasklist_lock); +if (child->signal) { +spin_lock_irq (&child->sighand->siglock); +if (child->state =TASK_STOPPED && + !test_and_set_tsk_thread_flag (child,TIF_RESTORE_RSE )) { +tsk_set_notify_resume (child); + + child->state =TASK_TRACED ; + stopped =1 ; + } +spin_unlock_irq (&child->sighand->siglock); + } +read_unlock (&tasklist_lock); + +if (!stopped) +return ; + +unw_init_from_blocked_task (&info, child); +do_sync_rbs (&info, ia64_sync_user_rbs); + +/* +* Now move the child back into TASK_STOPPED if it should be in a +* job control stop, so that SIGCONT can be used to wake it up. +*/ +read_lock (&tasklist_lock); +if (child->signal) { +spin_lock_irq (&child->sighand->siglock); +if (child->state =TASK_TRACED && + (child->signal->flags &SIGNAL_STOP_STOPPED )) { + child->state =TASK_STOPPED ; + } +spin_unlock_irq (&child->sighand->siglock); + } +read_unlock (&tasklist_lock); +} +static inline int thread_matches (struct task_struct *thread,unsigned long addr) {
@@ -1520,6 +1577,8 @@ sys_ptrace (long request, pid_t pid, unsif (request =PTRACE_ATTACH ) { ret =ptrace_attach (child); +if (ret =0 ) +ptrace_attach_sync_user_rbs (child); goto out_tsk; }
This is a simple test I produced for this case (attaching a stopped process).
Regards,
Petr Tesarik
arch/ia64/kernel/ptrace.c sys_ptrace (long request, pid_t pid, uns · line 1582
Quoted 5 lines
arch/ia64/kernel/ptrace.c +2
-0if (request =PTRACE_ATTACH ) { ret =ptrace_attach (child); +if (ret =0 ) +ptrace_attach_sync_user_rbs (child); goto out_tsk;
Please make this arch_ptrace_attach(child) and #define it to ptrace_attach_sync_user_rbs for ia64. That way it will still be doing the right thing later on when we clean up ia64 ptrace to get rid of sys_ptrace and define only arch_ptrace instead.
Thanks,
Roland
PATCH 3/3 Synchronize RBS on PTRACE_ATTACH
In reply to Petr TesarikWhen attaching to a stopped process, the RSE must be explicitly synced to user-space, so the debugger can read the correct values.
--- arch/ia64/kernel/ptrace.c | 57 +++++++++++++++++++++++++++++++++++++++++++++ include/asm-ia64/ptrace.h | 4 +++ 2 files changed, 61 insertions(+), 0 deletions(-)
arch/ia64/kernel/ptrace.c +57 -0
@@ -613,6 +613,63 @@ void ia64_sync_krbs(void)unw_init_running (do_sync_rbs, ia64_sync_kernel_rbs); } +/* +* After PTRACE_ATTACH, a thread's register backing store area in user +* space is assumed to contain correct data whenever the thread is +* stopped. arch_ptrace_stop takes care of this on tracing stops. +* But if the child was already stopped for job control when we attach +* to it, then it might not ever get into ptrace_stop by the time we +* want to examine the user memory containing the RBS. +*/ +void +ptrace_attach_sync_user_rbs (struct task_struct *child) +{ +int stopped =0 ; +struct unw_frame_info info; + +/* +* If the child is in TASK_STOPPED, we need to change that to +* TASK_TRACED momentarily while we operate on it. This ensures +* that the child won't be woken up and return to user mode while +* we are doing the sync. (It can only be woken up for SIGKILL.) +*/ + +read_lock (&tasklist_lock); +if (child->signal) { +spin_lock_irq (&child->sighand->siglock); +if (child->state =TASK_STOPPED && + !test_and_set_tsk_thread_flag (child,TIF_RESTORE_RSE )) { +tsk_set_notify_resume (child); + + child->state =TASK_TRACED ; + stopped =1 ; + } +spin_unlock_irq (&child->sighand->siglock); + } +read_unlock (&tasklist_lock); + +if (!stopped) +return ; + +unw_init_from_blocked_task (&info, child); +do_sync_rbs (&info, ia64_sync_user_rbs); + +/* +* Now move the child back into TASK_STOPPED if it should be in a +* job control stop, so that SIGCONT can be used to wake it up. +*/ +read_lock (&tasklist_lock); +if (child->signal) { +spin_lock_irq (&child->sighand->siglock); +if (child->state =TASK_TRACED && + (child->signal->flags &SIGNAL_STOP_STOPPED )) { + child->state =TASK_STOPPED ; + } +spin_unlock_irq (&child->sighand->siglock); + } +read_unlock (&tasklist_lock); +} +static inline int thread_matches (struct task_struct *thread,unsigned long addr) {
include/asm-ia64/ptrace.h +4 -0
@@ -310,6 +310,10 @@ # define force_successful_syscall_return#define arch_ptrace_stop_needed (code, info) \ (!test_thread_flag(TIF_RESTORE_RSE)) +extern void ptrace_attach_sync_user_rbs (struct task_struct *); +#define arch_ptrace_attach (child) \ + ptrace_attach_sync_user_rbs(child) +#endif /* !__KERNEL__ */ /* pt_all_user_regs is used for PTRACE_GETREGS PTRACE_SETREGS */