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
);
114 detach_breakpoints (fpid
);
116 if (ptrace (PT_DETACH
, fpid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
117 perror_with_name (("ptrace"));
118 detach_inferior (pid
);
124 #endif /* PT_GET_PROCESS_STATE */
127 /* Prepare to be traced. */
132 /* "Trace me, Dr. Memory!" */
133 ptrace (PT_TRACE_ME
, 0, (PTRACE_TYPE_ARG3
)0, 0);
136 /* Start a new inferior Unix child process. EXEC_FILE is the file to
137 run, ALLARGS is a string containing the arguments to the program.
138 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
142 inf_ptrace_create_inferior (struct target_ops
*ops
,
143 char *exec_file
, char *allargs
, char **env
,
148 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ptrace_me
, NULL
,
153 /* On some targets, there must be some explicit synchronization
154 between the parent and child processes after the debugger
155 forks, and before the child execs the debuggee program. This
156 call basically gives permission for the child to exec. */
158 target_acknowledge_created_inferior (pid
);
160 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
161 be 1 or 2 depending on whether we're starting without or with a
163 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
165 /* On some targets, there must be some explicit actions taken after
166 the inferior has been started up. */
167 target_post_startup_inferior (pid_to_ptid (pid
));
170 #ifdef PT_GET_PROCESS_STATE
173 inf_ptrace_post_startup_inferior (ptid_t pid
)
177 /* Set the initial event mask. */
178 memset (&pe
, 0, sizeof pe
);
179 pe
.pe_set_event
|= PTRACE_FORK
;
180 if (ptrace (PT_SET_EVENT_MASK
, ptid_get_pid (pid
),
181 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
182 perror_with_name (("ptrace"));
187 /* Clean up a rotting corpse of an inferior after it died. */
190 inf_ptrace_mourn_inferior (struct target_ops
*ops
)
194 /* Wait just one more time to collect the inferior's exit status.
195 Do not check whether this succeeds though, since we may be
196 dealing with a process that we attached to. Such a process will
197 only report its exit status to its original parent. */
198 waitpid (ptid_get_pid (inferior_ptid
), &status
, 0);
201 generic_mourn_inferior ();
204 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
205 be chatty about it. */
208 inf_ptrace_attach (struct target_ops
*ops
, char *args
, int from_tty
)
213 struct inferior
*inf
;
216 error_no_arg (_("process-id to attach"));
219 pid
= strtol (args
, &dummy
, 0);
220 /* Some targets don't set errno on errors, grrr! */
221 if (pid
== 0 && args
== dummy
)
222 error (_("Illegal process-id: %s."), args
);
224 if (pid
== getpid ()) /* Trying to masturbate? */
225 error (_("I refuse to debug myself!"));
229 exec_file
= get_exec_file (0);
232 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
233 target_pid_to_str (pid_to_ptid (pid
)));
235 printf_unfiltered (_("Attaching to %s\n"),
236 target_pid_to_str (pid_to_ptid (pid
)));
238 gdb_flush (gdb_stdout
);
243 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
245 perror_with_name (("ptrace"));
247 error (_("This system does not support attaching to a process"));
250 inferior_ptid
= pid_to_ptid (pid
);
252 inf
= add_inferior (pid
);
253 inf
->attach_flag
= 1;
255 /* Always add a main thread. If some target extends the ptrace
256 target, it should decorate the ptid later with more info. */
257 add_thread_silent (inferior_ptid
);
262 #ifdef PT_GET_PROCESS_STATE
265 inf_ptrace_post_attach (int pid
)
269 /* Set the initial event mask. */
270 memset (&pe
, 0, sizeof pe
);
271 pe
.pe_set_event
|= PTRACE_FORK
;
272 if (ptrace (PT_SET_EVENT_MASK
, pid
,
273 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
274 perror_with_name (("ptrace"));
279 /* Detach from the inferior, optionally passing it the signal
280 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
283 inf_ptrace_detach (struct target_ops
*ops
, char *args
, int from_tty
)
285 pid_t pid
= ptid_get_pid (inferior_ptid
);
290 char *exec_file
= get_exec_file (0);
293 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
294 target_pid_to_str (pid_to_ptid (pid
)));
295 gdb_flush (gdb_stdout
);
301 /* We'd better not have left any breakpoints in the program or it'll
302 die when it hits one. Also note that this may only work if we
303 previously attached to the inferior. It *might* work if we
304 started the process ourselves. */
306 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, sig
);
308 perror_with_name (("ptrace"));
310 error (_("This system does not support detaching from a process"));
313 inferior_ptid
= null_ptid
;
314 detach_inferior (pid
);
316 if (!have_inferiors ())
320 /* Kill the inferior. */
323 inf_ptrace_kill (void)
325 pid_t pid
= ptid_get_pid (inferior_ptid
);
331 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
332 waitpid (pid
, &status
, 0);
334 target_mourn_inferior ();
337 /* Stop the inferior. */
340 inf_ptrace_stop (ptid_t ptid
)
342 /* Send a SIGINT to the process group. This acts just like the user
343 typed a ^C on the controlling terminal. Note that using a
344 negative process number in kill() is a System V-ism. The proper
345 BSD interface is killpg(). However, all modern BSDs support the
346 System V interface too. */
347 kill (-inferior_process_group
, SIGINT
);
350 /* Resume execution of thread PTID, or all threads if PTID is -1. If
351 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
355 inf_ptrace_resume (ptid_t ptid
, int step
, enum target_signal signal
)
357 pid_t pid
= ptid_get_pid (ptid
);
358 int request
= PT_CONTINUE
;
361 /* Resume all threads. Traditionally ptrace() only supports
362 single-threaded processes, so simply resume the inferior. */
363 pid
= ptid_get_pid (inferior_ptid
);
367 /* If this system does not support PT_STEP, a higher level
368 function will have called single_step() to transmute the step
369 request into a continue request (by setting breakpoints on
370 all possible successor instructions), so we don't have to
371 worry about that here. */
375 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
376 where it was. If GDB wanted it to start some other way, we have
377 already written a new program counter value to the child. */
379 ptrace (request
, pid
, (PTRACE_TYPE_ARG3
)1, target_signal_to_host (signal
));
381 perror_with_name (("ptrace"));
384 /* Wait for the child specified by PTID to do something. Return the
385 process ID of the child, or MINUS_ONE_PTID in case of error; store
386 the status in *OURSTATUS. */
389 inf_ptrace_wait (struct target_ops
*ops
,
390 ptid_t ptid
, struct target_waitstatus
*ourstatus
)
393 int status
, save_errno
;
401 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
404 while (pid
== -1 && errno
== EINTR
);
406 clear_sigint_trap ();
410 fprintf_unfiltered (gdb_stderr
,
411 _("Child process unexpectedly missing: %s.\n"),
412 safe_strerror (save_errno
));
414 /* Claim it exited with unknown signal. */
415 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
416 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
417 return inferior_ptid
;
420 /* Ignore terminated detached child processes. */
421 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
426 #ifdef PT_GET_PROCESS_STATE
427 if (WIFSTOPPED (status
))
432 if (ptrace (PT_GET_PROCESS_STATE
, pid
,
433 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
434 perror_with_name (("ptrace"));
436 switch (pe
.pe_report_event
)
439 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
440 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
442 /* Make sure the other end of the fork is stopped too. */
443 fpid
= waitpid (pe
.pe_other_pid
, &status
, 0);
445 perror_with_name (("waitpid"));
447 if (ptrace (PT_GET_PROCESS_STATE
, fpid
,
448 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
449 perror_with_name (("ptrace"));
451 gdb_assert (pe
.pe_report_event
== PTRACE_FORK
);
452 gdb_assert (pe
.pe_other_pid
== pid
);
453 if (fpid
== ptid_get_pid (inferior_ptid
))
455 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
456 return pid_to_ptid (fpid
);
459 return pid_to_ptid (pid
);
464 store_waitstatus (ourstatus
, status
);
465 return pid_to_ptid (pid
);
468 /* Attempt a transfer all LEN bytes starting at OFFSET between the
469 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
470 Return the number of bytes actually transferred. */
473 inf_ptrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
474 const char *annex
, gdb_byte
*readbuf
,
475 const gdb_byte
*writebuf
,
476 ULONGEST offset
, LONGEST len
)
478 pid_t pid
= ptid_get_pid (inferior_ptid
);
482 case TARGET_OBJECT_MEMORY
:
484 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
485 request that promises to be much more efficient in reading
486 and writing data in the traced process's address space. */
488 struct ptrace_io_desc piod
;
490 /* NOTE: We assume that there are no distinct address spaces
491 for instruction and data. However, on OpenBSD 3.9 and
492 later, PIOD_WRITE_D doesn't allow changing memory that's
493 mapped read-only. Since most code segments will be
494 read-only, using PIOD_WRITE_D will prevent us from
495 inserting breakpoints, so we use PIOD_WRITE_I instead. */
496 piod
.piod_op
= writebuf
? PIOD_WRITE_I
: PIOD_READ_D
;
497 piod
.piod_addr
= writebuf
? (void *) writebuf
: readbuf
;
498 piod
.piod_offs
= (void *) (long) offset
;
502 if (ptrace (PT_IO
, pid
, (caddr_t
)&piod
, 0) == 0)
503 /* Return the actual number of bytes read or written. */
504 return piod
.piod_len
;
505 /* If the PT_IO request is somehow not supported, fallback on
506 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
507 to indicate failure. */
515 PTRACE_TYPE_RET word
;
516 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
518 ULONGEST rounded_offset
;
521 /* Round the start offset down to the next long word
523 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
525 /* Since ptrace will transfer a single word starting at that
526 rounded_offset the partial_len needs to be adjusted down to
527 that (remember this function only does a single transfer).
528 Should the required length be even less, adjust it down
530 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
531 if (partial_len
> len
)
536 /* If OFFSET:PARTIAL_LEN is smaller than
537 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
538 be needed. Read in the entire word. */
539 if (rounded_offset
< offset
540 || (offset
+ partial_len
541 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
542 /* Need part of initial word -- fetch it. */
543 buffer
.word
= ptrace (PT_READ_I
, pid
,
544 (PTRACE_TYPE_ARG3
)(uintptr_t)
547 /* Copy data to be written over corresponding part of
549 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
550 writebuf
, partial_len
);
553 ptrace (PT_WRITE_D
, pid
,
554 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
558 /* Using the appropriate one (I or D) is necessary for
559 Gould NP1, at least. */
561 ptrace (PT_WRITE_I
, pid
,
562 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
572 buffer
.word
= ptrace (PT_READ_I
, pid
,
573 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
577 /* Copy appropriate bytes out of the buffer. */
578 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
585 case TARGET_OBJECT_UNWIND_TABLE
:
588 case TARGET_OBJECT_AUXV
:
591 case TARGET_OBJECT_WCOOKIE
:
599 /* Return non-zero if the thread specified by PTID is alive. */
602 inf_ptrace_thread_alive (ptid_t ptid
)
604 /* ??? Is kill the right way to do this? */
605 return (kill (ptid_get_pid (ptid
), 0) != -1);
608 /* Print status information about what we're accessing. */
611 inf_ptrace_files_info (struct target_ops
*ignore
)
613 struct inferior
*inf
= current_inferior ();
615 printf_filtered (_("\tUsing the running image of %s %s.\n"),
616 inf
->attach_flag
? "attached" : "child",
617 target_pid_to_str (inferior_ptid
));
621 inf_ptrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
623 return normal_pid_to_str (ptid
);
626 /* Create a prototype ptrace target. The client can override it with
630 inf_ptrace_target (void)
632 struct target_ops
*t
= inf_child_target ();
634 t
->to_attach
= inf_ptrace_attach
;
635 t
->to_detach
= inf_ptrace_detach
;
636 t
->to_resume
= inf_ptrace_resume
;
637 t
->to_wait
= inf_ptrace_wait
;
638 t
->to_files_info
= inf_ptrace_files_info
;
639 t
->to_kill
= inf_ptrace_kill
;
640 t
->to_create_inferior
= inf_ptrace_create_inferior
;
641 #ifdef PT_GET_PROCESS_STATE
642 t
->to_follow_fork
= inf_ptrace_follow_fork
;
643 t
->to_post_startup_inferior
= inf_ptrace_post_startup_inferior
;
644 t
->to_post_attach
= inf_ptrace_post_attach
;
646 t
->to_mourn_inferior
= inf_ptrace_mourn_inferior
;
647 t
->to_thread_alive
= inf_ptrace_thread_alive
;
648 t
->to_pid_to_str
= inf_ptrace_pid_to_str
;
649 t
->to_stop
= inf_ptrace_stop
;
650 t
->to_xfer_partial
= inf_ptrace_xfer_partial
;
656 /* Pointer to a function that returns the offset within the user area
657 where a particular register is stored. */
658 static CORE_ADDR (*inf_ptrace_register_u_offset
)(struct gdbarch
*, int, int);
660 /* Fetch register REGNUM from the inferior. */
663 inf_ptrace_fetch_register (struct regcache
*regcache
, int regnum
)
665 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
668 PTRACE_TYPE_RET
*buf
;
671 /* This isn't really an address, but ptrace thinks of it as one. */
672 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 0);
673 if (addr
== (CORE_ADDR
)-1
674 || gdbarch_cannot_fetch_register (gdbarch
, regnum
))
676 regcache_raw_supply (regcache
, regnum
, NULL
);
680 /* Cater for systems like GNU/Linux, that implement threads as
681 separate processes. */
682 pid
= ptid_get_lwp (inferior_ptid
);
684 pid
= ptid_get_pid (inferior_ptid
);
686 size
= register_size (gdbarch
, regnum
);
687 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
690 /* Read the register contents from the inferior a chunk at a time. */
691 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
694 buf
[i
] = ptrace (PT_READ_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, 0);
696 error (_("Couldn't read register %s (#%d): %s."),
697 gdbarch_register_name (gdbarch
, regnum
),
698 regnum
, safe_strerror (errno
));
700 addr
+= sizeof (PTRACE_TYPE_RET
);
702 regcache_raw_supply (regcache
, regnum
, buf
);
705 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
706 for all registers. */
709 inf_ptrace_fetch_registers (struct regcache
*regcache
, int regnum
)
713 regnum
< gdbarch_num_regs (get_regcache_arch (regcache
));
715 inf_ptrace_fetch_register (regcache
, regnum
);
717 inf_ptrace_fetch_register (regcache
, regnum
);
720 /* Store register REGNUM into the inferior. */
723 inf_ptrace_store_register (const struct regcache
*regcache
, int regnum
)
725 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
728 PTRACE_TYPE_RET
*buf
;
731 /* This isn't really an address, but ptrace thinks of it as one. */
732 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 1);
733 if (addr
== (CORE_ADDR
)-1
734 || gdbarch_cannot_store_register (gdbarch
, regnum
))
737 /* Cater for systems like GNU/Linux, that implement threads as
738 separate processes. */
739 pid
= ptid_get_lwp (inferior_ptid
);
741 pid
= ptid_get_pid (inferior_ptid
);
743 size
= register_size (gdbarch
, regnum
);
744 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
747 /* Write the register contents into the inferior a chunk at a time. */
748 regcache_raw_collect (regcache
, regnum
, buf
);
749 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
752 ptrace (PT_WRITE_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, buf
[i
]);
754 error (_("Couldn't write register %s (#%d): %s."),
755 gdbarch_register_name (gdbarch
, regnum
),
756 regnum
, safe_strerror (errno
));
758 addr
+= sizeof (PTRACE_TYPE_RET
);
762 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
763 this for all registers. */
766 inf_ptrace_store_registers (struct regcache
*regcache
, int regnum
)
770 regnum
< gdbarch_num_regs (get_regcache_arch (regcache
));
772 inf_ptrace_store_register (regcache
, regnum
);
774 inf_ptrace_store_register (regcache
, regnum
);
777 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
778 a function returning the offset within the user area where a
779 particular register is stored. */
782 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset
)
783 (struct gdbarch
*, int, int))
785 struct target_ops
*t
= inf_ptrace_target();
787 gdb_assert (register_u_offset
);
788 inf_ptrace_register_u_offset
= register_u_offset
;
789 t
->to_fetch_registers
= inf_ptrace_fetch_registers
;
790 t
->to_store_registers
= inf_ptrace_store_registers
;