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/>. */
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)
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;
78 struct inferior *parent_inf, *child_inf;
79 struct thread_info *tp;
81 /* Otherwise, deleting the parent would get rid of this
83 last_tp->step_resume_breakpoint = NULL;
85 parent_inf = find_inferior_pid (pid);
88 child_inf = add_inferior (fpid);
89 child_inf->attach_flag = parent_inf->attach_flag;
90 copy_terminal_info (child_inf, parent_inf);
92 /* Before detaching from the parent, remove all breakpoints from
94 remove_breakpoints ();
96 if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
97 perror_with_name (("ptrace"));
99 /* Switch inferior_ptid out of the parent's way. */
100 inferior_ptid = pid_to_ptid (fpid);
102 /* Delete the parent. */
103 detach_inferior (pid);
105 tp = add_thread_silent (inferior_ptid);
107 tp->step_resume_breakpoint = step_resume_breakpoint;
108 tp->step_range_start = step_range_start;
109 tp->step_range_end = step_range_end;
110 tp->step_frame_id = step_frame_id;
112 /* Reset breakpoints in the child as appropriate. */
113 follow_inferior_reset_breakpoints ();
117 inferior_ptid = pid_to_ptid (pid);
119 /* Breakpoints have already been detached from the child by
122 if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
123 perror_with_name (("ptrace"));
124 detach_inferior (pid);
130 #endif /* PT_GET_PROCESS_STATE */
133 /* Prepare to be traced. */
138 /* "Trace me, Dr. Memory!" */
139 ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
142 /* Start a new inferior Unix child process. EXEC_FILE is the file to
143 run, ALLARGS is a string containing the arguments to the program.
144 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
148 inf_ptrace_create_inferior (struct target_ops *ops,
149 char *exec_file, char *allargs, char **env,
154 pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
159 /* On some targets, there must be some explicit synchronization
160 between the parent and child processes after the debugger
161 forks, and before the child execs the debuggee program. This
162 call basically gives permission for the child to exec. */
164 target_acknowledge_created_inferior (pid);
166 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
167 be 1 or 2 depending on whether we're starting without or with a
169 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
171 /* On some targets, there must be some explicit actions taken after
172 the inferior has been started up. */
173 target_post_startup_inferior (pid_to_ptid (pid));
176 #ifdef PT_GET_PROCESS_STATE
179 inf_ptrace_post_startup_inferior (ptid_t pid)
183 /* Set the initial event mask. */
184 memset (&pe, 0, sizeof pe);
185 pe.pe_set_event |= PTRACE_FORK;
186 if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
187 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
188 perror_with_name (("ptrace"));
193 /* Clean up a rotting corpse of an inferior after it died. */
196 inf_ptrace_mourn_inferior (struct target_ops *ops)
200 /* Wait just one more time to collect the inferior's exit status.
201 Do not check whether this succeeds though, since we may be
202 dealing with a process that we attached to. Such a process will
203 only report its exit status to its original parent. */
204 waitpid (ptid_get_pid (inferior_ptid), &status, 0);
206 generic_mourn_inferior ();
208 if (!have_inferiors ())
212 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
213 be chatty about it. */
216 inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
221 struct inferior *inf;
224 error_no_arg (_("process-id to attach"));
227 pid = strtol (args, &dummy, 0);
228 /* Some targets don't set errno on errors, grrr! */
229 if (pid == 0 && args == dummy)
230 error (_("Illegal process-id: %s."), args);
232 if (pid == getpid ()) /* Trying to masturbate? */
233 error (_("I refuse to debug myself!"));
237 exec_file = get_exec_file (0);
240 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
241 target_pid_to_str (pid_to_ptid (pid)));
243 printf_unfiltered (_("Attaching to %s\n"),
244 target_pid_to_str (pid_to_ptid (pid)));
246 gdb_flush (gdb_stdout);
251 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
253 perror_with_name (("ptrace"));
255 error (_("This system does not support attaching to a process"));
258 inferior_ptid = pid_to_ptid (pid);
260 inf = add_inferior (pid);
261 inf->attach_flag = 1;
263 /* Always add a main thread. If some target extends the ptrace
264 target, it should decorate the ptid later with more info. */
265 add_thread_silent (inferior_ptid);
270 #ifdef PT_GET_PROCESS_STATE
273 inf_ptrace_post_attach (int pid)
277 /* Set the initial event mask. */
278 memset (&pe, 0, sizeof pe);
279 pe.pe_set_event |= PTRACE_FORK;
280 if (ptrace (PT_SET_EVENT_MASK, pid,
281 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
282 perror_with_name (("ptrace"));
287 /* Detach from the inferior, optionally passing it the signal
288 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
291 inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)
293 pid_t pid = ptid_get_pid (inferior_ptid);
298 char *exec_file = get_exec_file (0);
301 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
302 target_pid_to_str (pid_to_ptid (pid)));
303 gdb_flush (gdb_stdout);
309 /* We'd better not have left any breakpoints in the program or it'll
310 die when it hits one. Also note that this may only work if we
311 previously attached to the inferior. It *might* work if we
312 started the process ourselves. */
314 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
316 perror_with_name (("ptrace"));
318 error (_("This system does not support detaching from a process"));
321 inferior_ptid = null_ptid;
322 detach_inferior (pid);
324 if (!have_inferiors ())
328 /* Kill the inferior. */
331 inf_ptrace_kill (struct target_ops *ops)
333 pid_t pid = ptid_get_pid (inferior_ptid);
339 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
340 waitpid (pid, &status, 0);
342 target_mourn_inferior ();
345 /* Stop the inferior. */
348 inf_ptrace_stop (ptid_t ptid)
350 /* Send a SIGINT to the process group. This acts just like the user
351 typed a ^C on the controlling terminal. Note that using a
352 negative process number in kill() is a System V-ism. The proper
353 BSD interface is killpg(). However, all modern BSDs support the
354 System V interface too. */
355 kill (-inferior_process_group (), SIGINT);
358 /* Resume execution of thread PTID, or all threads if PTID is -1. If
359 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
363 inf_ptrace_resume (struct target_ops *ops,
364 ptid_t ptid, int step, enum target_signal signal)
366 pid_t pid = ptid_get_pid (ptid);
367 int request = PT_CONTINUE;
370 /* Resume all threads. Traditionally ptrace() only supports
371 single-threaded processes, so simply resume the inferior. */
372 pid = ptid_get_pid (inferior_ptid);
376 /* If this system does not support PT_STEP, a higher level
377 function will have called single_step() to transmute the step
378 request into a continue request (by setting breakpoints on
379 all possible successor instructions), so we don't have to
380 worry about that here. */
384 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
385 where it was. If GDB wanted it to start some other way, we have
386 already written a new program counter value to the child. */
388 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
390 perror_with_name (("ptrace"));
393 /* Wait for the child specified by PTID to do something. Return the
394 process ID of the child, or MINUS_ONE_PTID in case of error; store
395 the status in *OURSTATUS. */
398 inf_ptrace_wait (struct target_ops *ops,
399 ptid_t ptid, struct target_waitstatus *ourstatus)
402 int status, save_errno;
410 pid = waitpid (ptid_get_pid (ptid), &status, 0);
413 while (pid == -1 && errno == EINTR);
415 clear_sigint_trap ();
419 fprintf_unfiltered (gdb_stderr,
420 _("Child process unexpectedly missing: %s.\n"),
421 safe_strerror (save_errno));
423 /* Claim it exited with unknown signal. */
424 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
425 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
426 return inferior_ptid;
429 /* Ignore terminated detached child processes. */
430 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
435 #ifdef PT_GET_PROCESS_STATE
436 if (WIFSTOPPED (status))
441 if (ptrace (PT_GET_PROCESS_STATE, pid,
442 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
443 perror_with_name (("ptrace"));
445 switch (pe.pe_report_event)
448 ourstatus->kind = TARGET_WAITKIND_FORKED;
449 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
451 /* Make sure the other end of the fork is stopped too. */
452 fpid = waitpid (pe.pe_other_pid, &status, 0);
454 perror_with_name (("waitpid"));
456 if (ptrace (PT_GET_PROCESS_STATE, fpid,
457 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
458 perror_with_name (("ptrace"));
460 gdb_assert (pe.pe_report_event == PTRACE_FORK);
461 gdb_assert (pe.pe_other_pid == pid);
462 if (fpid == ptid_get_pid (inferior_ptid))
464 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
465 return pid_to_ptid (fpid);
468 return pid_to_ptid (pid);
473 store_waitstatus (ourstatus, status);
474 return pid_to_ptid (pid);
477 /* Attempt a transfer all LEN bytes starting at OFFSET between the
478 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
479 Return the number of bytes actually transferred. */
482 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
483 const char *annex, gdb_byte *readbuf,
484 const gdb_byte *writebuf,
485 ULONGEST offset, LONGEST len)
487 pid_t pid = ptid_get_pid (inferior_ptid);
491 case TARGET_OBJECT_MEMORY:
493 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
494 request that promises to be much more efficient in reading
495 and writing data in the traced process's address space. */
497 struct ptrace_io_desc piod;
499 /* NOTE: We assume that there are no distinct address spaces
500 for instruction and data. However, on OpenBSD 3.9 and
501 later, PIOD_WRITE_D doesn't allow changing memory that's
502 mapped read-only. Since most code segments will be
503 read-only, using PIOD_WRITE_D will prevent us from
504 inserting breakpoints, so we use PIOD_WRITE_I instead. */
505 piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
506 piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
507 piod.piod_offs = (void *) (long) offset;
511 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
512 /* Return the actual number of bytes read or written. */
513 return piod.piod_len;
514 /* If the PT_IO request is somehow not supported, fallback on
515 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
516 to indicate failure. */
524 PTRACE_TYPE_RET word;
525 gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
527 ULONGEST rounded_offset;
530 /* Round the start offset down to the next long word
532 rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
534 /* Since ptrace will transfer a single word starting at that
535 rounded_offset the partial_len needs to be adjusted down to
536 that (remember this function only does a single transfer).
537 Should the required length be even less, adjust it down
539 partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
540 if (partial_len > len)
545 /* If OFFSET:PARTIAL_LEN is smaller than
546 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
547 be needed. Read in the entire word. */
548 if (rounded_offset < offset
549 || (offset + partial_len
550 < rounded_offset + sizeof (PTRACE_TYPE_RET)))
551 /* Need part of initial word -- fetch it. */
552 buffer.word = ptrace (PT_READ_I, pid,
553 (PTRACE_TYPE_ARG3)(uintptr_t)
556 /* Copy data to be written over corresponding part of
558 memcpy (buffer.byte + (offset - rounded_offset),
559 writebuf, partial_len);
562 ptrace (PT_WRITE_D, pid,
563 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
567 /* Using the appropriate one (I or D) is necessary for
568 Gould NP1, at least. */
570 ptrace (PT_WRITE_I, pid,
571 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
581 buffer.word = ptrace (PT_READ_I, pid,
582 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
586 /* Copy appropriate bytes out of the buffer. */
587 memcpy (readbuf, buffer.byte + (offset - rounded_offset),
594 case TARGET_OBJECT_UNWIND_TABLE:
597 case TARGET_OBJECT_AUXV:
600 case TARGET_OBJECT_WCOOKIE:
608 /* Return non-zero if the thread specified by PTID is alive. */
611 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
613 /* ??? Is kill the right way to do this? */
614 return (kill (ptid_get_pid (ptid), 0) != -1);
617 /* Print status information about what we're accessing. */
620 inf_ptrace_files_info (struct target_ops *ignore)
622 struct inferior *inf = current_inferior ();
624 printf_filtered (_("\tUsing the running image of %s %s.\n"),
625 inf->attach_flag ? "attached" : "child",
626 target_pid_to_str (inferior_ptid));
630 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
632 return normal_pid_to_str (ptid);
635 /* Create a prototype ptrace target. The client can override it with
639 inf_ptrace_target (void)
641 struct target_ops *t = inf_child_target ();
643 t->to_attach = inf_ptrace_attach;
644 t->to_detach = inf_ptrace_detach;
645 t->to_resume = inf_ptrace_resume;
646 t->to_wait = inf_ptrace_wait;
647 t->to_files_info = inf_ptrace_files_info;
648 t->to_kill = inf_ptrace_kill;
649 t->to_create_inferior = inf_ptrace_create_inferior;
650 #ifdef PT_GET_PROCESS_STATE
651 t->to_follow_fork = inf_ptrace_follow_fork;
652 t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
653 t->to_post_attach = inf_ptrace_post_attach;
655 t->to_mourn_inferior = inf_ptrace_mourn_inferior;
656 t->to_thread_alive = inf_ptrace_thread_alive;
657 t->to_pid_to_str = inf_ptrace_pid_to_str;
658 t->to_stop = inf_ptrace_stop;
659 t->to_xfer_partial = inf_ptrace_xfer_partial;
665 /* Pointer to a function that returns the offset within the user area
666 where a particular register is stored. */
667 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
669 /* Fetch register REGNUM from the inferior. */
672 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
674 struct gdbarch *gdbarch = get_regcache_arch (regcache);
677 PTRACE_TYPE_RET *buf;
680 /* This isn't really an address, but ptrace thinks of it as one. */
681 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
682 if (addr == (CORE_ADDR)-1
683 || gdbarch_cannot_fetch_register (gdbarch, regnum))
685 regcache_raw_supply (regcache, regnum, NULL);
689 /* Cater for systems like GNU/Linux, that implement threads as
690 separate processes. */
691 pid = ptid_get_lwp (inferior_ptid);
693 pid = ptid_get_pid (inferior_ptid);
695 size = register_size (gdbarch, regnum);
696 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
699 /* Read the register contents from the inferior a chunk at a time. */
700 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
703 buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
705 error (_("Couldn't read register %s (#%d): %s."),
706 gdbarch_register_name (gdbarch, regnum),
707 regnum, safe_strerror (errno));
709 addr += sizeof (PTRACE_TYPE_RET);
711 regcache_raw_supply (regcache, regnum, buf);
714 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
715 for all registers. */
718 inf_ptrace_fetch_registers (struct target_ops *ops,
719 struct regcache *regcache, int regnum)
723 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
725 inf_ptrace_fetch_register (regcache, regnum);
727 inf_ptrace_fetch_register (regcache, regnum);
730 /* Store register REGNUM into the inferior. */
733 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
735 struct gdbarch *gdbarch = get_regcache_arch (regcache);
738 PTRACE_TYPE_RET *buf;
741 /* This isn't really an address, but ptrace thinks of it as one. */
742 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
743 if (addr == (CORE_ADDR)-1
744 || gdbarch_cannot_store_register (gdbarch, regnum))
747 /* Cater for systems like GNU/Linux, that implement threads as
748 separate processes. */
749 pid = ptid_get_lwp (inferior_ptid);
751 pid = ptid_get_pid (inferior_ptid);
753 size = register_size (gdbarch, regnum);
754 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
757 /* Write the register contents into the inferior a chunk at a time. */
758 regcache_raw_collect (regcache, regnum, buf);
759 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
762 ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
764 error (_("Couldn't write register %s (#%d): %s."),
765 gdbarch_register_name (gdbarch, regnum),
766 regnum, safe_strerror (errno));
768 addr += sizeof (PTRACE_TYPE_RET);
772 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
773 this for all registers. */
776 inf_ptrace_store_registers (struct target_ops *ops,
777 struct regcache *regcache, int regnum)
781 regnum < gdbarch_num_regs (get_regcache_arch (regcache));
783 inf_ptrace_store_register (regcache, regnum);
785 inf_ptrace_store_register (regcache, regnum);
788 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
789 a function returning the offset within the user area where a
790 particular register is stored. */
793 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
794 (struct gdbarch *, int, int))
796 struct target_ops *t = inf_ptrace_target();
798 gdb_assert (register_u_offset);
799 inf_ptrace_register_u_offset = register_u_offset;
800 t->to_fetch_registers = inf_ptrace_fetch_registers;
801 t->to_store_registers = inf_ptrace_store_registers;