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, 2010
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/>. */
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
32 #include "gdb_ptrace.h"
36 #include "inf-ptrace.h"
37 #include "inf-child.h"
38 #include "gdbthread.h"
42 #ifdef PT_GET_PROCESS_STATE
45 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
50 pid = ptid_get_pid (inferior_ptid);
52 if (ptrace (PT_GET_PROCESS_STATE, pid,
53 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
54 perror_with_name (("ptrace"));
56 gdb_assert (pe.pe_report_event == PTRACE_FORK);
57 fpid = pe.pe_other_pid;
61 struct inferior *parent_inf, *child_inf;
62 struct thread_info *tp;
64 parent_inf = find_inferior_pid (pid);
67 child_inf = add_inferior (fpid);
68 child_inf->attach_flag = parent_inf->attach_flag;
69 copy_terminal_info (child_inf, parent_inf);
70 child_inf->pspace = parent_inf->pspace;
71 child_inf->aspace = parent_inf->aspace;
73 /* Before detaching from the parent, remove all breakpoints from
75 remove_breakpoints ();
77 if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
78 perror_with_name (("ptrace"));
80 /* Switch inferior_ptid out of the parent's way. */
81 inferior_ptid = pid_to_ptid (fpid);
83 /* Delete the parent. */
84 detach_inferior (pid);
86 add_thread_silent (inferior_ptid);
90 /* Breakpoints have already been detached from the child by
93 if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
94 perror_with_name (("ptrace"));
100 #endif /* PT_GET_PROCESS_STATE */
103 /* Prepare to be traced. */
108 /* "Trace me, Dr. Memory!" */
109 ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
112 /* Start a new inferior Unix child process. EXEC_FILE is the file to
113 run, ALLARGS is a string containing the arguments to the program.
114 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
118 inf_ptrace_create_inferior (struct target_ops *ops,
119 char *exec_file, char *allargs, char **env,
124 /* Do not change either targets above or the same target if already present.
125 The reason is the target stack is shared across multiple inferiors. */
126 int ops_already_pushed = target_is_pushed (ops);
127 struct cleanup *back_to = NULL;
129 if (! ops_already_pushed)
131 /* Clear possible core file with its process_stratum. */
133 back_to = make_cleanup_unpush_target (ops);
136 pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
139 if (! ops_already_pushed)
140 discard_cleanups (back_to);
142 /* On some targets, there must be some explicit synchronization
143 between the parent and child processes after the debugger
144 forks, and before the child execs the debuggee program. This
145 call basically gives permission for the child to exec. */
147 target_acknowledge_created_inferior (pid);
149 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
150 be 1 or 2 depending on whether we're starting without or with a
152 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
154 /* On some targets, there must be some explicit actions taken after
155 the inferior has been started up. */
156 target_post_startup_inferior (pid_to_ptid (pid));
159 #ifdef PT_GET_PROCESS_STATE
162 inf_ptrace_post_startup_inferior (ptid_t pid)
166 /* Set the initial event mask. */
167 memset (&pe, 0, sizeof pe);
168 pe.pe_set_event |= PTRACE_FORK;
169 if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
170 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
171 perror_with_name (("ptrace"));
176 /* Clean up a rotting corpse of an inferior after it died. */
179 inf_ptrace_mourn_inferior (struct target_ops *ops)
183 /* Wait just one more time to collect the inferior's exit status.
184 Do not check whether this succeeds though, since we may be
185 dealing with a process that we attached to. Such a process will
186 only report its exit status to its original parent. */
187 waitpid (ptid_get_pid (inferior_ptid), &status, 0);
189 generic_mourn_inferior ();
191 if (!have_inferiors ())
195 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
196 be chatty about it. */
199 inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
203 struct inferior *inf;
205 /* Do not change either targets above or the same target if already present.
206 The reason is the target stack is shared across multiple inferiors. */
207 int ops_already_pushed = target_is_pushed (ops);
208 struct cleanup *back_to = NULL;
210 pid = parse_pid_to_attach (args);
212 if (pid == getpid ()) /* Trying to masturbate? */
213 error (_("I refuse to debug myself!"));
215 if (! ops_already_pushed)
217 /* target_pid_to_str already uses the target. Also clear possible core
218 file with its process_stratum. */
220 back_to = make_cleanup_unpush_target (ops);
225 exec_file = get_exec_file (0);
228 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
229 target_pid_to_str (pid_to_ptid (pid)));
231 printf_unfiltered (_("Attaching to %s\n"),
232 target_pid_to_str (pid_to_ptid (pid)));
234 gdb_flush (gdb_stdout);
239 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
241 perror_with_name (("ptrace"));
243 error (_("This system does not support attaching to a process"));
246 inf = current_inferior ();
247 inferior_appeared (inf, pid);
248 inf->attach_flag = 1;
249 inferior_ptid = pid_to_ptid (pid);
251 /* Always add a main thread. If some target extends the ptrace
252 target, it should decorate the ptid later with more info. */
253 add_thread_silent (inferior_ptid);
255 if (! ops_already_pushed)
256 discard_cleanups (back_to);
259 #ifdef PT_GET_PROCESS_STATE
262 inf_ptrace_post_attach (int pid)
266 /* Set the initial event mask. */
267 memset (&pe, 0, sizeof pe);
268 pe.pe_set_event |= PTRACE_FORK;
269 if (ptrace (PT_SET_EVENT_MASK, pid,
270 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
271 perror_with_name (("ptrace"));
276 /* Detach from the inferior, optionally passing it the signal
277 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
280 inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)
282 pid_t pid = ptid_get_pid (inferior_ptid);
287 char *exec_file = get_exec_file (0);
290 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
291 target_pid_to_str (pid_to_ptid (pid)));
292 gdb_flush (gdb_stdout);
298 /* We'd better not have left any breakpoints in the program or it'll
299 die when it hits one. Also note that this may only work if we
300 previously attached to the inferior. It *might* work if we
301 started the process ourselves. */
303 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
305 perror_with_name (("ptrace"));
307 error (_("This system does not support detaching from a process"));
310 inferior_ptid = null_ptid;
311 detach_inferior (pid);
313 if (!have_inferiors ())
317 /* Kill the inferior. */
320 inf_ptrace_kill (struct target_ops *ops)
322 pid_t pid = ptid_get_pid (inferior_ptid);
328 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
329 waitpid (pid, &status, 0);
331 target_mourn_inferior ();
334 /* Stop the inferior. */
337 inf_ptrace_stop (ptid_t ptid)
339 /* Send a SIGINT to the process group. This acts just like the user
340 typed a ^C on the controlling terminal. Note that using a
341 negative process number in kill() is a System V-ism. The proper
342 BSD interface is killpg(). However, all modern BSDs support the
343 System V interface too. */
344 kill (-inferior_process_group (), SIGINT);
347 /* Resume execution of thread PTID, or all threads if PTID is -1. If
348 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
352 inf_ptrace_resume (struct target_ops *ops,
353 ptid_t ptid, int step, enum target_signal signal)
355 pid_t pid = ptid_get_pid (ptid);
359 /* Resume all threads. Traditionally ptrace() only supports
360 single-threaded processes, so simply resume the inferior. */
361 pid = ptid_get_pid (inferior_ptid);
363 if (catch_syscall_enabled () > 0)
364 request = PT_SYSCALL;
366 request = PT_CONTINUE;
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, int options)
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;