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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include <sys/types.h>
29 #ifdef HAVE_SYS_PTRACE_H
30 # include <sys/ptrace.h>
32 #ifdef HAVE_SYS_PARAM_H
33 # include <sys/param.h>
35 #ifdef HAVE_SYS_WAIT_H
36 # include <sys/wait.h>
39 # include <sys/ucontext.h>
45 #define WIN32_NO_STATUS
55 #define PTRACE_CONT PT_CONTINUE
57 #ifndef PTRACE_SINGLESTEP
58 #define PTRACE_SINGLESTEP PT_STEP
61 #define PTRACE_ATTACH PT_ATTACH
64 #define PTRACE_DETACH PT_DETACH
66 #ifndef PTRACE_PEEKDATA
67 #define PTRACE_PEEKDATA PT_READ_D
69 #ifndef PTRACE_POKEDATA
70 #define PTRACE_POKEDATA PT_WRITE_D
72 #ifndef PTRACE_PEEKUSER
73 #define PTRACE_PEEKUSER PT_READ_U
75 #ifndef PTRACE_POKEUSER
76 #define PTRACE_POKEUSER PT_WRITE_U
80 #define PTRACE_GETDBREGS PT_GETDBREGS
83 #define PTRACE_SETDBREGS PT_SETDBREGS
86 #ifndef HAVE_SYS_PTRACE_H
93 static inline int ptrace(int req
, ...) { errno
= EPERM
; return -1; /*FAIL*/ }
94 #endif /* HAVE_SYS_PTRACE_H */
96 /* handle a status returned by wait4 */
97 static int handle_child_status( struct thread
*thread
, int pid
, int status
, int want_sig
)
99 if (WIFSTOPPED(status
))
101 int sig
= WSTOPSIG(status
);
102 if (debug_level
&& thread
)
103 fprintf( stderr
, "%04x: *signal* signal=%d\n", thread
->id
, sig
);
106 /* ignore other signals for now */
107 ptrace( PTRACE_CONT
, pid
, (caddr_t
)1, sig
);
111 if (thread
&& (WIFSIGNALED(status
) || WIFEXITED(status
)))
113 thread
->unix_pid
= -1;
114 thread
->unix_tid
= -1;
117 if (WIFSIGNALED(status
))
118 fprintf( stderr
, "%04x: *exited* signal=%d\n",
119 thread
->id
, WTERMSIG(status
) );
121 fprintf( stderr
, "%04x: *exited* status=%d\n",
122 thread
->id
, WEXITSTATUS(status
) );
128 /* wait4 wrapper to handle missing __WALL flag in older kernels */
129 static inline pid_t
wait4_wrapper( pid_t pid
, int *status
, int options
, struct rusage
*usage
)
132 static int wall_flag
= __WALL
;
136 pid_t ret
= wait4( pid
, status
, options
| wall_flag
, usage
);
137 if (ret
!= -1 || !wall_flag
|| errno
!= EINVAL
) return ret
;
141 return wait4( pid
, status
, options
, usage
);
145 /* handle a SIGCHLD signal */
146 void sigchld_callback(void)
152 if (!(pid
= wait4_wrapper( -1, &status
, WUNTRACED
| WNOHANG
, NULL
))) break;
155 struct thread
*thread
= get_thread_from_tid( pid
);
156 if (!thread
) thread
= get_thread_from_pid( pid
);
157 handle_child_status( thread
, pid
, status
, -1 );
163 /* return the Unix pid to use in ptrace calls for a given process */
164 static int get_ptrace_pid( struct thread
*thread
)
166 #ifdef linux /* linux always uses thread id */
167 if (thread
->unix_tid
!= -1) return thread
->unix_tid
;
169 return thread
->unix_pid
;
172 /* return the Unix tid to use in ptrace calls for a given thread */
173 static int get_ptrace_tid( struct thread
*thread
)
175 if (thread
->unix_tid
!= -1) return thread
->unix_tid
;
176 return thread
->unix_pid
;
179 /* wait for a ptraced child to get a certain signal */
180 static int wait4_thread( struct thread
*thread
, int signal
)
187 if ((res
= wait4_wrapper( get_ptrace_pid(thread
), &status
, WUNTRACED
, NULL
)) == -1)
191 if (!watchdog_triggered()) continue;
192 if (debug_level
) fprintf( stderr
, "%04x: *watchdog* wait4 aborted\n", thread
->id
);
194 else if (errno
== ECHILD
) /* must have died */
196 thread
->unix_pid
= -1;
197 thread
->unix_tid
= -1;
199 else perror( "wait4" );
203 res
= handle_child_status( thread
, res
, status
, signal
);
204 if (!res
|| res
== signal
) break;
207 return (thread
->unix_pid
!= -1);
210 /* send a signal to a specific thread */
211 static inline int tkill( int tgid
, int pid
, int sig
)
216 __asm__( "pushl %%ebx\n\t"
221 : "0" (270) /*SYS_tgkill*/, "r" (tgid
), "c" (pid
), "d" (sig
) );
223 __asm__( "pushl %%ebx\n\t"
228 : "0" (238) /*SYS_tkill*/, "r" (pid
), "c" (sig
) );
229 # elif defined(__x86_64__)
230 __asm__( "syscall" : "=a" (ret
)
231 : "0" (200) /*SYS_tkill*/, "D" (pid
), "S" (sig
) );
233 if (ret
>= 0) return ret
;
236 #elif defined(__FreeBSD__) && defined(HAVE_THR_KILL2)
237 return thr_kill2( tgid
, pid
, sig
);
244 /* initialize the process tracing mechanism */
245 void init_tracing_mechanism(void)
247 /* no initialization needed for ptrace */
250 /* initialize the per-process tracing mechanism */
251 void init_process_tracing( struct process
*process
)
253 /* ptrace setup is done on-demand */
256 /* terminate the per-process tracing mechanism */
257 void finish_process_tracing( struct process
*process
)
261 /* send a Unix signal to a specific thread */
262 int send_thread_signal( struct thread
*thread
, int sig
)
266 if (thread
->unix_pid
!= -1)
268 if (thread
->unix_tid
!= -1)
270 ret
= tkill( thread
->unix_pid
, thread
->unix_tid
, sig
);
271 if (ret
== -1 && errno
== ENOSYS
) ret
= kill( thread
->unix_pid
, sig
);
273 else ret
= kill( thread
->unix_pid
, sig
);
275 if (ret
== -1 && errno
== ESRCH
) /* thread got killed */
277 thread
->unix_pid
= -1;
278 thread
->unix_tid
= -1;
281 if (debug_level
&& ret
!= -1)
282 fprintf( stderr
, "%04x: *sent signal* signal=%d\n", thread
->id
, sig
);
286 /* resume a thread after we have used ptrace on it */
287 static void resume_after_ptrace( struct thread
*thread
)
289 if (thread
->unix_pid
== -1) return;
290 if (ptrace( PTRACE_DETACH
, get_ptrace_pid(thread
), (caddr_t
)1, 0 ) == -1)
292 if (errno
== ESRCH
) thread
->unix_pid
= thread
->unix_tid
= -1; /* thread got killed */
296 /* suspend a thread to allow using ptrace on it */
297 /* you must do a resume_after_ptrace when finished with the thread */
298 static int suspend_for_ptrace( struct thread
*thread
)
300 /* can't stop a thread while initialisation is in progress */
301 if (thread
->unix_pid
== -1 || !is_process_init_done(thread
->process
)) goto error
;
303 /* this may fail if the client is already being debugged */
304 if (ptrace( PTRACE_ATTACH
, get_ptrace_pid(thread
), 0, 0 ) == -1)
306 if (errno
== ESRCH
) thread
->unix_pid
= thread
->unix_tid
= -1; /* thread got killed */
309 if (wait4_thread( thread
, SIGSTOP
)) return 1;
310 resume_after_ptrace( thread
);
312 set_error( STATUS_ACCESS_DENIED
);
316 /* read an int from a thread address space */
317 static int read_thread_int( struct thread
*thread
, int *addr
, int *data
)
320 *data
= ptrace( PTRACE_PEEKDATA
, get_ptrace_pid(thread
), (caddr_t
)addr
, 0 );
321 if ( *data
== -1 && errno
)
329 /* write an int to a thread address space */
330 static int write_thread_int( struct thread
*thread
, int *addr
, int data
, unsigned int mask
)
335 if (read_thread_int( thread
, addr
, &res
) == -1) return -1;
336 data
= (data
& mask
) | (res
& ~mask
);
338 if ((res
= ptrace( PTRACE_POKEDATA
, get_ptrace_pid(thread
), (caddr_t
)addr
, data
)) == -1)
343 /* return a thread of the process suitable for ptracing */
344 static struct thread
*get_ptrace_thread( struct process
*process
)
346 struct thread
*thread
;
348 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
350 if (thread
->unix_pid
!= -1) return thread
;
352 set_error( STATUS_ACCESS_DENIED
); /* process is dead */
356 /* read data from a process memory space */
357 int read_process_memory( struct process
*process
, const void *ptr
, data_size_t size
, char *dest
)
359 struct thread
*thread
= get_ptrace_thread( process
);
360 unsigned int first_offset
, last_offset
, len
;
363 if (!thread
) return 0;
365 first_offset
= (unsigned long)ptr
% sizeof(int);
366 last_offset
= (size
+ first_offset
) % sizeof(int);
367 if (!last_offset
) last_offset
= sizeof(int);
369 addr
= (int *)((char *)ptr
- first_offset
);
370 len
= (size
+ first_offset
+ sizeof(int) - 1) / sizeof(int);
372 if (suspend_for_ptrace( thread
))
376 if (read_thread_int( thread
, addr
++, &data
) == -1) goto done
;
377 memcpy( dest
, (char *)&data
+ first_offset
, sizeof(int) - first_offset
);
378 dest
+= sizeof(int) - first_offset
;
385 if (read_thread_int( thread
, addr
++, &data
) == -1) goto done
;
386 memcpy( dest
, &data
, sizeof(int) );
391 if (read_thread_int( thread
, addr
++, &data
) == -1) goto done
;
392 memcpy( dest
, (char *)&data
+ first_offset
, last_offset
- first_offset
);
396 resume_after_ptrace( thread
);
401 /* make sure we can write to the whole address range */
402 /* len is the total size (in ints) */
403 static int check_process_write_access( struct thread
*thread
, int *addr
, data_size_t len
)
405 int page
= get_page_size() / sizeof(int);
409 if (write_thread_int( thread
, addr
, 0, 0 ) == -1) return 0;
410 if (len
<= page
) break;
414 return (write_thread_int( thread
, addr
+ len
- 1, 0, 0 ) != -1);
417 /* write data to a process memory space */
418 int write_process_memory( struct process
*process
, void *ptr
, data_size_t size
, const char *src
)
420 struct thread
*thread
= get_ptrace_thread( process
);
421 int ret
= 0, data
= 0;
424 unsigned int first_mask
, first_offset
, last_mask
, last_offset
;
426 if (!thread
) return 0;
428 /* compute the mask for the first int */
430 first_offset
= (unsigned long)ptr
% sizeof(int);
431 memset( &first_mask
, 0, first_offset
);
433 /* compute the mask for the last int */
434 last_offset
= (size
+ first_offset
) % sizeof(int);
435 if (!last_offset
) last_offset
= sizeof(int);
437 memset( &last_mask
, 0xff, last_offset
);
439 addr
= (int *)((char *)ptr
- first_offset
);
440 len
= (size
+ first_offset
+ sizeof(int) - 1) / sizeof(int);
442 if (suspend_for_ptrace( thread
))
444 if (!check_process_write_access( thread
, addr
, len
))
446 set_error( STATUS_ACCESS_DENIED
);
449 /* first word is special */
452 memcpy( (char *)&data
+ first_offset
, src
, sizeof(int) - first_offset
);
453 src
+= sizeof(int) - first_offset
;
454 if (write_thread_int( thread
, addr
++, data
, first_mask
) == -1) goto done
;
458 else last_mask
&= first_mask
;
462 memcpy( &data
, src
, sizeof(int) );
464 if (write_thread_int( thread
, addr
++, data
, ~0 ) == -1) goto done
;
468 /* last word is special too */
469 memcpy( (char *)&data
+ first_offset
, src
, last_offset
- first_offset
);
470 if (write_thread_int( thread
, addr
, data
, last_mask
) == -1) goto done
;
474 resume_after_ptrace( thread
);
479 /* retrieve an LDT selector entry */
480 void get_selector_entry( struct thread
*thread
, int entry
, unsigned int *base
,
481 unsigned int *limit
, unsigned char *flags
)
483 if (!thread
->process
->ldt_copy
)
485 set_error( STATUS_ACCESS_DENIED
);
490 set_error( STATUS_ACCESS_VIOLATION
);
493 if (suspend_for_ptrace( thread
))
495 unsigned char flags_buf
[4];
496 int *addr
= (int *)thread
->process
->ldt_copy
+ entry
;
497 if (read_thread_int( thread
, addr
, (int *)base
) == -1) goto done
;
498 if (read_thread_int( thread
, addr
+ 8192, (int *)limit
) == -1) goto done
;
499 addr
= (int *)thread
->process
->ldt_copy
+ 2*8192 + (entry
>> 2);
500 if (read_thread_int( thread
, addr
, (int *)flags_buf
) == -1) goto done
;
501 *flags
= flags_buf
[entry
& 3];
503 resume_after_ptrace( thread
);
508 #if defined(linux) && (defined(__i386__) || defined(__x86_64__))
510 #ifdef HAVE_SYS_USER_H
511 # include <sys/user.h>
514 /* debug register offset in struct user */
515 #define DR_OFFSET(dr) ((((struct user *)0)->u_debugreg) + (dr))
517 /* retrieve the thread x86 registers */
518 void get_thread_context( struct thread
*thread
, CONTEXT
*context
, unsigned int flags
)
520 int i
, pid
= get_ptrace_tid(thread
);
523 /* all other regs are handled on the client side */
524 assert( (flags
| CONTEXT_i386
) == CONTEXT_DEBUG_REGISTERS
);
526 if (!suspend_for_ptrace( thread
)) return;
528 for (i
= 0; i
< 8; i
++)
530 if (i
== 4 || i
== 5) continue;
532 data
[i
] = ptrace( PTRACE_PEEKUSER
, pid
, DR_OFFSET(i
), 0 );
533 if ((data
[i
] == -1) && errno
)
539 context
->Dr0
= data
[0];
540 context
->Dr1
= data
[1];
541 context
->Dr2
= data
[2];
542 context
->Dr3
= data
[3];
543 context
->Dr6
= data
[6];
544 context
->Dr7
= data
[7];
545 context
->ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
547 resume_after_ptrace( thread
);
550 /* set the thread x86 registers */
551 void set_thread_context( struct thread
*thread
, const CONTEXT
*context
, unsigned int flags
)
553 int pid
= get_ptrace_tid( thread
);
555 /* all other regs are handled on the client side */
556 assert( (flags
| CONTEXT_i386
) == CONTEXT_DEBUG_REGISTERS
);
558 if (!suspend_for_ptrace( thread
)) return;
560 if (ptrace( PTRACE_POKEUSER
, pid
, DR_OFFSET(0), context
->Dr0
) == -1) goto error
;
561 if (thread
->context
) thread
->context
->Dr0
= context
->Dr0
;
562 if (ptrace( PTRACE_POKEUSER
, pid
, DR_OFFSET(1), context
->Dr1
) == -1) goto error
;
563 if (thread
->context
) thread
->context
->Dr1
= context
->Dr1
;
564 if (ptrace( PTRACE_POKEUSER
, pid
, DR_OFFSET(2), context
->Dr2
) == -1) goto error
;
565 if (thread
->context
) thread
->context
->Dr2
= context
->Dr2
;
566 if (ptrace( PTRACE_POKEUSER
, pid
, DR_OFFSET(3), context
->Dr3
) == -1) goto error
;
567 if (thread
->context
) thread
->context
->Dr3
= context
->Dr3
;
568 if (ptrace( PTRACE_POKEUSER
, pid
, DR_OFFSET(6), context
->Dr6
) == -1) goto error
;
569 if (thread
->context
) thread
->context
->Dr6
= context
->Dr6
;
570 if (ptrace( PTRACE_POKEUSER
, pid
, DR_OFFSET(7), context
->Dr7
) == -1) goto error
;
571 if (thread
->context
) thread
->context
->Dr7
= context
->Dr7
;
572 resume_after_ptrace( thread
);
576 resume_after_ptrace( thread
);
579 #elif defined(__i386__) && defined(PTRACE_GETDBREGS) && defined(PTRACE_SETDBREGS) && \
580 (defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__) || defined(__NetBSD__))
582 #include <machine/reg.h>
584 /* retrieve the thread x86 registers */
585 void get_thread_context( struct thread
*thread
, CONTEXT
*context
, unsigned int flags
)
587 int pid
= get_ptrace_tid(thread
);
590 /* all other regs are handled on the client side */
591 assert( (flags
| CONTEXT_i386
) == CONTEXT_DEBUG_REGISTERS
);
593 if (!suspend_for_ptrace( thread
)) return;
595 if (ptrace( PTRACE_GETDBREGS
, pid
, (caddr_t
) &dbregs
, 0 ) == -1) file_set_error();
599 /* needed for FreeBSD, the structure fields have changed under 5.x */
600 context
->Dr0
= DBREG_DRX((&dbregs
), 0);
601 context
->Dr1
= DBREG_DRX((&dbregs
), 1);
602 context
->Dr2
= DBREG_DRX((&dbregs
), 2);
603 context
->Dr3
= DBREG_DRX((&dbregs
), 3);
604 context
->Dr6
= DBREG_DRX((&dbregs
), 6);
605 context
->Dr7
= DBREG_DRX((&dbregs
), 7);
607 context
->Dr0
= dbregs
.dr0
;
608 context
->Dr1
= dbregs
.dr1
;
609 context
->Dr2
= dbregs
.dr2
;
610 context
->Dr3
= dbregs
.dr3
;
611 context
->Dr6
= dbregs
.dr6
;
612 context
->Dr7
= dbregs
.dr7
;
614 context
->ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
616 resume_after_ptrace( thread
);
619 /* set the thread x86 registers */
620 void set_thread_context( struct thread
*thread
, const CONTEXT
*context
, unsigned int flags
)
622 int pid
= get_ptrace_tid(thread
);
625 /* all other regs are handled on the client side */
626 assert( (flags
| CONTEXT_i386
) == CONTEXT_DEBUG_REGISTERS
);
628 if (!suspend_for_ptrace( thread
)) return;
631 /* needed for FreeBSD, the structure fields have changed under 5.x */
632 DBREG_DRX((&dbregs
), 0) = context
->Dr0
;
633 DBREG_DRX((&dbregs
), 1) = context
->Dr1
;
634 DBREG_DRX((&dbregs
), 2) = context
->Dr2
;
635 DBREG_DRX((&dbregs
), 3) = context
->Dr3
;
636 DBREG_DRX((&dbregs
), 4) = 0;
637 DBREG_DRX((&dbregs
), 5) = 0;
638 DBREG_DRX((&dbregs
), 6) = context
->Dr6
;
639 DBREG_DRX((&dbregs
), 7) = context
->Dr7
;
641 dbregs
.dr0
= context
->Dr0
;
642 dbregs
.dr1
= context
->Dr1
;
643 dbregs
.dr2
= context
->Dr2
;
644 dbregs
.dr3
= context
->Dr3
;
647 dbregs
.dr6
= context
->Dr6
;
648 dbregs
.dr7
= context
->Dr7
;
650 if (ptrace( PTRACE_SETDBREGS
, pid
, (caddr_t
) &dbregs
, 0 ) == -1) file_set_error();
651 else if (thread
->context
) /* update the cached values */
653 thread
->context
->Dr0
= context
->Dr0
;
654 thread
->context
->Dr1
= context
->Dr1
;
655 thread
->context
->Dr2
= context
->Dr2
;
656 thread
->context
->Dr3
= context
->Dr3
;
657 thread
->context
->Dr6
= context
->Dr6
;
658 thread
->context
->Dr7
= context
->Dr7
;
660 resume_after_ptrace( thread
);
663 #else /* linux || __FreeBSD__ */
665 /* retrieve the thread x86 registers */
666 void get_thread_context( struct thread
*thread
, CONTEXT
*context
, unsigned int flags
)
670 /* set the thread x86 debug registers */
671 void set_thread_context( struct thread
*thread
, const CONTEXT
*context
, unsigned int flags
)
675 #endif /* linux || __FreeBSD__ */
677 #endif /* USE_PTRACE */