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);
115 /* Breakpoints have already been detached from the child by
118 if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
119 perror_with_name (("ptrace"));
120 detach_inferior (pid);
126 #endif /* PT_GET_PROCESS_STATE */
129 /* Prepare to be traced. */
134 /* "Trace me, Dr. Memory!" */
135 ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
138 /* Start a new inferior Unix child process. EXEC_FILE is the file to
139 run, ALLARGS is a string containing the arguments to the program.
140 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
144 inf_ptrace_create_inferior (struct target_ops *ops,
145 char *exec_file, char *allargs, char **env,
150 pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
155 /* On some targets, there must be some explicit synchronization
156 between the parent and child processes after the debugger
157 forks, and before the child execs the debuggee program. This
158 call basically gives permission for the child to exec. */
160 target_acknowledge_created_inferior (pid);
162 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
163 be 1 or 2 depending on whether we're starting without or with a
165 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
167 /* On some targets, there must be some explicit actions taken after
168 the inferior has been started up. */
169 target_post_startup_inferior (pid_to_ptid (pid));
172 #ifdef PT_GET_PROCESS_STATE
175 inf_ptrace_post_startup_inferior (ptid_t pid)
179 /* Set the initial event mask. */
180 memset (&pe, 0, sizeof pe);
181 pe.pe_set_event |= PTRACE_FORK;
182 if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
183 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
184 perror_with_name (("ptrace"));
189 /* Clean up a rotting corpse of an inferior after it died. */
192 inf_ptrace_mourn_inferior (struct target_ops *ops)
196 /* Wait just one more time to collect the inferior's exit status.
197 Do not check whether this succeeds though, since we may be
198 dealing with a process that we attached to. Such a process will
199 only report its exit status to its original parent. */
200 waitpid (ptid_get_pid (inferior_ptid), &status, 0);
202 generic_mourn_inferior ();
204 if (!have_inferiors ())
208 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
209 be chatty about it. */
212 inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
217 struct inferior *inf;
220 error_no_arg (_("process-id to attach"));
223 pid = strtol (args, &dummy, 0);
224 /* Some targets don't set errno on errors, grrr! */
225 if (pid == 0 && args == dummy)
226 error (_("Illegal process-id: %s."), args);
228 if (pid == getpid ()) /* Trying to masturbate? */
229 error (_("I refuse to debug myself!"));
233 exec_file = get_exec_file (0);
236 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
237 target_pid_to_str (pid_to_ptid (pid)));
239 printf_unfiltered (_("Attaching to %s\n"),
240 target_pid_to_str (pid_to_ptid (pid)));
242 gdb_flush (gdb_stdout);
247 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
249 perror_with_name (("ptrace"));
251 error (_("This system does not support attaching to a process"));
254 inferior_ptid = pid_to_ptid (pid);
256 inf = add_inferior (pid);
257 inf->attach_flag = 1;
259 /* Always add a main thread. If some target extends the ptrace
260 target, it should decorate the ptid later with more info. */
261 add_thread_silent (inferior_ptid);
266 #ifdef PT_GET_PROCESS_STATE
269 inf_ptrace_post_attach (int pid)
273 /* Set the initial event mask. */
274 memset (&pe, 0, sizeof pe);
275 pe.pe_set_event |= PTRACE_FORK;
276 if (ptrace (PT_SET_EVENT_MASK, pid,
277 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
278 perror_with_name (("ptrace"));
283 /* Detach from the inferior, optionally passing it the signal
284 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
287 inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)
289 pid_t pid = ptid_get_pid (inferior_ptid);
294 char *exec_file = get_exec_file (0);
297 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
298 target_pid_to_str (pid_to_ptid (pid)));
299 gdb_flush (gdb_stdout);
305 /* We'd better not have left any breakpoints in the program or it'll
306 die when it hits one. Also note that this may only work if we
307 previously attached to the inferior. It *might* work if we
308 started the process ourselves. */
310 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
312 perror_with_name (("ptrace"));
314 error (_("This system does not support detaching from a process"));
317 inferior_ptid = null_ptid;
318 detach_inferior (pid);
320 if (!have_inferiors ())
324 /* Kill the inferior. */
327 inf_ptrace_kill (struct target_ops *ops)
329 pid_t pid = ptid_get_pid (inferior_ptid);
335 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
336 waitpid (pid, &status, 0);
338 target_mourn_inferior ();
341 /* Stop the inferior. */
344 inf_ptrace_stop (ptid_t ptid)
346 /* Send a SIGINT to the process group. This acts just like the user
347 typed a ^C on the controlling terminal. Note that using a
348 negative process number in kill() is a System V-ism. The proper
349 BSD interface is killpg(). However, all modern BSDs support the
350 System V interface too. */
351 kill (-inferior_process_group (), SIGINT);
354 /* Resume execution of thread PTID, or all threads if PTID is -1. If
355 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
359 inf_ptrace_resume (struct target_ops *ops,
360 ptid_t ptid, int step, enum target_signal signal)
362 pid_t pid = ptid_get_pid (ptid);
363 int request = PT_CONTINUE;
366 /* Resume all threads. Traditionally ptrace() only supports
367 single-threaded processes, so simply resume the inferior. */
368 pid = ptid_get_pid (inferior_ptid);
372 /* If this system does not support PT_STEP, a higher level
373 function will have called single_step() to transmute the step
374 request into a continue request (by setting breakpoints on
375 all possible successor instructions), so we don't have to
376 worry about that here. */
380 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
381 where it was. If GDB wanted it to start some other way, we have
382 already written a new program counter value to the child. */
384 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
386 perror_with_name (("ptrace"));
389 /* Wait for the child specified by PTID to do something. Return the
390 process ID of the child, or MINUS_ONE_PTID in case of error; store
391 the status in *OURSTATUS. */
394 inf_ptrace_wait (struct target_ops *ops,
395 ptid_t ptid, struct target_waitstatus *ourstatus)
398 int status, save_errno;
406 pid = waitpid (ptid_get_pid (ptid), &status, 0);
409 while (pid == -1 && errno == EINTR);
411 clear_sigint_trap ();
415 fprintf_unfiltered (gdb_stderr,
416 _("Child process unexpectedly missing: %s.\n"),
417 safe_strerror (save_errno));
419 /* Claim it exited with unknown signal. */
420 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
421 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
422 return inferior_ptid;
425 /* Ignore terminated detached child processes. */
426 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
431 #ifdef PT_GET_PROCESS_STATE
432 if (WIFSTOPPED (status))
437 if (ptrace (PT_GET_PROCESS_STATE, pid,
438 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
439 perror_with_name (("ptrace"));
441 switch (pe.pe_report_event)
444 ourstatus->kind = TARGET_WAITKIND_FORKED;
445 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
447 /* Make sure the other end of the fork is stopped too. */
448 fpid = waitpid (pe.pe_other_pid, &status, 0);
450 perror_with_name (("waitpid"));
452 if (ptrace (PT_GET_PROCESS_STATE, fpid,
453 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
454 perror_with_name (("ptrace"));
456 gdb_assert (pe.pe_report_event == PTRACE_FORK);
457 gdb_assert (pe.pe_other_pid == pid);
458 if (fpid == ptid_get_pid (inferior_ptid))
460 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
461 return pid_to_ptid (fpid);
464 return pid_to_ptid (pid);
469 store_waitstatus (ourstatus, status);
470 return pid_to_ptid (pid);
473 /* Attempt a transfer all LEN bytes starting at OFFSET between the
474 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
475 Return the number of bytes actually transferred. */
478 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
479 const char *annex, gdb_byte *readbuf,
480 const gdb_byte *writebuf,
481 ULONGEST offset, LONGEST len)
483 pid_t pid = ptid_get_pid (inferior_ptid);
487 case TARGET_OBJECT_MEMORY:
489 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
490 request that promises to be much more efficient in reading
491 and writing data in the traced process's address space. */
493 struct ptrace_io_desc piod;
495 /* NOTE: We assume that there are no distinct address spaces
496 for instruction and data. However, on OpenBSD 3.9 and
497 later, PIOD_WRITE_D doesn't allow changing memory that's
498 mapped read-only. Since most code segments will be
499 read-only, using PIOD_WRITE_D will prevent us from
500 inserting breakpoints, so we use PIOD_WRITE_I instead. */
501 piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
502 piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
503 piod.piod_offs = (void *) (long) offset;
507 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
508 /* Return the actual number of bytes read or written. */
509 return piod.piod_len;
510 /* If the PT_IO request is somehow not supported, fallback on
511 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
512 to indicate failure. */
520 PTRACE_TYPE_RET word;
521 gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
523 ULONGEST rounded_offset;
526 /* Round the start offset down to the next long word
528 rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
530 /* Since ptrace will transfer a single word starting at that
531 rounded_offset the partial_len needs to be adjusted down to
532 that (remember this function only does a single transfer).
533 Should the required length be even less, adjust it down
535 partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
536 if (partial_len > len)
541 /* If OFFSET:PARTIAL_LEN is smaller than
542 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
543 be needed. Read in the entire word. */
544 if (rounded_offset < offset
545 || (offset + partial_len
546 < rounded_offset + sizeof (PTRACE_TYPE_RET)))
547 /* Need part of initial word -- fetch it. */
548 buffer.word = ptrace (PT_READ_I, pid,
549 (PTRACE_TYPE_ARG3)(uintptr_t)
552 /* Copy data to be written over corresponding part of
554 memcpy (buffer.byte + (offset - rounded_offset),
555 writebuf, partial_len);
558 ptrace (PT_WRITE_D, pid,
559 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
563 /* Using the appropriate one (I or D) is necessary for
564 Gould NP1, at least. */
566 ptrace (PT_WRITE_I, pid,
567 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
577 buffer.word = ptrace (PT_READ_I, pid,
578 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
582 /* Copy appropriate bytes out of the buffer. */
583 memcpy (readbuf, buffer.byte + (offset - rounded_offset),
590 case TARGET_OBJECT_UNWIND_TABLE:
593 case TARGET_OBJECT_AUXV:
596 case TARGET_OBJECT_WCOOKIE:
604 /* Return non-zero if the thread specified by PTID is alive. */
607 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
609 /* ??? Is kill the right way to do this? */
610 return (kill (ptid_get_pid (ptid), 0) != -1);
613 /* Print status information about what we're accessing. */
616 inf_ptrace_files_info (struct target_ops *ignore)
618 struct inferior *inf = current_inferior ();
620 printf_filtered (_("\tUsing the running image of %s %s.\n"),
621 inf->attach_flag ? "attached" : "child",
622 target_pid_to_str (inferior_ptid));
626 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
628 return normal_pid_to_str (ptid);
631 /* Create a prototype ptrace target. The client can override it with
635 inf_ptrace_target (void)
637 struct target_ops *t = inf_child_target ();
639 t->to_attach = inf_ptrace_attach;
640 t->to_detach = inf_ptrace_detach;
641 t->to_resume = inf_ptrace_resume;
642 t->to_wait = inf_ptrace_wait;
643 t->to_files_info = inf_ptrace_files_info;
644 t->to_kill = inf_ptrace_kill;
645 t->to_create_inferior = inf_ptrace_create_inferior;
646 #ifdef PT_GET_PROCESS_STATE
647 t->to_follow_fork = inf_ptrace_follow_fork;
648 t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
649 t->to_post_attach = inf_ptrace_post_attach;
651 t->to_mourn_inferior = inf_ptrace_mourn_inferior;
652 t->to_thread_alive = inf_ptrace_thread_alive;
653 t->to_pid_to_str = inf_ptrace_pid_to_str;
654 t->to_stop = inf_ptrace_stop;
655 t->to_xfer_partial = inf_ptrace_xfer_partial;
661 /* Pointer to a function that returns the offset within the user area
662 where a particular register is stored. */
663 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
665 /* Fetch register REGNUM from the inferior. */
668 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
670 struct gdbarch *gdbarch = get_regcache_arch (regcache);
673 PTRACE_TYPE_RET *buf;
676 /* This isn't really an address, but ptrace thinks of it as one. */
677 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
678 if (addr == (CORE_ADDR)-1
679 || gdbarch_cannot_fetch_register (gdbarch, regnum))
681 regcache_raw_supply (regcache, regnum, NULL);
685 /* Cater for systems like GNU/Linux, that implement threads as
686 separate processes. */
687 pid = ptid_get_lwp (inferior_ptid);
689 pid = ptid_get_pid (inferior_ptid);
691 size = register_size (gdbarch, regnum);
692 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
695 /* Read the register contents from the inferior a chunk at a time. */
696 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
699 buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
701 error (_("Couldn't read register %s (#%d): %s."),
702 gdbarch_register_name (gdbarch, regnum),
703 regnum, safe_strerror (errno));
705 addr += sizeof (PTRACE_TYPE_RET);
707 regcache_raw_supply (regcache, regnum, buf);
710 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
711 for all registers. */
714 inf_ptrace_fetch_registers (struct target_ops *ops,
715 struct regcache *regcache, int regnum)
719 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
721 inf_ptrace_fetch_register (regcache, regnum);
723 inf_ptrace_fetch_register (regcache, regnum);
726 /* Store register REGNUM into the inferior. */
729 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
731 struct gdbarch *gdbarch = get_regcache_arch (regcache);
734 PTRACE_TYPE_RET *buf;
737 /* This isn't really an address, but ptrace thinks of it as one. */
738 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
739 if (addr == (CORE_ADDR)-1
740 || gdbarch_cannot_store_register (gdbarch, regnum))
743 /* Cater for systems like GNU/Linux, that implement threads as
744 separate processes. */
745 pid = ptid_get_lwp (inferior_ptid);
747 pid = ptid_get_pid (inferior_ptid);
749 size = register_size (gdbarch, regnum);
750 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
753 /* Write the register contents into the inferior a chunk at a time. */
754 regcache_raw_collect (regcache, regnum, buf);
755 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
758 ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
760 error (_("Couldn't write register %s (#%d): %s."),
761 gdbarch_register_name (gdbarch, regnum),
762 regnum, safe_strerror (errno));
764 addr += sizeof (PTRACE_TYPE_RET);
768 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
769 this for all registers. */
772 inf_ptrace_store_registers (struct target_ops *ops,
773 struct regcache *regcache, int regnum)
777 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
779 inf_ptrace_store_register (regcache, regnum);
781 inf_ptrace_store_register (regcache, regnum);
784 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
785 a function returning the offset within the user area where a
786 particular register is stored. */
789 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
790 (struct gdbarch *, int, int))
792 struct target_ops *t = inf_ptrace_target();
794 gdb_assert (register_u_offset);
795 inf_ptrace_register_u_offset = register_u_offset;
796 t->to_fetch_registers = inf_ptrace_fetch_registers;
797 t->to_store_registers = inf_ptrace_store_registers;