1 /* Low-level child interface to ptrace.
3 Copyright (C) 1988-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "nat/gdb_ptrace.h"
28 #include "gdbsupport/gdb_wait.h"
31 #include "inf-ptrace.h"
32 #include "inf-child.h"
33 #include "gdbthread.h"
34 #include "nat/fork-inferior.h"
40 static PTRACE_TYPE_RET
41 gdb_ptrace (PTRACE_TYPE_ARG1 request
, ptid_t ptid
, PTRACE_TYPE_ARG3 addr
,
42 PTRACE_TYPE_ARG4 data
)
45 return ptrace (request
, ptid
.pid (), addr
, data
);
47 pid_t pid
= get_ptrace_pid (ptid
);
48 return ptrace (request
, pid
, addr
, data
);
52 /* A unique_ptr helper to unpush a target. */
54 struct target_unpusher
56 void operator() (struct target_ops
*ops
) const
62 /* A unique_ptr that unpushes a target on destruction. */
64 typedef std::unique_ptr
<struct target_ops
, target_unpusher
> target_unpush_up
;
68 inf_ptrace_target::~inf_ptrace_target ()
71 #ifdef PT_GET_PROCESS_STATE
73 /* Target hook for follow_fork. On entry and at return inferior_ptid is
74 the ptid of the followed inferior. */
77 inf_ptrace_target::follow_fork (int follow_child
, int detach_fork
)
81 struct thread_info
*tp
= inferior_thread ();
82 pid_t child_pid
= tp
->pending_follow
.value
.related_pid
.pid ();
84 /* Breakpoints have already been detached from the child by
87 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
88 perror_with_name (("ptrace"));
95 inf_ptrace_target::insert_fork_catchpoint (int pid
)
101 inf_ptrace_target::remove_fork_catchpoint (int pid
)
106 #endif /* PT_GET_PROCESS_STATE */
109 /* Prepare to be traced. */
114 /* "Trace me, Dr. Memory!" */
115 if (ptrace (PT_TRACE_ME
, 0, (PTRACE_TYPE_ARG3
) 0, 0) < 0)
116 trace_start_error_with_name ("ptrace");
119 /* Start a new inferior Unix child process. EXEC_FILE is the file to
120 run, ALLARGS is a string containing the arguments to the program.
121 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
125 inf_ptrace_target::create_inferior (const char *exec_file
,
126 const std::string
&allargs
,
127 char **env
, int from_tty
)
132 /* Do not change either targets above or the same target if already present.
133 The reason is the target stack is shared across multiple inferiors. */
134 int ops_already_pushed
= target_is_pushed (this);
136 target_unpush_up unpusher
;
137 if (! ops_already_pushed
)
139 /* Clear possible core file with its process_stratum. */
141 unpusher
.reset (this);
144 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ptrace_me
, NULL
,
148 /* We have something that executes now. We'll be running through
149 the shell at this point (if startup-with-shell is true), but the
150 pid shouldn't change. */
151 add_thread_silent (this, ptid
);
155 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
157 /* On some targets, there must be some explicit actions taken after
158 the inferior has been started up. */
159 target_post_startup_inferior (ptid
);
162 #ifdef PT_GET_PROCESS_STATE
165 inf_ptrace_target::post_startup_inferior (ptid_t pid
)
169 /* Set the initial event mask. */
170 memset (&pe
, 0, sizeof pe
);
171 pe
.pe_set_event
|= PTRACE_FORK
;
172 if (ptrace (PT_SET_EVENT_MASK
, pid
.pid (),
173 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
174 perror_with_name (("ptrace"));
179 /* Clean up a rotting corpse of an inferior after it died. */
182 inf_ptrace_target::mourn_inferior ()
186 /* Wait just one more time to collect the inferior's exit status.
187 Do not check whether this succeeds though, since we may be
188 dealing with a process that we attached to. Such a process will
189 only report its exit status to its original parent. */
190 waitpid (inferior_ptid
.pid (), &status
, 0);
192 inf_child_target::mourn_inferior ();
195 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
196 be chatty about it. */
199 inf_ptrace_target::attach (const char *args
, int from_tty
)
202 struct inferior
*inf
;
204 /* Do not change either targets above or the same target if already present.
205 The reason is the target stack is shared across multiple inferiors. */
206 int ops_already_pushed
= target_is_pushed (this);
208 pid
= parse_pid_to_attach (args
);
210 if (pid
== getpid ()) /* Trying to masturbate? */
211 error (_("I refuse to debug myself!"));
213 target_unpush_up unpusher
;
214 if (! ops_already_pushed
)
216 /* target_pid_to_str already uses the target. Also clear possible core
217 file with its process_stratum. */
219 unpusher
.reset (this);
224 const char *exec_file
= get_exec_file (0);
227 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
228 target_pid_to_str (ptid_t (pid
)).c_str ());
230 printf_unfiltered (_("Attaching to %s\n"),
231 target_pid_to_str (ptid_t (pid
)).c_str ());
236 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
238 perror_with_name (("ptrace"));
240 error (_("This system does not support attaching to a process"));
243 inf
= current_inferior ();
244 inferior_appeared (inf
, pid
);
245 inf
->attach_flag
= 1;
246 inferior_ptid
= ptid_t (pid
);
248 /* Always add a main thread. If some target extends the ptrace
249 target, it should decorate the ptid later with more info. */
250 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
251 /* Don't consider the thread stopped until we've processed its
252 initial SIGSTOP stop. */
253 set_executing (this, thr
->ptid
, true);
258 #ifdef PT_GET_PROCESS_STATE
261 inf_ptrace_target::post_attach (int pid
)
265 /* Set the initial event mask. */
266 memset (&pe
, 0, sizeof pe
);
267 pe
.pe_set_event
|= PTRACE_FORK
;
268 if (ptrace (PT_SET_EVENT_MASK
, pid
,
269 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
270 perror_with_name (("ptrace"));
275 /* Detach from the inferior. If FROM_TTY is non-zero, be chatty about it. */
278 inf_ptrace_target::detach (inferior
*inf
, int from_tty
)
280 pid_t pid
= inferior_ptid
.pid ();
282 target_announce_detach (from_tty
);
285 /* We'd better not have left any breakpoints in the program or it'll
286 die when it hits one. Also note that this may only work if we
287 previously attached to the inferior. It *might* work if we
288 started the process ourselves. */
290 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, 0);
292 perror_with_name (("ptrace"));
294 error (_("This system does not support detaching from a process"));
297 detach_success (inf
);
300 /* See inf-ptrace.h. */
303 inf_ptrace_target::detach_success (inferior
*inf
)
305 inferior_ptid
= null_ptid
;
306 detach_inferior (inf
);
308 maybe_unpush_target ();
311 /* Kill the inferior. */
314 inf_ptrace_target::kill ()
316 pid_t pid
= inferior_ptid
.pid ();
322 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
323 waitpid (pid
, &status
, 0);
325 target_mourn_inferior (inferior_ptid
);
330 /* See inf-ptrace.h. */
333 get_ptrace_pid (ptid_t ptid
)
337 /* If we have an LWPID to work with, use it. Otherwise, we're
338 dealing with a non-threaded program/target. */
346 /* Resume execution of thread PTID, or all threads if PTID is -1. If
347 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
351 inf_ptrace_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
353 PTRACE_TYPE_ARG1 request
;
355 if (minus_one_ptid
== ptid
)
356 /* Resume all threads. Traditionally ptrace() only supports
357 single-threaded processes, so simply resume the inferior. */
358 ptid
= ptid_t (inferior_ptid
.pid ());
360 if (catch_syscall_enabled () > 0)
361 request
= PT_SYSCALL
;
363 request
= PT_CONTINUE
;
367 /* If this system does not support PT_STEP, a higher level
368 function will have called the appropriate functions to transmute the
369 step 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 gdb_ptrace (request
, ptid
, (PTRACE_TYPE_ARG3
)1, gdb_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_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
393 int status
, save_errno
;
401 pid
= waitpid (ptid
.pid (), &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
= GDB_SIGNAL_UNKNOWN
;
417 return inferior_ptid
;
420 /* Ignore terminated detached child processes. */
421 if (!WIFSTOPPED (status
) && pid
!= inferior_ptid
.pid ())
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
= ptid_t (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
== inferior_ptid
.pid ())
455 ourstatus
->value
.related_pid
= ptid_t (pe
.pe_other_pid
);
456 return ptid_t (fpid
);
464 store_waitstatus (ourstatus
, status
);
468 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
469 from process PID's memory into READBUF. Start at target address ADDR
470 and transfer up to LEN bytes. Exactly one of READBUF and WRITEBUF must
471 be non-null. Return the number of transferred bytes. */
474 inf_ptrace_peek_poke (ptid_t ptid
, gdb_byte
*readbuf
,
475 const gdb_byte
*writebuf
,
476 ULONGEST addr
, ULONGEST len
)
481 /* We transfer aligned words. Thus align ADDR down to a word
482 boundary and determine how many bytes to skip at the
484 ULONGEST skip
= addr
& (sizeof (PTRACE_TYPE_RET
) - 1);
489 n
+= chunk
, addr
+= sizeof (PTRACE_TYPE_RET
), skip
= 0)
491 /* Restrict to a chunk that fits in the current word. */
492 chunk
= std::min (sizeof (PTRACE_TYPE_RET
) - skip
, len
- n
);
494 /* Use a union for type punning. */
497 PTRACE_TYPE_RET word
;
498 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
501 /* Read the word, also when doing a partial word write. */
502 if (readbuf
!= NULL
|| chunk
< sizeof (PTRACE_TYPE_RET
))
505 buf
.word
= gdb_ptrace (PT_READ_I
, ptid
,
506 (PTRACE_TYPE_ARG3
)(uintptr_t) addr
, 0);
510 memcpy (readbuf
+ n
, buf
.byte
+ skip
, chunk
);
512 if (writebuf
!= NULL
)
514 memcpy (buf
.byte
+ skip
, writebuf
+ n
, chunk
);
516 gdb_ptrace (PT_WRITE_D
, ptid
, (PTRACE_TYPE_ARG3
)(uintptr_t) addr
,
520 /* Using the appropriate one (I or D) is necessary for
521 Gould NP1, at least. */
523 gdb_ptrace (PT_WRITE_I
, ptid
, (PTRACE_TYPE_ARG3
)(uintptr_t) addr
,
534 /* Implement the to_xfer_partial target_ops method. */
536 enum target_xfer_status
537 inf_ptrace_target::xfer_partial (enum target_object object
,
538 const char *annex
, gdb_byte
*readbuf
,
539 const gdb_byte
*writebuf
,
540 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
542 ptid_t ptid
= inferior_ptid
;
546 case TARGET_OBJECT_MEMORY
:
548 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
549 request that promises to be much more efficient in reading
550 and writing data in the traced process's address space. */
552 struct ptrace_io_desc piod
;
554 /* NOTE: We assume that there are no distinct address spaces
555 for instruction and data. However, on OpenBSD 3.9 and
556 later, PIOD_WRITE_D doesn't allow changing memory that's
557 mapped read-only. Since most code segments will be
558 read-only, using PIOD_WRITE_D will prevent us from
559 inserting breakpoints, so we use PIOD_WRITE_I instead. */
560 piod
.piod_op
= writebuf
? PIOD_WRITE_I
: PIOD_READ_D
;
561 piod
.piod_addr
= writebuf
? (void *) writebuf
: readbuf
;
562 piod
.piod_offs
= (void *) (long) offset
;
566 if (gdb_ptrace (PT_IO
, ptid
, (caddr_t
)&piod
, 0) == 0)
568 /* Return the actual number of bytes read or written. */
569 *xfered_len
= piod
.piod_len
;
570 return (piod
.piod_len
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
572 /* If the PT_IO request is somehow not supported, fallback on
573 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
574 to indicate failure. */
576 return TARGET_XFER_EOF
;
579 *xfered_len
= inf_ptrace_peek_poke (ptid
, readbuf
, writebuf
,
581 return *xfered_len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
583 case TARGET_OBJECT_UNWIND_TABLE
:
584 return TARGET_XFER_E_IO
;
586 case TARGET_OBJECT_AUXV
:
587 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
588 /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
589 request that allows us to read the auxilliary vector. Other
590 BSD's may follow if they feel the need to support PIE. */
592 struct ptrace_io_desc piod
;
595 return TARGET_XFER_E_IO
;
596 piod
.piod_op
= PIOD_READ_AUXV
;
597 piod
.piod_addr
= readbuf
;
598 piod
.piod_offs
= (void *) (long) offset
;
602 if (gdb_ptrace (PT_IO
, ptid
, (caddr_t
)&piod
, 0) == 0)
604 /* Return the actual number of bytes read or written. */
605 *xfered_len
= piod
.piod_len
;
606 return (piod
.piod_len
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
610 return TARGET_XFER_E_IO
;
612 case TARGET_OBJECT_WCOOKIE
:
613 return TARGET_XFER_E_IO
;
616 return TARGET_XFER_E_IO
;
620 /* Return non-zero if the thread specified by PTID is alive. */
623 inf_ptrace_target::thread_alive (ptid_t ptid
)
625 /* ??? Is kill the right way to do this? */
626 return (::kill (ptid
.pid (), 0) != -1);
629 /* Print status information about what we're accessing. */
632 inf_ptrace_target::files_info ()
634 struct inferior
*inf
= current_inferior ();
636 printf_filtered (_("\tUsing the running image of %s %s.\n"),
637 inf
->attach_flag
? "attached" : "child",
638 target_pid_to_str (inferior_ptid
).c_str ());
642 inf_ptrace_target::pid_to_str (ptid_t ptid
)
644 return normal_pid_to_str (ptid
);
647 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
649 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
650 Return 0 if *READPTR is already at the end of the buffer.
651 Return -1 if there is insufficient buffer for a whole entry.
652 Return 1 if an entry was read into *TYPEP and *VALP. */
655 inf_ptrace_target::auxv_parse (gdb_byte
**readptr
, gdb_byte
*endptr
,
656 CORE_ADDR
*typep
, CORE_ADDR
*valp
)
658 struct type
*int_type
= builtin_type (target_gdbarch ())->builtin_int
;
659 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
660 const int sizeof_auxv_type
= TYPE_LENGTH (int_type
);
661 const int sizeof_auxv_val
= TYPE_LENGTH (ptr_type
);
662 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
663 gdb_byte
*ptr
= *readptr
;
668 if (endptr
- ptr
< 2 * sizeof_auxv_val
)
671 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_type
, byte_order
);
672 ptr
+= sizeof_auxv_val
; /* Alignment. */
673 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_val
, byte_order
);
674 ptr
+= sizeof_auxv_val
;