1 /* Low-level child interface to ptrace.
3 Copyright (C) 1988-2017 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"
31 #include "inf-ptrace.h"
32 #include "inf-child.h"
33 #include "gdbthread.h"
37 #ifdef PT_GET_PROCESS_STATE
39 /* Target hook for follow_fork. On entry and at return inferior_ptid is
40 the ptid of the followed inferior. */
43 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child,
48 struct thread_info *tp = inferior_thread ();
49 pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
51 /* Breakpoints have already been detached from the child by
54 if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
55 perror_with_name (("ptrace"));
62 inf_ptrace_insert_fork_catchpoint (struct target_ops *self, int pid)
68 inf_ptrace_remove_fork_catchpoint (struct target_ops *self, int pid)
73 #endif /* PT_GET_PROCESS_STATE */
76 /* Prepare to be traced. */
81 /* "Trace me, Dr. Memory!" */
82 if (ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3) 0, 0) < 0)
83 trace_start_error_with_name ("ptrace");
86 /* Start a new inferior Unix child process. EXEC_FILE is the file to
87 run, ALLARGS is a string containing the arguments to the program.
88 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
92 inf_ptrace_create_inferior (struct target_ops *ops,
93 char *exec_file, char *allargs, char **env,
98 /* Do not change either targets above or the same target if already present.
99 The reason is the target stack is shared across multiple inferiors. */
100 int ops_already_pushed = target_is_pushed (ops);
101 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
103 if (! ops_already_pushed)
105 /* Clear possible core file with its process_stratum. */
107 make_cleanup_unpush_target (ops);
110 pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
113 discard_cleanups (back_to);
115 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
117 /* On some targets, there must be some explicit actions taken after
118 the inferior has been started up. */
119 target_post_startup_inferior (pid_to_ptid (pid));
122 #ifdef PT_GET_PROCESS_STATE
125 inf_ptrace_post_startup_inferior (struct target_ops *self, ptid_t pid)
129 /* Set the initial event mask. */
130 memset (&pe, 0, sizeof pe);
131 pe.pe_set_event |= PTRACE_FORK;
132 if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
133 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
134 perror_with_name (("ptrace"));
139 /* Clean up a rotting corpse of an inferior after it died. */
142 inf_ptrace_mourn_inferior (struct target_ops *ops)
146 /* Wait just one more time to collect the inferior's exit status.
147 Do not check whether this succeeds though, since we may be
148 dealing with a process that we attached to. Such a process will
149 only report its exit status to its original parent. */
150 waitpid (ptid_get_pid (inferior_ptid), &status, 0);
152 inf_child_mourn_inferior (ops);
155 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
156 be chatty about it. */
159 inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty)
163 struct inferior *inf;
165 /* Do not change either targets above or the same target if already present.
166 The reason is the target stack is shared across multiple inferiors. */
167 int ops_already_pushed = target_is_pushed (ops);
168 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
170 pid = parse_pid_to_attach (args);
172 if (pid == getpid ()) /* Trying to masturbate? */
173 error (_("I refuse to debug myself!"));
175 if (! ops_already_pushed)
177 /* target_pid_to_str already uses the target. Also clear possible core
178 file with its process_stratum. */
180 make_cleanup_unpush_target (ops);
185 exec_file = get_exec_file (0);
188 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
189 target_pid_to_str (pid_to_ptid (pid)));
191 printf_unfiltered (_("Attaching to %s\n"),
192 target_pid_to_str (pid_to_ptid (pid)));
194 gdb_flush (gdb_stdout);
199 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
201 perror_with_name (("ptrace"));
203 error (_("This system does not support attaching to a process"));
206 inf = current_inferior ();
207 inferior_appeared (inf, pid);
208 inf->attach_flag = 1;
209 inferior_ptid = pid_to_ptid (pid);
211 /* Always add a main thread. If some target extends the ptrace
212 target, it should decorate the ptid later with more info. */
213 add_thread_silent (inferior_ptid);
215 discard_cleanups (back_to);
218 #ifdef PT_GET_PROCESS_STATE
221 inf_ptrace_post_attach (struct target_ops *self, int pid)
225 /* Set the initial event mask. */
226 memset (&pe, 0, sizeof pe);
227 pe.pe_set_event |= PTRACE_FORK;
228 if (ptrace (PT_SET_EVENT_MASK, pid,
229 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
230 perror_with_name (("ptrace"));
235 /* Detach from the inferior, optionally passing it the signal
236 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
239 inf_ptrace_detach (struct target_ops *ops, const char *args, int from_tty)
241 pid_t pid = ptid_get_pid (inferior_ptid);
244 target_announce_detach (from_tty);
249 /* We'd better not have left any breakpoints in the program or it'll
250 die when it hits one. Also note that this may only work if we
251 previously attached to the inferior. It *might* work if we
252 started the process ourselves. */
254 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
256 perror_with_name (("ptrace"));
258 error (_("This system does not support detaching from a process"));
261 inf_ptrace_detach_success (ops);
264 /* See inf-ptrace.h. */
267 inf_ptrace_detach_success (struct target_ops *ops)
269 pid_t pid = ptid_get_pid (inferior_ptid);
271 inferior_ptid = null_ptid;
272 detach_inferior (pid);
274 inf_child_maybe_unpush_target (ops);
277 /* Kill the inferior. */
280 inf_ptrace_kill (struct target_ops *ops)
282 pid_t pid = ptid_get_pid (inferior_ptid);
288 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
289 waitpid (pid, &status, 0);
291 target_mourn_inferior (inferior_ptid);
294 /* Interrupt the inferior. */
297 inf_ptrace_interrupt (struct target_ops *self, ptid_t ptid)
299 /* Send a SIGINT to the process group. This acts just like the user
300 typed a ^C on the controlling terminal. Note that using a
301 negative process number in kill() is a System V-ism. The proper
302 BSD interface is killpg(). However, all modern BSDs support the
303 System V interface too. */
304 kill (-inferior_process_group (), SIGINT);
307 /* Return which PID to pass to ptrace in order to observe/control the
308 tracee identified by PTID. */
311 get_ptrace_pid (ptid_t ptid)
315 /* If we have an LWPID to work with, use it. Otherwise, we're
316 dealing with a non-threaded program/target. */
317 pid = ptid_get_lwp (ptid);
319 pid = ptid_get_pid (ptid);
323 /* Resume execution of thread PTID, or all threads if PTID is -1. If
324 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
328 inf_ptrace_resume (struct target_ops *ops,
329 ptid_t ptid, int step, enum gdb_signal signal)
334 if (ptid_equal (minus_one_ptid, ptid))
335 /* Resume all threads. Traditionally ptrace() only supports
336 single-threaded processes, so simply resume the inferior. */
337 pid = ptid_get_pid (inferior_ptid);
339 pid = get_ptrace_pid (ptid);
341 if (catch_syscall_enabled () > 0)
342 request = PT_SYSCALL;
344 request = PT_CONTINUE;
348 /* If this system does not support PT_STEP, a higher level
349 function will have called single_step() to transmute the step
350 request into a continue request (by setting breakpoints on
351 all possible successor instructions), so we don't have to
352 worry about that here. */
356 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
357 where it was. If GDB wanted it to start some other way, we have
358 already written a new program counter value to the child. */
360 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal));
362 perror_with_name (("ptrace"));
365 /* Wait for the child specified by PTID to do something. Return the
366 process ID of the child, or MINUS_ONE_PTID in case of error; store
367 the status in *OURSTATUS. */
370 inf_ptrace_wait (struct target_ops *ops,
371 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
374 int status, save_errno;
382 pid = waitpid (ptid_get_pid (ptid), &status, 0);
385 while (pid == -1 && errno == EINTR);
387 clear_sigint_trap ();
391 fprintf_unfiltered (gdb_stderr,
392 _("Child process unexpectedly missing: %s.\n"),
393 safe_strerror (save_errno));
395 /* Claim it exited with unknown signal. */
396 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
397 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
398 return inferior_ptid;
401 /* Ignore terminated detached child processes. */
402 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
407 #ifdef PT_GET_PROCESS_STATE
408 if (WIFSTOPPED (status))
413 if (ptrace (PT_GET_PROCESS_STATE, pid,
414 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
415 perror_with_name (("ptrace"));
417 switch (pe.pe_report_event)
420 ourstatus->kind = TARGET_WAITKIND_FORKED;
421 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
423 /* Make sure the other end of the fork is stopped too. */
424 fpid = waitpid (pe.pe_other_pid, &status, 0);
426 perror_with_name (("waitpid"));
428 if (ptrace (PT_GET_PROCESS_STATE, fpid,
429 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
430 perror_with_name (("ptrace"));
432 gdb_assert (pe.pe_report_event == PTRACE_FORK);
433 gdb_assert (pe.pe_other_pid == pid);
434 if (fpid == ptid_get_pid (inferior_ptid))
436 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
437 return pid_to_ptid (fpid);
440 return pid_to_ptid (pid);
445 store_waitstatus (ourstatus, status);
446 return pid_to_ptid (pid);
449 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
450 from process PID's memory into READBUF. Start at target address ADDR
451 and transfer up to LEN bytes. Exactly one of READBUF and WRITEBUF must
452 be non-null. Return the number of transferred bytes. */
455 inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf,
456 const gdb_byte *writebuf,
457 ULONGEST addr, ULONGEST len)
462 /* We transfer aligned words. Thus align ADDR down to a word
463 boundary and determine how many bytes to skip at the
465 ULONGEST skip = addr & (sizeof (PTRACE_TYPE_RET) - 1);
470 n += chunk, addr += sizeof (PTRACE_TYPE_RET), skip = 0)
472 /* Restrict to a chunk that fits in the current word. */
473 chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n);
475 /* Use a union for type punning. */
478 PTRACE_TYPE_RET word;
479 gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
482 /* Read the word, also when doing a partial word write. */
483 if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET))
486 buf.word = ptrace (PT_READ_I, pid,
487 (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0);
491 memcpy (readbuf + n, buf.byte + skip, chunk);
493 if (writebuf != NULL)
495 memcpy (buf.byte + skip, writebuf + n, chunk);
497 ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
501 /* Using the appropriate one (I or D) is necessary for
502 Gould NP1, at least. */
504 ptrace (PT_WRITE_I, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
515 /* Implement the to_xfer_partial target_ops method. */
517 static enum target_xfer_status
518 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
519 const char *annex, gdb_byte *readbuf,
520 const gdb_byte *writebuf,
521 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
523 pid_t pid = ptid_get_pid (inferior_ptid);
527 case TARGET_OBJECT_MEMORY:
529 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
530 request that promises to be much more efficient in reading
531 and writing data in the traced process's address space. */
533 struct ptrace_io_desc piod;
535 /* NOTE: We assume that there are no distinct address spaces
536 for instruction and data. However, on OpenBSD 3.9 and
537 later, PIOD_WRITE_D doesn't allow changing memory that's
538 mapped read-only. Since most code segments will be
539 read-only, using PIOD_WRITE_D will prevent us from
540 inserting breakpoints, so we use PIOD_WRITE_I instead. */
541 piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
542 piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
543 piod.piod_offs = (void *) (long) offset;
547 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
549 /* Return the actual number of bytes read or written. */
550 *xfered_len = piod.piod_len;
551 return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
553 /* If the PT_IO request is somehow not supported, fallback on
554 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
555 to indicate failure. */
557 return TARGET_XFER_EOF;
560 *xfered_len = inf_ptrace_peek_poke (pid, readbuf, writebuf,
562 return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
564 case TARGET_OBJECT_UNWIND_TABLE:
565 return TARGET_XFER_E_IO;
567 case TARGET_OBJECT_AUXV:
568 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
569 /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
570 request that allows us to read the auxilliary vector. Other
571 BSD's may follow if they feel the need to support PIE. */
573 struct ptrace_io_desc piod;
576 return TARGET_XFER_E_IO;
577 piod.piod_op = PIOD_READ_AUXV;
578 piod.piod_addr = readbuf;
579 piod.piod_offs = (void *) (long) offset;
583 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
585 /* Return the actual number of bytes read or written. */
586 *xfered_len = piod.piod_len;
587 return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
591 return TARGET_XFER_E_IO;
593 case TARGET_OBJECT_WCOOKIE:
594 return TARGET_XFER_E_IO;
597 return TARGET_XFER_E_IO;
601 /* Return non-zero if the thread specified by PTID is alive. */
604 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
606 /* ??? Is kill the right way to do this? */
607 return (kill (ptid_get_pid (ptid), 0) != -1);
610 /* Print status information about what we're accessing. */
613 inf_ptrace_files_info (struct target_ops *ignore)
615 struct inferior *inf = current_inferior ();
617 printf_filtered (_("\tUsing the running image of %s %s.\n"),
618 inf->attach_flag ? "attached" : "child",
619 target_pid_to_str (inferior_ptid));
623 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
625 return normal_pid_to_str (ptid);
628 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
630 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
631 Return 0 if *READPTR is already at the end of the buffer.
632 Return -1 if there is insufficient buffer for a whole entry.
633 Return 1 if an entry was read into *TYPEP and *VALP. */
636 inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
637 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
639 struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
640 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
641 const int sizeof_auxv_type = TYPE_LENGTH (int_type);
642 const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
643 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
644 gdb_byte *ptr = *readptr;
649 if (endptr - ptr < 2 * sizeof_auxv_val)
652 *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
653 ptr += sizeof_auxv_val; /* Alignment. */
654 *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
655 ptr += sizeof_auxv_val;
663 /* Create a prototype ptrace target. The client can override it with
667 inf_ptrace_target (void)
669 struct target_ops *t = inf_child_target ();
671 t->to_attach = inf_ptrace_attach;
672 t->to_detach = inf_ptrace_detach;
673 t->to_resume = inf_ptrace_resume;
674 t->to_wait = inf_ptrace_wait;
675 t->to_files_info = inf_ptrace_files_info;
676 t->to_kill = inf_ptrace_kill;
677 t->to_create_inferior = inf_ptrace_create_inferior;
678 #ifdef PT_GET_PROCESS_STATE
679 t->to_follow_fork = inf_ptrace_follow_fork;
680 t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
681 t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
682 t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
683 t->to_post_attach = inf_ptrace_post_attach;
685 t->to_mourn_inferior = inf_ptrace_mourn_inferior;
686 t->to_thread_alive = inf_ptrace_thread_alive;
687 t->to_pid_to_str = inf_ptrace_pid_to_str;
688 t->to_interrupt = inf_ptrace_interrupt;
689 t->to_xfer_partial = inf_ptrace_xfer_partial;
690 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
691 t->to_auxv_parse = inf_ptrace_auxv_parse;
698 /* Pointer to a function that returns the offset within the user area
699 where a particular register is stored. */
700 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
702 /* Fetch register REGNUM from the inferior. */
705 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
707 struct gdbarch *gdbarch = get_regcache_arch (regcache);
710 PTRACE_TYPE_RET *buf;
713 /* This isn't really an address, but ptrace thinks of it as one. */
714 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
715 if (addr == (CORE_ADDR)-1
716 || gdbarch_cannot_fetch_register (gdbarch, regnum))
718 regcache_raw_supply (regcache, regnum, NULL);
722 /* Cater for systems like GNU/Linux, that implement threads as
723 separate processes. */
724 pid = ptid_get_lwp (inferior_ptid);
726 pid = ptid_get_pid (inferior_ptid);
728 size = register_size (gdbarch, regnum);
729 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
730 buf = (PTRACE_TYPE_RET *) alloca (size);
732 /* Read the register contents from the inferior a chunk at a time. */
733 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
736 buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
738 error (_("Couldn't read register %s (#%d): %s."),
739 gdbarch_register_name (gdbarch, regnum),
740 regnum, safe_strerror (errno));
742 addr += sizeof (PTRACE_TYPE_RET);
744 regcache_raw_supply (regcache, regnum, buf);
747 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
748 for all registers. */
751 inf_ptrace_fetch_registers (struct target_ops *ops,
752 struct regcache *regcache, int regnum)
756 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
758 inf_ptrace_fetch_register (regcache, regnum);
760 inf_ptrace_fetch_register (regcache, regnum);
763 /* Store register REGNUM into the inferior. */
766 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
768 struct gdbarch *gdbarch = get_regcache_arch (regcache);
771 PTRACE_TYPE_RET *buf;
774 /* This isn't really an address, but ptrace thinks of it as one. */
775 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
776 if (addr == (CORE_ADDR)-1
777 || gdbarch_cannot_store_register (gdbarch, regnum))
780 /* Cater for systems like GNU/Linux, that implement threads as
781 separate processes. */
782 pid = ptid_get_lwp (inferior_ptid);
784 pid = ptid_get_pid (inferior_ptid);
786 size = register_size (gdbarch, regnum);
787 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
788 buf = (PTRACE_TYPE_RET *) alloca (size);
790 /* Write the register contents into the inferior a chunk at a time. */
791 regcache_raw_collect (regcache, regnum, buf);
792 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
795 ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
797 error (_("Couldn't write register %s (#%d): %s."),
798 gdbarch_register_name (gdbarch, regnum),
799 regnum, safe_strerror (errno));
801 addr += sizeof (PTRACE_TYPE_RET);
805 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
806 this for all registers. */
809 inf_ptrace_store_registers (struct target_ops *ops,
810 struct regcache *regcache, int regnum)
814 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
816 inf_ptrace_store_register (regcache, regnum);
818 inf_ptrace_store_register (regcache, regnum);
821 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
822 a function returning the offset within the user area where a
823 particular register is stored. */
826 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
827 (struct gdbarch *, int, int))
829 struct target_ops *t = inf_ptrace_target();
831 gdb_assert (register_u_offset);
832 inf_ptrace_register_u_offset = register_u_offset;
833 t->to_fetch_registers = inf_ptrace_fetch_registers;
834 t->to_store_registers = inf_ptrace_store_registers;