1 /* Low-level child interface to ptrace.
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
4 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "gdb_ptrace.h"
35 #include "inf-ptrace.h"
36 #include "inf-child.h"
37 #include "gdbthread.h"
41 #ifdef PT_GET_PROCESS_STATE
44 inf_ptrace_follow_fork (struct target_ops
*ops
, int follow_child
)
48 struct thread_info
*last_tp
= NULL
;
50 /* FIXME: kettenis/20050720: This stuff should really be passed as
51 an argument by our caller. */
54 struct target_waitstatus status
;
56 get_last_target_status (&ptid
, &status
);
57 gdb_assert (status
.kind
== TARGET_WAITKIND_FORKED
);
59 pid
= ptid_get_pid (ptid
);
60 last_tp
= find_thread_pid (ptid
);
63 if (ptrace (PT_GET_PROCESS_STATE
, pid
,
64 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
65 perror_with_name (("ptrace"));
67 gdb_assert (pe
.pe_report_event
== PTRACE_FORK
);
68 fpid
= pe
.pe_other_pid
;
72 /* Copy user stepping state to the new inferior thread. */
73 struct breakpoint
*step_resume_breakpoint
= last_tp
->step_resume_breakpoint
;
74 CORE_ADDR step_range_start
= last_tp
->step_range_start
;
75 CORE_ADDR step_range_end
= last_tp
->step_range_end
;
76 struct frame_id step_frame_id
= last_tp
->step_frame_id
;
77 int attach_flag
= find_inferior_pid (pid
)->attach_flag
;
79 struct thread_info
*tp
;
81 /* Otherwise, deleting the parent would get rid of this
83 last_tp
->step_resume_breakpoint
= NULL
;
85 /* Before detaching from the parent, remove all breakpoints from
87 remove_breakpoints ();
89 if (ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
90 perror_with_name (("ptrace"));
92 /* Switch inferior_ptid out of the parent's way. */
93 inferior_ptid
= pid_to_ptid (fpid
);
95 /* Delete the parent. */
96 detach_inferior (pid
);
99 inf
= add_inferior (fpid
);
100 inf
->attach_flag
= attach_flag
;
101 tp
= add_thread_silent (inferior_ptid
);
103 tp
->step_resume_breakpoint
= step_resume_breakpoint
;
104 tp
->step_range_start
= step_range_start
;
105 tp
->step_range_end
= step_range_end
;
106 tp
->step_frame_id
= step_frame_id
;
108 /* Reset breakpoints in the child as appropriate. */
109 follow_inferior_reset_breakpoints ();
113 inferior_ptid
= pid_to_ptid (pid
);
115 /* Breakpoints have already been detached from the child by
118 if (ptrace (PT_DETACH
, fpid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
119 perror_with_name (("ptrace"));
120 detach_inferior (pid
);
126 #endif /* PT_GET_PROCESS_STATE */
129 /* Prepare to be traced. */
134 /* "Trace me, Dr. Memory!" */
135 ptrace (PT_TRACE_ME
, 0, (PTRACE_TYPE_ARG3
)0, 0);
138 /* Start a new inferior Unix child process. EXEC_FILE is the file to
139 run, ALLARGS is a string containing the arguments to the program.
140 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
144 inf_ptrace_create_inferior (struct target_ops
*ops
,
145 char *exec_file
, char *allargs
, char **env
,
150 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ptrace_me
, NULL
,
155 /* On some targets, there must be some explicit synchronization
156 between the parent and child processes after the debugger
157 forks, and before the child execs the debuggee program. This
158 call basically gives permission for the child to exec. */
160 target_acknowledge_created_inferior (pid
);
162 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
163 be 1 or 2 depending on whether we're starting without or with a
165 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
167 /* On some targets, there must be some explicit actions taken after
168 the inferior has been started up. */
169 target_post_startup_inferior (pid_to_ptid (pid
));
172 #ifdef PT_GET_PROCESS_STATE
175 inf_ptrace_post_startup_inferior (ptid_t pid
)
179 /* Set the initial event mask. */
180 memset (&pe
, 0, sizeof pe
);
181 pe
.pe_set_event
|= PTRACE_FORK
;
182 if (ptrace (PT_SET_EVENT_MASK
, ptid_get_pid (pid
),
183 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
184 perror_with_name (("ptrace"));
189 /* Clean up a rotting corpse of an inferior after it died. */
192 inf_ptrace_mourn_inferior (struct target_ops
*ops
)
196 /* Wait just one more time to collect the inferior's exit status.
197 Do not check whether this succeeds though, since we may be
198 dealing with a process that we attached to. Such a process will
199 only report its exit status to its original parent. */
200 waitpid (ptid_get_pid (inferior_ptid
), &status
, 0);
203 generic_mourn_inferior ();
206 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
207 be chatty about it. */
210 inf_ptrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
215 struct inferior
*inf
;
218 error_no_arg (_("process-id to attach"));
221 pid
= strtol (args
, &dummy
, 0);
222 /* Some targets don't set errno on errors, grrr! */
223 if (pid
== 0 && args
== dummy
)
224 error (_("Illegal process-id: %s."), args
);
226 if (pid
== getpid ()) /* Trying to masturbate? */
227 error (_("I refuse to debug myself!"));
231 exec_file
= get_exec_file (0);
234 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
235 target_pid_to_str (pid_to_ptid (pid
)));
237 printf_unfiltered (_("Attaching to %s\n"),
238 target_pid_to_str (pid_to_ptid (pid
)));
240 gdb_flush (gdb_stdout
);
245 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
247 perror_with_name (("ptrace"));
249 error (_("This system does not support attaching to a process"));
252 inferior_ptid
= pid_to_ptid (pid
);
254 inf
= add_inferior (pid
);
255 inf
->attach_flag
= 1;
257 /* Always add a main thread. If some target extends the ptrace
258 target, it should decorate the ptid later with more info. */
259 add_thread_silent (inferior_ptid
);
264 #ifdef PT_GET_PROCESS_STATE
267 inf_ptrace_post_attach (int pid
)
271 /* Set the initial event mask. */
272 memset (&pe
, 0, sizeof pe
);
273 pe
.pe_set_event
|= PTRACE_FORK
;
274 if (ptrace (PT_SET_EVENT_MASK
, pid
,
275 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
276 perror_with_name (("ptrace"));
281 /* Detach from the inferior, optionally passing it the signal
282 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
285 inf_ptrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
287 pid_t pid
= ptid_get_pid (inferior_ptid
);
292 char *exec_file
= get_exec_file (0);
295 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
296 target_pid_to_str (pid_to_ptid (pid
)));
297 gdb_flush (gdb_stdout
);
303 /* We'd better not have left any breakpoints in the program or it'll
304 die when it hits one. Also note that this may only work if we
305 previously attached to the inferior. It *might* work if we
306 started the process ourselves. */
308 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, sig
);
310 perror_with_name (("ptrace"));
312 error (_("This system does not support detaching from a process"));
315 inferior_ptid
= null_ptid
;
316 detach_inferior (pid
);
318 if (!have_inferiors ())
322 /* Kill the inferior. */
325 inf_ptrace_kill (struct target_ops
*ops
)
327 pid_t pid
= ptid_get_pid (inferior_ptid
);
333 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
334 waitpid (pid
, &status
, 0);
336 target_mourn_inferior ();
339 /* Stop the inferior. */
342 inf_ptrace_stop (ptid_t ptid
)
344 /* Send a SIGINT to the process group. This acts just like the user
345 typed a ^C on the controlling terminal. Note that using a
346 negative process number in kill() is a System V-ism. The proper
347 BSD interface is killpg(). However, all modern BSDs support the
348 System V interface too. */
349 kill (-inferior_process_group
, SIGINT
);
352 /* Resume execution of thread PTID, or all threads if PTID is -1. If
353 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
357 inf_ptrace_resume (struct target_ops
*ops
,
358 ptid_t ptid
, int step
, enum target_signal signal
)
360 pid_t pid
= ptid_get_pid (ptid
);
361 int request
= PT_CONTINUE
;
364 /* Resume all threads. Traditionally ptrace() only supports
365 single-threaded processes, so simply resume the inferior. */
366 pid
= ptid_get_pid (inferior_ptid
);
370 /* If this system does not support PT_STEP, a higher level
371 function will have called single_step() to transmute the step
372 request into a continue request (by setting breakpoints on
373 all possible successor instructions), so we don't have to
374 worry about that here. */
378 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
379 where it was. If GDB wanted it to start some other way, we have
380 already written a new program counter value to the child. */
382 ptrace (request
, pid
, (PTRACE_TYPE_ARG3
)1, target_signal_to_host (signal
));
384 perror_with_name (("ptrace"));
387 /* Wait for the child specified by PTID to do something. Return the
388 process ID of the child, or MINUS_ONE_PTID in case of error; store
389 the status in *OURSTATUS. */
392 inf_ptrace_wait (struct target_ops
*ops
,
393 ptid_t ptid
, struct target_waitstatus
*ourstatus
)
396 int status
, save_errno
;
404 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
407 while (pid
== -1 && errno
== EINTR
);
409 clear_sigint_trap ();
413 fprintf_unfiltered (gdb_stderr
,
414 _("Child process unexpectedly missing: %s.\n"),
415 safe_strerror (save_errno
));
417 /* Claim it exited with unknown signal. */
418 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
419 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
420 return inferior_ptid
;
423 /* Ignore terminated detached child processes. */
424 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
429 #ifdef PT_GET_PROCESS_STATE
430 if (WIFSTOPPED (status
))
435 if (ptrace (PT_GET_PROCESS_STATE
, pid
,
436 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
437 perror_with_name (("ptrace"));
439 switch (pe
.pe_report_event
)
442 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
443 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
445 /* Make sure the other end of the fork is stopped too. */
446 fpid
= waitpid (pe
.pe_other_pid
, &status
, 0);
448 perror_with_name (("waitpid"));
450 if (ptrace (PT_GET_PROCESS_STATE
, fpid
,
451 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
452 perror_with_name (("ptrace"));
454 gdb_assert (pe
.pe_report_event
== PTRACE_FORK
);
455 gdb_assert (pe
.pe_other_pid
== pid
);
456 if (fpid
== ptid_get_pid (inferior_ptid
))
458 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
459 return pid_to_ptid (fpid
);
462 return pid_to_ptid (pid
);
467 store_waitstatus (ourstatus
, status
);
468 return pid_to_ptid (pid
);
471 /* Attempt a transfer all LEN bytes starting at OFFSET between the
472 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
473 Return the number of bytes actually transferred. */
476 inf_ptrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
477 const char *annex
, gdb_byte
*readbuf
,
478 const gdb_byte
*writebuf
,
479 ULONGEST offset
, LONGEST len
)
481 pid_t pid
= ptid_get_pid (inferior_ptid
);
485 case TARGET_OBJECT_MEMORY
:
487 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
488 request that promises to be much more efficient in reading
489 and writing data in the traced process's address space. */
491 struct ptrace_io_desc piod
;
493 /* NOTE: We assume that there are no distinct address spaces
494 for instruction and data. However, on OpenBSD 3.9 and
495 later, PIOD_WRITE_D doesn't allow changing memory that's
496 mapped read-only. Since most code segments will be
497 read-only, using PIOD_WRITE_D will prevent us from
498 inserting breakpoints, so we use PIOD_WRITE_I instead. */
499 piod
.piod_op
= writebuf
? PIOD_WRITE_I
: PIOD_READ_D
;
500 piod
.piod_addr
= writebuf
? (void *) writebuf
: readbuf
;
501 piod
.piod_offs
= (void *) (long) offset
;
505 if (ptrace (PT_IO
, pid
, (caddr_t
)&piod
, 0) == 0)
506 /* Return the actual number of bytes read or written. */
507 return piod
.piod_len
;
508 /* If the PT_IO request is somehow not supported, fallback on
509 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
510 to indicate failure. */
518 PTRACE_TYPE_RET word
;
519 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
521 ULONGEST rounded_offset
;
524 /* Round the start offset down to the next long word
526 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
528 /* Since ptrace will transfer a single word starting at that
529 rounded_offset the partial_len needs to be adjusted down to
530 that (remember this function only does a single transfer).
531 Should the required length be even less, adjust it down
533 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
534 if (partial_len
> len
)
539 /* If OFFSET:PARTIAL_LEN is smaller than
540 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
541 be needed. Read in the entire word. */
542 if (rounded_offset
< offset
543 || (offset
+ partial_len
544 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
545 /* Need part of initial word -- fetch it. */
546 buffer
.word
= ptrace (PT_READ_I
, pid
,
547 (PTRACE_TYPE_ARG3
)(uintptr_t)
550 /* Copy data to be written over corresponding part of
552 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
553 writebuf
, partial_len
);
556 ptrace (PT_WRITE_D
, pid
,
557 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
561 /* Using the appropriate one (I or D) is necessary for
562 Gould NP1, at least. */
564 ptrace (PT_WRITE_I
, pid
,
565 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
575 buffer
.word
= ptrace (PT_READ_I
, pid
,
576 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
580 /* Copy appropriate bytes out of the buffer. */
581 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
588 case TARGET_OBJECT_UNWIND_TABLE
:
591 case TARGET_OBJECT_AUXV
:
594 case TARGET_OBJECT_WCOOKIE
:
602 /* Return non-zero if the thread specified by PTID is alive. */
605 inf_ptrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
607 /* ??? Is kill the right way to do this? */
608 return (kill (ptid_get_pid (ptid
), 0) != -1);
611 /* Print status information about what we're accessing. */
614 inf_ptrace_files_info (struct target_ops
*ignore
)
616 struct inferior
*inf
= current_inferior ();
618 printf_filtered (_("\tUsing the running image of %s %s.\n"),
619 inf
->attach_flag
? "attached" : "child",
620 target_pid_to_str (inferior_ptid
));
624 inf_ptrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
626 return normal_pid_to_str (ptid
);
629 /* Create a prototype ptrace target. The client can override it with
633 inf_ptrace_target (void)
635 struct target_ops
*t
= inf_child_target ();
637 t
->to_attach
= inf_ptrace_attach
;
638 t
->to_detach
= inf_ptrace_detach
;
639 t
->to_resume
= inf_ptrace_resume
;
640 t
->to_wait
= inf_ptrace_wait
;
641 t
->to_files_info
= inf_ptrace_files_info
;
642 t
->to_kill
= inf_ptrace_kill
;
643 t
->to_create_inferior
= inf_ptrace_create_inferior
;
644 #ifdef PT_GET_PROCESS_STATE
645 t
->to_follow_fork
= inf_ptrace_follow_fork
;
646 t
->to_post_startup_inferior
= inf_ptrace_post_startup_inferior
;
647 t
->to_post_attach
= inf_ptrace_post_attach
;
649 t
->to_mourn_inferior
= inf_ptrace_mourn_inferior
;
650 t
->to_thread_alive
= inf_ptrace_thread_alive
;
651 t
->to_pid_to_str
= inf_ptrace_pid_to_str
;
652 t
->to_stop
= inf_ptrace_stop
;
653 t
->to_xfer_partial
= inf_ptrace_xfer_partial
;
659 /* Pointer to a function that returns the offset within the user area
660 where a particular register is stored. */
661 static CORE_ADDR (*inf_ptrace_register_u_offset
)(struct gdbarch
*, int, int);
663 /* Fetch register REGNUM from the inferior. */
666 inf_ptrace_fetch_register (struct regcache
*regcache
, int regnum
)
668 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
671 PTRACE_TYPE_RET
*buf
;
674 /* This isn't really an address, but ptrace thinks of it as one. */
675 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 0);
676 if (addr
== (CORE_ADDR
)-1
677 || gdbarch_cannot_fetch_register (gdbarch
, regnum
))
679 regcache_raw_supply (regcache
, regnum
, NULL
);
683 /* Cater for systems like GNU/Linux, that implement threads as
684 separate processes. */
685 pid
= ptid_get_lwp (inferior_ptid
);
687 pid
= ptid_get_pid (inferior_ptid
);
689 size
= register_size (gdbarch
, regnum
);
690 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
693 /* Read the register contents from the inferior a chunk at a time. */
694 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
697 buf
[i
] = ptrace (PT_READ_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, 0);
699 error (_("Couldn't read register %s (#%d): %s."),
700 gdbarch_register_name (gdbarch
, regnum
),
701 regnum
, safe_strerror (errno
));
703 addr
+= sizeof (PTRACE_TYPE_RET
);
705 regcache_raw_supply (regcache
, regnum
, buf
);
708 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
709 for all registers. */
712 inf_ptrace_fetch_registers (struct target_ops
*ops
,
713 struct regcache
*regcache
, int regnum
)
717 regnum
< gdbarch_num_regs (get_regcache_arch (regcache
));
719 inf_ptrace_fetch_register (regcache
, regnum
);
721 inf_ptrace_fetch_register (regcache
, regnum
);
724 /* Store register REGNUM into the inferior. */
727 inf_ptrace_store_register (const struct regcache
*regcache
, int regnum
)
729 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
732 PTRACE_TYPE_RET
*buf
;
735 /* This isn't really an address, but ptrace thinks of it as one. */
736 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 1);
737 if (addr
== (CORE_ADDR
)-1
738 || gdbarch_cannot_store_register (gdbarch
, regnum
))
741 /* Cater for systems like GNU/Linux, that implement threads as
742 separate processes. */
743 pid
= ptid_get_lwp (inferior_ptid
);
745 pid
= ptid_get_pid (inferior_ptid
);
747 size
= register_size (gdbarch
, regnum
);
748 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
751 /* Write the register contents into the inferior a chunk at a time. */
752 regcache_raw_collect (regcache
, regnum
, buf
);
753 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
756 ptrace (PT_WRITE_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, buf
[i
]);
758 error (_("Couldn't write register %s (#%d): %s."),
759 gdbarch_register_name (gdbarch
, regnum
),
760 regnum
, safe_strerror (errno
));
762 addr
+= sizeof (PTRACE_TYPE_RET
);
766 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
767 this for all registers. */
770 inf_ptrace_store_registers (struct target_ops
*ops
,
771 struct regcache
*regcache
, int regnum
)
775 regnum
< gdbarch_num_regs (get_regcache_arch (regcache
));
777 inf_ptrace_store_register (regcache
, regnum
);
779 inf_ptrace_store_register (regcache
, regnum
);
782 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
783 a function returning the offset within the user area where a
784 particular register is stored. */
787 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset
)
788 (struct gdbarch
*, int, int))
790 struct target_ops
*t
= inf_ptrace_target();
792 gdb_assert (register_u_offset
);
793 inf_ptrace_register_u_offset
= register_u_offset
;
794 t
->to_fetch_registers
= inf_ptrace_fetch_registers
;
795 t
->to_store_registers
= inf_ptrace_store_registers
;