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 */
73 static const int use_ptrace
= 1; /* set to 0 to disable ptrace */
75 /* handle a status returned by wait4 */
76 static int handle_child_status( struct thread
*thread
, int pid
, int status
, int want_sig
)
78 if (WIFSTOPPED(status
))
80 int sig
= WSTOPSIG(status
);
81 if (debug_level
&& thread
)
82 fprintf( stderr
, "%04x: *signal* signal=%d\n", thread
->id
, sig
);
85 /* ignore other signals for now */
86 if (thread
&& get_thread_single_step( thread
))
87 ptrace( PTRACE_SINGLESTEP
, pid
, (caddr_t
)1, sig
);
89 ptrace( PTRACE_CONT
, pid
, (caddr_t
)1, sig
);
93 if (thread
&& (WIFSIGNALED(status
) || WIFEXITED(status
)))
96 thread
->unix_pid
= -1;
97 thread
->unix_tid
= -1;
100 if (WIFSIGNALED(status
))
101 fprintf( stderr
, "%04x: *exited* signal=%d\n",
102 thread
->id
, WTERMSIG(status
) );
104 fprintf( stderr
, "%04x: *exited* status=%d\n",
105 thread
->id
, WEXITSTATUS(status
) );
111 /* handle a SIGCHLD signal */
112 void sigchld_handler()
118 if (!(pid
= wait4( -1, &status
, WUNTRACED
| WNOHANG
| __WALL
, NULL
))) break;
119 if (pid
!= -1) handle_child_status( get_thread_from_pid(pid
), pid
, status
, -1 );
124 /* wait for a ptraced child to get a certain signal */
125 static void wait4_thread( struct thread
*thread
, int signal
)
131 if ((res
= wait4( get_ptrace_pid(thread
), &status
, WUNTRACED
| __WALL
, NULL
)) == -1)
133 if (errno
== ECHILD
) /* must have died */
135 thread
->unix_pid
= -1;
136 thread
->unix_tid
= -1;
137 thread
->attached
= 0;
139 else perror( "wait4" );
142 res
= handle_child_status( thread
, res
, status
, signal
);
143 } while (res
&& res
!= signal
);
146 /* return the Unix pid to use in ptrace calls for a given thread */
147 int get_ptrace_pid( struct thread
*thread
)
149 if (thread
->unix_tid
!= -1) return thread
->unix_tid
;
150 return thread
->unix_pid
;
153 /* send a Unix signal to a specific thread */
154 int send_thread_signal( struct thread
*thread
, int sig
)
158 if (thread
->unix_pid
!= -1)
160 if (thread
->unix_tid
!= -1) ret
= tkill( thread
->unix_tid
, sig
);
161 else ret
= kill( thread
->unix_pid
, sig
);
163 if (ret
== -1 && errno
== ESRCH
) /* thread got killed */
165 thread
->unix_pid
= -1;
166 thread
->unix_tid
= -1;
167 thread
->attached
= 0;
173 /* attach to a Unix thread */
174 static int attach_thread( struct thread
*thread
)
176 /* this may fail if the client is already being debugged */
177 if (!use_ptrace
) return 0;
178 if (ptrace( PTRACE_ATTACH
, get_ptrace_pid(thread
), 0, 0 ) == -1)
180 if (errno
== ESRCH
) thread
->unix_pid
= thread
->unix_tid
= -1; /* thread got killed */
183 if (debug_level
) fprintf( stderr
, "%04x: *attached*\n", thread
->id
);
184 thread
->attached
= 1;
185 wait4_thread( thread
, SIGSTOP
);
189 /* detach from a Unix thread and kill it */
190 void detach_thread( struct thread
*thread
, int sig
)
192 if (thread
->unix_pid
== -1) return;
193 if (thread
->attached
)
195 /* make sure it is stopped */
196 suspend_for_ptrace( thread
);
197 if (sig
) send_thread_signal( thread
, sig
);
198 if (thread
->unix_pid
== -1) return;
199 if (debug_level
) fprintf( stderr
, "%04x: *detached*\n", thread
->id
);
200 ptrace( PTRACE_DETACH
, get_ptrace_pid(thread
), (caddr_t
)1, sig
);
201 thread
->attached
= 0;
203 else if (sig
) send_thread_signal( thread
, sig
);
206 /* attach to a Unix process with ptrace */
207 int attach_process( struct process
*process
)
209 struct thread
*thread
;
212 if (!process
->thread_list
) /* need at least one running thread */
214 set_error( STATUS_ACCESS_DENIED
);
217 for (thread
= process
->thread_list
; thread
; thread
= thread
->proc_next
)
219 if (thread
->attached
) continue;
220 if (suspend_for_ptrace( thread
)) resume_after_ptrace( thread
);
226 /* detach from a ptraced Unix process */
227 void detach_process( struct process
*process
)
229 struct thread
*thread
;
231 for (thread
= process
->thread_list
; thread
; thread
= thread
->proc_next
)
233 if (thread
->attached
) detach_thread( thread
, 0 );
237 /* suspend a thread to allow using ptrace on it */
238 /* you must do a resume_after_ptrace when finished with the thread */
239 int suspend_for_ptrace( struct thread
*thread
)
241 /* can't stop a thread while initialisation is in progress */
242 if (thread
->unix_pid
== -1 || !is_process_init_done(thread
->process
)) goto error
;
244 if (thread
->attached
)
246 send_thread_signal( thread
, SIGSTOP
);
247 wait4_thread( thread
, SIGSTOP
);
250 if (attach_thread( thread
)) return 1;
252 set_error( STATUS_ACCESS_DENIED
);
256 /* resume a thread after we have used ptrace on it */
257 void resume_after_ptrace( struct thread
*thread
)
259 if (thread
->unix_pid
== -1) return;
260 assert( thread
->attached
);
261 ptrace( get_thread_single_step(thread
) ? PTRACE_SINGLESTEP
: PTRACE_CONT
,
262 get_ptrace_pid(thread
), (caddr_t
)1, 0 /* cancel the SIGSTOP */ );
265 /* read an int from a thread address space */
266 int read_thread_int( struct thread
*thread
, const int *addr
, int *data
)
269 *data
= ptrace( PTRACE_PEEKDATA
, get_ptrace_pid(thread
), (caddr_t
)addr
, 0 );
270 if ( *data
== -1 && errno
)
278 /* write an int to a thread address space */
279 int write_thread_int( struct thread
*thread
, int *addr
, int data
, unsigned int mask
)
284 if (read_thread_int( thread
, addr
, &res
) == -1) return -1;
285 data
= (data
& mask
) | (res
& ~mask
);
287 if ((res
= ptrace( PTRACE_POKEDATA
, get_ptrace_pid(thread
), (caddr_t
)addr
, data
)) == -1)