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
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-child.h"
36 #include "gdbthread.h"
38 /* HACK: Save the ptrace ops returned by inf_ptrace_target. */
39 static struct target_ops *ptrace_ops_hack;
42 #ifdef PT_GET_PROCESS_STATE
45 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
49 struct thread_info *last_tp = NULL;
51 /* FIXME: kettenis/20050720: This stuff should really be passed as
52 an argument by our caller. */
55 struct target_waitstatus status;
57 get_last_target_status (&ptid, &status);
58 gdb_assert (status.kind == TARGET_WAITKIND_FORKED);
60 pid = ptid_get_pid (ptid);
61 last_tp = find_thread_pid (ptid);
64 if (ptrace (PT_GET_PROCESS_STATE, pid,
65 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
66 perror_with_name (("ptrace"));
68 gdb_assert (pe.pe_report_event == PTRACE_FORK);
69 fpid = pe.pe_other_pid;
73 /* Copy user stepping state to the new inferior thread. */
74 struct breakpoint *step_resume_breakpoint = last_tp->step_resume_breakpoint;
75 CORE_ADDR step_range_start = last_tp->step_range_start;
76 CORE_ADDR step_range_end = last_tp->step_range_end;
77 struct frame_id step_frame_id = last_tp->step_frame_id;
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 detach_breakpoints (pid);
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);
100 tp = add_thread_silent (inferior_ptid);
102 tp->step_resume_breakpoint = step_resume_breakpoint;
103 tp->step_range_start = step_range_start;
104 tp->step_range_end = step_range_end;
105 tp->step_frame_id = step_frame_id;
107 /* Reset breakpoints in the child as appropriate. */
108 follow_inferior_reset_breakpoints ();
112 inferior_ptid = pid_to_ptid (pid);
113 detach_breakpoints (fpid);
115 if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
116 perror_with_name (("ptrace"));
117 detach_inferior (pid);
123 #endif /* PT_GET_PROCESS_STATE */
126 /* Prepare to be traced. */
131 /* "Trace me, Dr. Memory!" */
132 ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
135 /* Start tracing PID. */
138 inf_ptrace_him (int pid)
140 push_target (ptrace_ops_hack);
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 /* Start a new inferior Unix child process. EXEC_FILE is the file to
160 run, ALLARGS is a string containing the arguments to the program.
161 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
165 inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env,
168 fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him,
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 (void)
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 unpush_target (ptrace_ops_hack);
203 generic_mourn_inferior ();
206 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
207 be chatty about it. */
210 inf_ptrace_attach (char *args, int from_tty)
215 struct inferior *inf;
218 error_no_arg (_("process-id to attach"));
221 pid = strtol (args, &dummy, 0);
222 /* Some targets don't set errno on errors, grrr! */
223 if (pid == 0 && args == dummy)
224 error (_("Illegal process-id: %s."), args);
226 if (pid == getpid ()) /* Trying to masturbate? */
227 error (_("I refuse to debug myself!"));
231 exec_file = get_exec_file (0);
234 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
235 target_pid_to_str (pid_to_ptid (pid)));
237 printf_unfiltered (_("Attaching to %s\n"),
238 target_pid_to_str (pid_to_ptid (pid)));
240 gdb_flush (gdb_stdout);
245 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
247 perror_with_name (("ptrace"));
249 error (_("This system does not support attaching to a process"));
252 inferior_ptid = pid_to_ptid (pid);
254 inf = add_inferior (pid);
255 inf->attach_flag = 1;
257 /* Always add a main thread. If some target extends the ptrace
258 target, it should decorate the ptid later with more info. */
259 add_thread_silent (inferior_ptid);
261 push_target (ptrace_ops_hack);
264 #ifdef PT_GET_PROCESS_STATE
267 inf_ptrace_post_attach (int pid)
271 /* Set the initial event mask. */
272 memset (&pe, 0, sizeof pe);
273 pe.pe_set_event |= PTRACE_FORK;
274 if (ptrace (PT_SET_EVENT_MASK, pid,
275 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
276 perror_with_name (("ptrace"));
281 /* Detach from the inferior, optionally passing it the signal
282 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
285 inf_ptrace_detach (char *args, int from_tty)
287 pid_t pid = ptid_get_pid (inferior_ptid);
292 char *exec_file = get_exec_file (0);
295 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
296 target_pid_to_str (pid_to_ptid (pid)));
297 gdb_flush (gdb_stdout);
303 /* We'd better not have left any breakpoints in the program or it'll
304 die when it hits one. Also note that this may only work if we
305 previously attached to the inferior. It *might* work if we
306 started the process ourselves. */
308 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
310 perror_with_name (("ptrace"));
312 error (_("This system does not support detaching from a process"));
315 inferior_ptid = null_ptid;
316 detach_inferior (pid);
317 unpush_target (ptrace_ops_hack);
320 /* Kill the inferior. */
323 inf_ptrace_kill (void)
325 pid_t pid = ptid_get_pid (inferior_ptid);
331 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
332 waitpid (pid, &status, 0);
334 target_mourn_inferior ();
337 /* Stop the inferior. */
340 inf_ptrace_stop (ptid_t ptid)
342 /* Send a SIGINT to the process group. This acts just like the user
343 typed a ^C on the controlling terminal. Note that using a
344 negative process number in kill() is a System V-ism. The proper
345 BSD interface is killpg(). However, all modern BSDs support the
346 System V interface too. */
347 kill (-inferior_process_group, SIGINT);
350 /* Resume execution of thread PTID, or all threads if PTID is -1. If
351 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
355 inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal)
357 pid_t pid = ptid_get_pid (ptid);
358 int request = PT_CONTINUE;
361 /* Resume all threads. Traditionally ptrace() only supports
362 single-threaded processes, so simply resume the inferior. */
363 pid = ptid_get_pid (inferior_ptid);
367 /* If this system does not support PT_STEP, a higher level
368 function will have called single_step() to transmute the step
369 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 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_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_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
392 int status, save_errno;
401 pid = waitpid (ptid_get_pid (ptid), &status, 0);
404 while (pid == -1 && errno == EINTR);
407 clear_sigint_trap ();
411 fprintf_unfiltered (gdb_stderr,
412 _("Child process unexpectedly missing: %s.\n"),
413 safe_strerror (save_errno));
415 /* Claim it exited with unknown signal. */
416 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
417 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
418 return minus_one_ptid;
421 /* Ignore terminated detached child processes. */
422 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
427 #ifdef PT_GET_PROCESS_STATE
428 if (WIFSTOPPED (status))
433 if (ptrace (PT_GET_PROCESS_STATE, pid,
434 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
435 perror_with_name (("ptrace"));
437 switch (pe.pe_report_event)
440 ourstatus->kind = TARGET_WAITKIND_FORKED;
441 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
443 /* Make sure the other end of the fork is stopped too. */
444 fpid = waitpid (pe.pe_other_pid, &status, 0);
446 perror_with_name (("waitpid"));
448 if (ptrace (PT_GET_PROCESS_STATE, fpid,
449 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
450 perror_with_name (("ptrace"));
452 gdb_assert (pe.pe_report_event == PTRACE_FORK);
453 gdb_assert (pe.pe_other_pid == pid);
454 if (fpid == ptid_get_pid (inferior_ptid))
456 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
457 return pid_to_ptid (fpid);
460 return pid_to_ptid (pid);
465 store_waitstatus (ourstatus, status);
466 return pid_to_ptid (pid);
469 /* Attempt a transfer all LEN bytes starting at OFFSET between the
470 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
471 Return the number of bytes actually transferred. */
474 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
475 const char *annex, gdb_byte *readbuf,
476 const gdb_byte *writebuf,
477 ULONGEST offset, LONGEST len)
479 pid_t pid = ptid_get_pid (inferior_ptid);
483 case TARGET_OBJECT_MEMORY:
485 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
486 request that promises to be much more efficient in reading
487 and writing data in the traced process's address space. */
489 struct ptrace_io_desc piod;
491 /* NOTE: We assume that there are no distinct address spaces
492 for instruction and data. However, on OpenBSD 3.9 and
493 later, PIOD_WRITE_D doesn't allow changing memory that's
494 mapped read-only. Since most code segments will be
495 read-only, using PIOD_WRITE_D will prevent us from
496 inserting breakpoints, so we use PIOD_WRITE_I instead. */
497 piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
498 piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
499 piod.piod_offs = (void *) (long) offset;
503 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
504 /* Return the actual number of bytes read or written. */
505 return piod.piod_len;
506 /* If the PT_IO request is somehow not supported, fallback on
507 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
508 to indicate failure. */
516 PTRACE_TYPE_RET word;
517 gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
519 ULONGEST rounded_offset;
522 /* Round the start offset down to the next long word
524 rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
526 /* Since ptrace will transfer a single word starting at that
527 rounded_offset the partial_len needs to be adjusted down to
528 that (remember this function only does a single transfer).
529 Should the required length be even less, adjust it down
531 partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
532 if (partial_len > len)
537 /* If OFFSET:PARTIAL_LEN is smaller than
538 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
539 be needed. Read in the entire word. */
540 if (rounded_offset < offset
541 || (offset + partial_len
542 < rounded_offset + sizeof (PTRACE_TYPE_RET)))
543 /* Need part of initial word -- fetch it. */
544 buffer.word = ptrace (PT_READ_I, pid,
545 (PTRACE_TYPE_ARG3)(uintptr_t)
548 /* Copy data to be written over corresponding part of
550 memcpy (buffer.byte + (offset - rounded_offset),
551 writebuf, partial_len);
554 ptrace (PT_WRITE_D, pid,
555 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
559 /* Using the appropriate one (I or D) is necessary for
560 Gould NP1, at least. */
562 ptrace (PT_WRITE_I, pid,
563 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
573 buffer.word = ptrace (PT_READ_I, pid,
574 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
578 /* Copy appropriate bytes out of the buffer. */
579 memcpy (readbuf, buffer.byte + (offset - rounded_offset),
586 case TARGET_OBJECT_UNWIND_TABLE:
589 case TARGET_OBJECT_AUXV:
592 case TARGET_OBJECT_WCOOKIE:
600 /* Return non-zero if the thread specified by PTID is alive. */
603 inf_ptrace_thread_alive (ptid_t ptid)
605 /* ??? Is kill the right way to do this? */
606 return (kill (ptid_get_pid (ptid), 0) != -1);
609 /* Print status information about what we're accessing. */
612 inf_ptrace_files_info (struct target_ops *ignore)
614 struct inferior *inf = current_inferior ();
616 printf_filtered (_("\tUsing the running image of %s %s.\n"),
617 inf->attach_flag ? "attached" : "child",
618 target_pid_to_str (inferior_ptid));
621 /* Create a prototype ptrace target. The client can override it with
625 inf_ptrace_target (void)
627 struct target_ops *t = inf_child_target ();
629 t->to_attach = inf_ptrace_attach;
630 t->to_detach = inf_ptrace_detach;
631 t->to_resume = inf_ptrace_resume;
632 t->to_wait = inf_ptrace_wait;
633 t->to_files_info = inf_ptrace_files_info;
634 t->to_kill = inf_ptrace_kill;
635 t->to_create_inferior = inf_ptrace_create_inferior;
636 #ifdef PT_GET_PROCESS_STATE
637 t->to_follow_fork = inf_ptrace_follow_fork;
638 t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
639 t->to_post_attach = inf_ptrace_post_attach;
641 t->to_mourn_inferior = inf_ptrace_mourn_inferior;
642 t->to_thread_alive = inf_ptrace_thread_alive;
643 t->to_pid_to_str = normal_pid_to_str;
644 t->to_stop = inf_ptrace_stop;
645 t->to_xfer_partial = inf_ptrace_xfer_partial;
652 /* Pointer to a function that returns the offset within the user area
653 where a particular register is stored. */
654 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
656 /* Fetch register REGNUM from the inferior. */
659 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
661 struct gdbarch *gdbarch = get_regcache_arch (regcache);
664 PTRACE_TYPE_RET *buf;
667 /* This isn't really an address, but ptrace thinks of it as one. */
668 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
669 if (addr == (CORE_ADDR)-1
670 || gdbarch_cannot_fetch_register (gdbarch, regnum))
672 regcache_raw_supply (regcache, regnum, NULL);
676 /* Cater for systems like GNU/Linux, that implement threads as
677 separate processes. */
678 pid = ptid_get_lwp (inferior_ptid);
680 pid = ptid_get_pid (inferior_ptid);
682 size = register_size (gdbarch, regnum);
683 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
686 /* Read the register contents from the inferior a chunk at a time. */
687 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
690 buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
692 error (_("Couldn't read register %s (#%d): %s."),
693 gdbarch_register_name (gdbarch, regnum),
694 regnum, safe_strerror (errno));
696 addr += sizeof (PTRACE_TYPE_RET);
698 regcache_raw_supply (regcache, regnum, buf);
701 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
702 for all registers. */
705 inf_ptrace_fetch_registers (struct regcache *regcache, int regnum)
709 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
711 inf_ptrace_fetch_register (regcache, regnum);
713 inf_ptrace_fetch_register (regcache, regnum);
716 /* Store register REGNUM into the inferior. */
719 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
721 struct gdbarch *gdbarch = get_regcache_arch (regcache);
724 PTRACE_TYPE_RET *buf;
727 /* This isn't really an address, but ptrace thinks of it as one. */
728 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
729 if (addr == (CORE_ADDR)-1
730 || gdbarch_cannot_store_register (gdbarch, regnum))
733 /* Cater for systems like GNU/Linux, that implement threads as
734 separate processes. */
735 pid = ptid_get_lwp (inferior_ptid);
737 pid = ptid_get_pid (inferior_ptid);
739 size = register_size (gdbarch, regnum);
740 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
743 /* Write the register contents into the inferior a chunk at a time. */
744 regcache_raw_collect (regcache, regnum, buf);
745 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
748 ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
750 error (_("Couldn't write register %s (#%d): %s."),
751 gdbarch_register_name (gdbarch, regnum),
752 regnum, safe_strerror (errno));
754 addr += sizeof (PTRACE_TYPE_RET);
758 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
759 this for all registers. */
762 inf_ptrace_store_registers (struct regcache *regcache, int regnum)
766 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
768 inf_ptrace_store_register (regcache, regnum);
770 inf_ptrace_store_register (regcache, regnum);
773 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
774 a function returning the offset within the user area where a
775 particular register is stored. */
778 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
779 (struct gdbarch *, int, int))
781 struct target_ops *t = inf_ptrace_target();
783 gdb_assert (register_u_offset);
784 inf_ptrace_register_u_offset = register_u_offset;
785 t->to_fetch_registers = inf_ptrace_fetch_registers;
786 t->to_store_registers = inf_ptrace_store_registers;