2 * Server-side ptrace support
4 * Copyright (C) 1999 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <sys/types.h>
28 #ifdef HAVE_SYS_PTRACE_H
29 # include <sys/ptrace.h>
31 #ifdef HAVE_SYS_WAIT_H
32 # include <sys/wait.h>
41 #define PTRACE_CONT PT_CONTINUE
43 #ifndef PTRACE_SINGLESTEP
44 #define PTRACE_SINGLESTEP PT_STEP
47 #define PTRACE_ATTACH PT_ATTACH
50 #define PTRACE_DETACH PT_DETACH
52 #ifndef PTRACE_PEEKDATA
53 #define PTRACE_PEEKDATA PT_READ_D
55 #ifndef PTRACE_POKEDATA
56 #define PTRACE_POKEDATA PT_WRITE_D
59 #ifndef HAVE_SYS_PTRACE_H
66 inline static int ptrace(int req
, ...) { errno
= EPERM
; return -1; /*FAIL*/ }
67 #endif /* HAVE_SYS_PTRACE_H */
69 static const int use_ptrace
= 1; /* set to 0 to disable ptrace */
71 /* handle a status returned by wait4 */
72 static int handle_child_status( struct thread
*thread
, int pid
, int status
, int want_sig
)
74 if (WIFSTOPPED(status
))
76 int sig
= WSTOPSIG(status
);
77 if (debug_level
&& thread
)
78 fprintf( stderr
, "%04x: *signal* signal=%d\n", thread
->id
, sig
);
81 /* ignore other signals for now */
82 if (thread
&& get_thread_single_step( thread
))
83 ptrace( PTRACE_SINGLESTEP
, pid
, (caddr_t
)1, sig
);
85 ptrace( PTRACE_CONT
, pid
, (caddr_t
)1, sig
);
89 if (thread
&& (WIFSIGNALED(status
) || WIFEXITED(status
)))
92 thread
->unix_pid
= -1;
93 thread
->unix_tid
= -1;
96 if (WIFSIGNALED(status
))
97 fprintf( stderr
, "%04x: *exited* signal=%d\n",
98 thread
->id
, WTERMSIG(status
) );
100 fprintf( stderr
, "%04x: *exited* status=%d\n",
101 thread
->id
, WEXITSTATUS(status
) );
107 /* wait4 wrapper to handle missing __WALL flag in older kernels */
108 static inline pid_t
wait4_wrapper( pid_t pid
, int *status
, int options
, struct rusage
*usage
)
111 static int wall_flag
= __WALL
;
115 pid_t ret
= wait4( pid
, status
, options
| wall_flag
, usage
);
116 if (ret
!= -1 || !wall_flag
|| errno
!= EINVAL
) return ret
;
120 return wait4( pid
, status
, options
, usage
);
124 /* handle a SIGCHLD signal */
125 void sigchld_callback(void)
131 if (!(pid
= wait4_wrapper( -1, &status
, WUNTRACED
| WNOHANG
, NULL
))) break;
132 if (pid
!= -1) handle_child_status( get_thread_from_pid(pid
), pid
, status
, -1 );
137 /* wait for a ptraced child to get a certain signal */
138 static int wait4_thread( struct thread
*thread
, int signal
)
145 if ((res
= wait4_wrapper( get_ptrace_pid(thread
), &status
, WUNTRACED
, NULL
)) == -1)
149 if (!watchdog_triggered()) continue;
150 if (debug_level
) fprintf( stderr
, "%04x: *watchdog* wait4 aborted\n", thread
->id
);
152 else if (errno
== ECHILD
) /* must have died */
154 thread
->unix_pid
= -1;
155 thread
->unix_tid
= -1;
156 thread
->attached
= 0;
158 else perror( "wait4" );
162 res
= handle_child_status( thread
, res
, status
, signal
);
163 if (!res
|| res
== signal
) break;
166 return (thread
->unix_pid
!= -1);
169 /* return the Unix pid to use in ptrace calls for a given thread */
170 int get_ptrace_pid( struct thread
*thread
)
172 if (thread
->unix_tid
!= -1) return thread
->unix_tid
;
173 return thread
->unix_pid
;
176 /* send a Unix signal to a specific thread */
177 int send_thread_signal( struct thread
*thread
, int sig
)
181 if (thread
->unix_pid
!= -1)
183 if (thread
->unix_tid
!= -1)
185 ret
= tkill( thread
->unix_tid
, sig
);
186 if (ret
== -1 && errno
== ENOSYS
) ret
= kill( thread
->unix_pid
, sig
);
188 else ret
= kill( thread
->unix_pid
, sig
);
190 if (ret
== -1 && errno
== ESRCH
) /* thread got killed */
192 thread
->unix_pid
= -1;
193 thread
->unix_tid
= -1;
194 thread
->attached
= 0;
200 /* detach from a Unix thread and kill it */
201 void detach_thread( struct thread
*thread
, int sig
)
203 if (thread
->unix_pid
== -1) return;
204 if (thread
->attached
)
206 /* make sure it is stopped */
207 suspend_for_ptrace( thread
);
208 if (sig
) send_thread_signal( thread
, sig
);
209 if (thread
->unix_pid
== -1) return;
210 if (debug_level
) fprintf( stderr
, "%04x: *detached*\n", thread
->id
);
211 ptrace( PTRACE_DETACH
, get_ptrace_pid(thread
), (caddr_t
)1, sig
);
212 thread
->attached
= 0;
214 else if (sig
) send_thread_signal( thread
, sig
);
217 /* attach to a Unix process with ptrace */
218 int attach_process( struct process
*process
)
220 struct thread
*thread
;
223 if (list_empty( &process
->thread_list
)) /* need at least one running thread */
225 set_error( STATUS_ACCESS_DENIED
);
229 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
231 if (thread
->attached
) continue;
232 if (suspend_for_ptrace( thread
)) resume_after_ptrace( thread
);
238 /* detach from a ptraced Unix process */
239 void detach_process( struct process
*process
)
241 struct thread
*thread
;
243 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
245 if (thread
->attached
) detach_thread( thread
, 0 );
249 /* suspend a thread to allow using ptrace on it */
250 /* you must do a resume_after_ptrace when finished with the thread */
251 int suspend_for_ptrace( struct thread
*thread
)
253 /* can't stop a thread while initialisation is in progress */
254 if (thread
->unix_pid
== -1 || !is_process_init_done(thread
->process
)) goto error
;
256 if (thread
->attached
)
258 if (!send_thread_signal( thread
, SIGSTOP
)) goto error
;
262 /* this may fail if the client is already being debugged */
263 if (!use_ptrace
) goto error
;
264 if (ptrace( PTRACE_ATTACH
, get_ptrace_pid(thread
), 0, 0 ) == -1)
266 if (errno
== ESRCH
) thread
->unix_pid
= thread
->unix_tid
= -1; /* thread got killed */
269 if (debug_level
) fprintf( stderr
, "%04x: *attached*\n", thread
->id
);
270 thread
->attached
= 1;
272 if (wait4_thread( thread
, SIGSTOP
)) return 1;
273 resume_after_ptrace( thread
);
275 set_error( STATUS_ACCESS_DENIED
);
279 /* resume a thread after we have used ptrace on it */
280 void resume_after_ptrace( struct thread
*thread
)
282 if (thread
->unix_pid
== -1) return;
283 assert( thread
->attached
);
284 ptrace( get_thread_single_step(thread
) ? PTRACE_SINGLESTEP
: PTRACE_CONT
,
285 get_ptrace_pid(thread
), (caddr_t
)1, 0 /* cancel the SIGSTOP */ );
288 /* read an int from a thread address space */
289 int read_thread_int( struct thread
*thread
, const int *addr
, int *data
)
292 *data
= ptrace( PTRACE_PEEKDATA
, get_ptrace_pid(thread
), (caddr_t
)addr
, 0 );
293 if ( *data
== -1 && errno
)
301 /* write an int to a thread address space */
302 int write_thread_int( struct thread
*thread
, int *addr
, int data
, unsigned int mask
)
307 if (read_thread_int( thread
, addr
, &res
) == -1) return -1;
308 data
= (data
& mask
) | (res
& ~mask
);
310 if ((res
= ptrace( PTRACE_POKEDATA
, get_ptrace_pid(thread
), (caddr_t
)addr
, data
)) == -1)