1 /* Low-level child interface to ptrace.
3 Copyright (C) 1988-2018 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"
34 #include "nat/fork-inferior.h"
39 #ifdef PT_GET_PROCESS_STATE
41 /* Target hook for follow_fork. On entry and at return inferior_ptid is
42 the ptid of the followed inferior. */
45 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child,
50 struct thread_info *tp = inferior_thread ();
51 pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
53 /* Breakpoints have already been detached from the child by
56 if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
57 perror_with_name (("ptrace"));
64 inf_ptrace_insert_fork_catchpoint (struct target_ops *self, int pid)
70 inf_ptrace_remove_fork_catchpoint (struct target_ops *self, int pid)
75 #endif /* PT_GET_PROCESS_STATE */
78 /* Prepare to be traced. */
83 /* "Trace me, Dr. Memory!" */
84 if (ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3) 0, 0) < 0)
85 trace_start_error_with_name ("ptrace");
88 /* Start a new inferior Unix child process. EXEC_FILE is the file to
89 run, ALLARGS is a string containing the arguments to the program.
90 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
94 inf_ptrace_create_inferior (struct target_ops *ops,
95 const char *exec_file, const std::string &allargs,
96 char **env, int from_tty)
101 /* Do not change either targets above or the same target if already present.
102 The reason is the target stack is shared across multiple inferiors. */
103 int ops_already_pushed = target_is_pushed (ops);
104 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
106 if (! ops_already_pushed)
108 /* Clear possible core file with its process_stratum. */
110 make_cleanup_unpush_target (ops);
113 pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
116 ptid = pid_to_ptid (pid);
117 /* We have something that executes now. We'll be running through
118 the shell at this point (if startup-with-shell is true), but the
119 pid shouldn't change. */
120 add_thread_silent (ptid);
122 discard_cleanups (back_to);
124 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
126 /* On some targets, there must be some explicit actions taken after
127 the inferior has been started up. */
128 target_post_startup_inferior (ptid);
131 #ifdef PT_GET_PROCESS_STATE
134 inf_ptrace_post_startup_inferior (struct target_ops *self, ptid_t pid)
138 /* Set the initial event mask. */
139 memset (&pe, 0, sizeof pe);
140 pe.pe_set_event |= PTRACE_FORK;
141 if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
142 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
143 perror_with_name (("ptrace"));
148 /* Clean up a rotting corpse of an inferior after it died. */
151 inf_ptrace_mourn_inferior (struct target_ops *ops)
155 /* Wait just one more time to collect the inferior's exit status.
156 Do not check whether this succeeds though, since we may be
157 dealing with a process that we attached to. Such a process will
158 only report its exit status to its original parent. */
159 waitpid (ptid_get_pid (inferior_ptid), &status, 0);
161 inf_child_mourn_inferior (ops);
164 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
165 be chatty about it. */
168 inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty)
172 struct inferior *inf;
174 /* Do not change either targets above or the same target if already present.
175 The reason is the target stack is shared across multiple inferiors. */
176 int ops_already_pushed = target_is_pushed (ops);
177 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
179 pid = parse_pid_to_attach (args);
181 if (pid == getpid ()) /* Trying to masturbate? */
182 error (_("I refuse to debug myself!"));
184 if (! ops_already_pushed)
186 /* target_pid_to_str already uses the target. Also clear possible core
187 file with its process_stratum. */
189 make_cleanup_unpush_target (ops);
194 exec_file = get_exec_file (0);
197 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
198 target_pid_to_str (pid_to_ptid (pid)));
200 printf_unfiltered (_("Attaching to %s\n"),
201 target_pid_to_str (pid_to_ptid (pid)));
203 gdb_flush (gdb_stdout);
208 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
210 perror_with_name (("ptrace"));
212 error (_("This system does not support attaching to a process"));
215 inf = current_inferior ();
216 inferior_appeared (inf, pid);
217 inf->attach_flag = 1;
218 inferior_ptid = pid_to_ptid (pid);
220 /* Always add a main thread. If some target extends the ptrace
221 target, it should decorate the ptid later with more info. */
222 add_thread_silent (inferior_ptid);
224 discard_cleanups (back_to);
227 #ifdef PT_GET_PROCESS_STATE
230 inf_ptrace_post_attach (struct target_ops *self, int pid)
234 /* Set the initial event mask. */
235 memset (&pe, 0, sizeof pe);
236 pe.pe_set_event |= PTRACE_FORK;
237 if (ptrace (PT_SET_EVENT_MASK, pid,
238 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
239 perror_with_name (("ptrace"));
244 /* Detach from the inferior. If FROM_TTY is non-zero, be chatty about it. */
247 inf_ptrace_detach (struct target_ops *ops, inferior *inf, int from_tty)
249 pid_t pid = ptid_get_pid (inferior_ptid);
251 target_announce_detach (from_tty);
254 /* We'd better not have left any breakpoints in the program or it'll
255 die when it hits one. Also note that this may only work if we
256 previously attached to the inferior. It *might* work if we
257 started the process ourselves. */
259 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0);
261 perror_with_name (("ptrace"));
263 error (_("This system does not support detaching from a process"));
266 inf_ptrace_detach_success (ops);
269 /* See inf-ptrace.h. */
272 inf_ptrace_detach_success (struct target_ops *ops)
274 pid_t pid = ptid_get_pid (inferior_ptid);
276 inferior_ptid = null_ptid;
277 detach_inferior (pid);
279 inf_child_maybe_unpush_target (ops);
282 /* Kill the inferior. */
285 inf_ptrace_kill (struct target_ops *ops)
287 pid_t pid = ptid_get_pid (inferior_ptid);
293 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
294 waitpid (pid, &status, 0);
296 target_mourn_inferior (inferior_ptid);
299 /* Interrupt the inferior. */
302 inf_ptrace_interrupt (struct target_ops *self, ptid_t ptid)
304 /* Send a SIGINT to the process group. This acts just like the user
305 typed a ^C on the controlling terminal. Note that using a
306 negative process number in kill() is a System V-ism. The proper
307 BSD interface is killpg(). However, all modern BSDs support the
308 System V interface too. */
309 kill (-inferior_process_group (), SIGINT);
312 /* Return which PID to pass to ptrace in order to observe/control the
313 tracee identified by PTID. */
316 get_ptrace_pid (ptid_t ptid)
320 /* If we have an LWPID to work with, use it. Otherwise, we're
321 dealing with a non-threaded program/target. */
322 pid = ptid_get_lwp (ptid);
324 pid = ptid_get_pid (ptid);
328 /* Resume execution of thread PTID, or all threads if PTID is -1. If
329 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
333 inf_ptrace_resume (struct target_ops *ops,
334 ptid_t ptid, int step, enum gdb_signal signal)
339 if (ptid_equal (minus_one_ptid, ptid))
340 /* Resume all threads. Traditionally ptrace() only supports
341 single-threaded processes, so simply resume the inferior. */
342 pid = ptid_get_pid (inferior_ptid);
344 pid = get_ptrace_pid (ptid);
346 if (catch_syscall_enabled () > 0)
347 request = PT_SYSCALL;
349 request = PT_CONTINUE;
353 /* If this system does not support PT_STEP, a higher level
354 function will have called single_step() to transmute the step
355 request into a continue request (by setting breakpoints on
356 all possible successor instructions), so we don't have to
357 worry about that here. */
361 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
362 where it was. If GDB wanted it to start some other way, we have
363 already written a new program counter value to the child. */
365 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal));
367 perror_with_name (("ptrace"));
370 /* Wait for the child specified by PTID to do something. Return the
371 process ID of the child, or MINUS_ONE_PTID in case of error; store
372 the status in *OURSTATUS. */
375 inf_ptrace_wait (struct target_ops *ops,
376 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
379 int status, save_errno;
387 pid = waitpid (ptid_get_pid (ptid), &status, 0);
390 while (pid == -1 && errno == EINTR);
392 clear_sigint_trap ();
396 fprintf_unfiltered (gdb_stderr,
397 _("Child process unexpectedly missing: %s.\n"),
398 safe_strerror (save_errno));
400 /* Claim it exited with unknown signal. */
401 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
402 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
403 return inferior_ptid;
406 /* Ignore terminated detached child processes. */
407 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
412 #ifdef PT_GET_PROCESS_STATE
413 if (WIFSTOPPED (status))
418 if (ptrace (PT_GET_PROCESS_STATE, pid,
419 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
420 perror_with_name (("ptrace"));
422 switch (pe.pe_report_event)
425 ourstatus->kind = TARGET_WAITKIND_FORKED;
426 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
428 /* Make sure the other end of the fork is stopped too. */
429 fpid = waitpid (pe.pe_other_pid, &status, 0);
431 perror_with_name (("waitpid"));
433 if (ptrace (PT_GET_PROCESS_STATE, fpid,
434 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
435 perror_with_name (("ptrace"));
437 gdb_assert (pe.pe_report_event == PTRACE_FORK);
438 gdb_assert (pe.pe_other_pid == pid);
439 if (fpid == ptid_get_pid (inferior_ptid))
441 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
442 return pid_to_ptid (fpid);
445 return pid_to_ptid (pid);
450 store_waitstatus (ourstatus, status);
451 return pid_to_ptid (pid);
454 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
455 from process PID's memory into READBUF. Start at target address ADDR
456 and transfer up to LEN bytes. Exactly one of READBUF and WRITEBUF must
457 be non-null. Return the number of transferred bytes. */
460 inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf,
461 const gdb_byte *writebuf,
462 ULONGEST addr, ULONGEST len)
467 /* We transfer aligned words. Thus align ADDR down to a word
468 boundary and determine how many bytes to skip at the
470 ULONGEST skip = addr & (sizeof (PTRACE_TYPE_RET) - 1);
475 n += chunk, addr += sizeof (PTRACE_TYPE_RET), skip = 0)
477 /* Restrict to a chunk that fits in the current word. */
478 chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n);
480 /* Use a union for type punning. */
483 PTRACE_TYPE_RET word;
484 gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
487 /* Read the word, also when doing a partial word write. */
488 if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET))
491 buf.word = ptrace (PT_READ_I, pid,
492 (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0);
496 memcpy (readbuf + n, buf.byte + skip, chunk);
498 if (writebuf != NULL)
500 memcpy (buf.byte + skip, writebuf + n, chunk);
502 ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
506 /* Using the appropriate one (I or D) is necessary for
507 Gould NP1, at least. */
509 ptrace (PT_WRITE_I, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
520 /* Implement the to_xfer_partial target_ops method. */
522 static enum target_xfer_status
523 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
524 const char *annex, gdb_byte *readbuf,
525 const gdb_byte *writebuf,
526 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
528 pid_t pid = get_ptrace_pid (inferior_ptid);
532 case TARGET_OBJECT_MEMORY:
534 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
535 request that promises to be much more efficient in reading
536 and writing data in the traced process's address space. */
538 struct ptrace_io_desc piod;
540 /* NOTE: We assume that there are no distinct address spaces
541 for instruction and data. However, on OpenBSD 3.9 and
542 later, PIOD_WRITE_D doesn't allow changing memory that's
543 mapped read-only. Since most code segments will be
544 read-only, using PIOD_WRITE_D will prevent us from
545 inserting breakpoints, so we use PIOD_WRITE_I instead. */
546 piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
547 piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
548 piod.piod_offs = (void *) (long) offset;
552 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
554 /* Return the actual number of bytes read or written. */
555 *xfered_len = piod.piod_len;
556 return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
558 /* If the PT_IO request is somehow not supported, fallback on
559 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
560 to indicate failure. */
562 return TARGET_XFER_EOF;
565 *xfered_len = inf_ptrace_peek_poke (pid, readbuf, writebuf,
567 return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
569 case TARGET_OBJECT_UNWIND_TABLE:
570 return TARGET_XFER_E_IO;
572 case TARGET_OBJECT_AUXV:
573 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
574 /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
575 request that allows us to read the auxilliary vector. Other
576 BSD's may follow if they feel the need to support PIE. */
578 struct ptrace_io_desc piod;
581 return TARGET_XFER_E_IO;
582 piod.piod_op = PIOD_READ_AUXV;
583 piod.piod_addr = readbuf;
584 piod.piod_offs = (void *) (long) offset;
588 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
590 /* Return the actual number of bytes read or written. */
591 *xfered_len = piod.piod_len;
592 return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
596 return TARGET_XFER_E_IO;
598 case TARGET_OBJECT_WCOOKIE:
599 return TARGET_XFER_E_IO;
602 return TARGET_XFER_E_IO;
606 /* Return non-zero if the thread specified by PTID is alive. */
609 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
611 /* ??? Is kill the right way to do this? */
612 return (kill (ptid_get_pid (ptid), 0) != -1);
615 /* Print status information about what we're accessing. */
618 inf_ptrace_files_info (struct target_ops *ignore)
620 struct inferior *inf = current_inferior ();
622 printf_filtered (_("\tUsing the running image of %s %s.\n"),
623 inf->attach_flag ? "attached" : "child",
624 target_pid_to_str (inferior_ptid));
628 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
630 return normal_pid_to_str (ptid);
633 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
635 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
636 Return 0 if *READPTR is already at the end of the buffer.
637 Return -1 if there is insufficient buffer for a whole entry.
638 Return 1 if an entry was read into *TYPEP and *VALP. */
641 inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
642 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
644 struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
645 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
646 const int sizeof_auxv_type = TYPE_LENGTH (int_type);
647 const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
648 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
649 gdb_byte *ptr = *readptr;
654 if (endptr - ptr < 2 * sizeof_auxv_val)
657 *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
658 ptr += sizeof_auxv_val; /* Alignment. */
659 *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
660 ptr += sizeof_auxv_val;
668 /* Create a prototype ptrace target. The client can override it with
672 inf_ptrace_target (void)
674 struct target_ops *t = inf_child_target ();
676 t->to_attach = inf_ptrace_attach;
677 t->to_detach = inf_ptrace_detach;
678 t->to_resume = inf_ptrace_resume;
679 t->to_wait = inf_ptrace_wait;
680 t->to_files_info = inf_ptrace_files_info;
681 t->to_kill = inf_ptrace_kill;
682 t->to_create_inferior = inf_ptrace_create_inferior;
683 #ifdef PT_GET_PROCESS_STATE
684 t->to_follow_fork = inf_ptrace_follow_fork;
685 t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
686 t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
687 t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
688 t->to_post_attach = inf_ptrace_post_attach;
690 t->to_mourn_inferior = inf_ptrace_mourn_inferior;
691 t->to_thread_alive = inf_ptrace_thread_alive;
692 t->to_pid_to_str = inf_ptrace_pid_to_str;
693 t->to_interrupt = inf_ptrace_interrupt;
694 t->to_xfer_partial = inf_ptrace_xfer_partial;
695 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
696 t->to_auxv_parse = inf_ptrace_auxv_parse;
703 /* Pointer to a function that returns the offset within the user area
704 where a particular register is stored. */
705 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
707 /* Fetch register REGNUM from the inferior. */
710 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
712 struct gdbarch *gdbarch = regcache->arch ();
715 PTRACE_TYPE_RET *buf;
719 /* This isn't really an address, but ptrace thinks of it as one. */
720 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
721 if (addr == (CORE_ADDR)-1
722 || gdbarch_cannot_fetch_register (gdbarch, regnum))
724 regcache_raw_supply (regcache, regnum, NULL);
728 pid = get_ptrace_pid (regcache_get_ptid (regcache));
730 size = register_size (gdbarch, regnum);
731 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
732 buf = (PTRACE_TYPE_RET *) alloca (size);
734 /* Read the register contents from the inferior a chunk at a time. */
735 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
738 buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
740 error (_("Couldn't read register %s (#%d): %s."),
741 gdbarch_register_name (gdbarch, regnum),
742 regnum, safe_strerror (errno));
744 addr += sizeof (PTRACE_TYPE_RET);
746 regcache_raw_supply (regcache, regnum, buf);
749 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
750 for all registers. */
753 inf_ptrace_fetch_registers (struct target_ops *ops,
754 struct regcache *regcache, int regnum)
758 regnum < gdbarch_num_regs (regcache->arch ());
760 inf_ptrace_fetch_register (regcache, regnum);
762 inf_ptrace_fetch_register (regcache, regnum);
765 /* Store register REGNUM into the inferior. */
768 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
770 struct gdbarch *gdbarch = regcache->arch ();
773 PTRACE_TYPE_RET *buf;
777 /* This isn't really an address, but ptrace thinks of it as one. */
778 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
779 if (addr == (CORE_ADDR)-1
780 || gdbarch_cannot_store_register (gdbarch, regnum))
783 pid = get_ptrace_pid (regcache_get_ptid (regcache));
785 size = register_size (gdbarch, regnum);
786 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
787 buf = (PTRACE_TYPE_RET *) alloca (size);
789 /* Write the register contents into the inferior a chunk at a time. */
790 regcache_raw_collect (regcache, regnum, buf);
791 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
794 ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
796 error (_("Couldn't write register %s (#%d): %s."),
797 gdbarch_register_name (gdbarch, regnum),
798 regnum, safe_strerror (errno));
800 addr += sizeof (PTRACE_TYPE_RET);
804 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
805 this for all registers. */
808 inf_ptrace_store_registers (struct target_ops *ops,
809 struct regcache *regcache, int regnum)
813 regnum < gdbarch_num_regs (regcache->arch ());
815 inf_ptrace_store_register (regcache, regnum);
817 inf_ptrace_store_register (regcache, regnum);
820 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
821 a function returning the offset within the user area where a
822 particular register is stored. */
825 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
826 (struct gdbarch *, int, int))
828 struct target_ops *t = inf_ptrace_target();
830 gdb_assert (register_u_offset);
831 inf_ptrace_register_u_offset = register_u_offset;
832 t->to_fetch_registers = inf_ptrace_fetch_registers;
833 t->to_store_registers = inf_ptrace_store_registers;