X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Finf-ptrace.c;h=b5e1744b1faf6721473f23373e8854f2ccf902c1;hb=8fbca658f0643a6c3d5b61840351ae70e5bf2db6;hp=7a9957ba68ff45f6831d2e2d19fdc0f3af185ef5;hpb=a9762ec78a53fbe9209fe1654db42df0cd328d50;p=binutils-gdb.git diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c index 7a9957ba68f..b5e1744b1fa 100644 --- a/gdb/inf-ptrace.c +++ b/gdb/inf-ptrace.c @@ -1,7 +1,7 @@ /* Low-level child interface to ptrace. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, - 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007 + 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. This file is part of GDB. @@ -23,20 +23,20 @@ #include "command.h" #include "inferior.h" #include "inflow.h" +#include "terminal.h" #include "gdbcore.h" #include "regcache.h" -#include "gdb_stdint.h" #include "gdb_assert.h" #include "gdb_string.h" #include "gdb_ptrace.h" #include "gdb_wait.h" #include +#include "inf-ptrace.h" #include "inf-child.h" +#include "gdbthread.h" -/* HACK: Save the ptrace ops returned by inf_ptrace_target. */ -static struct target_ops *ptrace_ops_hack; #ifdef PT_GET_PROCESS_STATE @@ -47,17 +47,7 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child) pid_t pid, fpid; ptrace_state_t pe; - /* FIXME: kettenis/20050720: This stuff should really be passed as - an argument by our caller. */ - { - ptid_t ptid; - struct target_waitstatus status; - - get_last_target_status (&ptid, &status); - gdb_assert (status.kind == TARGET_WAITKIND_FORKED); - - pid = ptid_get_pid (ptid); - } + pid = ptid_get_pid (inferior_ptid); if (ptrace (PT_GET_PROCESS_STATE, pid, (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) @@ -68,19 +58,37 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child) if (follow_child) { - inferior_ptid = pid_to_ptid (fpid); - detach_breakpoints (pid); + struct inferior *parent_inf, *child_inf; + struct thread_info *tp; - /* Reset breakpoints in the child as appropriate. */ - follow_inferior_reset_breakpoints (); + parent_inf = find_inferior_pid (pid); + + /* Add the child. */ + child_inf = add_inferior (fpid); + child_inf->attach_flag = parent_inf->attach_flag; + copy_terminal_info (child_inf, parent_inf); + child_inf->pspace = parent_inf->pspace; + child_inf->aspace = parent_inf->aspace; + + /* Before detaching from the parent, remove all breakpoints from + it. */ + remove_breakpoints (); if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1) perror_with_name (("ptrace")); + + /* Switch inferior_ptid out of the parent's way. */ + inferior_ptid = pid_to_ptid (fpid); + + /* Delete the parent. */ + detach_inferior (pid); + + add_thread_silent (inferior_ptid); } else { - inferior_ptid = pid_to_ptid (pid); - detach_breakpoints (fpid); + /* Breakpoints have already been detached from the child by + infrun.c. */ if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1) perror_with_name (("ptrace")); @@ -101,19 +109,35 @@ inf_ptrace_me (void) ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0); } -/* Start tracing PID. */ +/* Start a new inferior Unix child process. EXEC_FILE is the file to + run, ALLARGS is a string containing the arguments to the program. + ENV is the environment vector to pass. If FROM_TTY is non-zero, be + chatty about it. */ static void -inf_ptrace_him (int pid) +inf_ptrace_create_inferior (struct target_ops *ops, + char *exec_file, char *allargs, char **env, + int from_tty) { - push_target (ptrace_ops_hack); + int pid; - /* On some targets, there must be some explicit synchronization - between the parent and child processes after the debugger - forks, and before the child execs the debuggee program. This - call basically gives permission for the child to exec. */ + /* Do not change either targets above or the same target if already present. + The reason is the target stack is shared across multiple inferiors. */ + int ops_already_pushed = target_is_pushed (ops); + struct cleanup *back_to = NULL; + + if (! ops_already_pushed) + { + /* Clear possible core file with its process_stratum. */ + push_target (ops); + back_to = make_cleanup_unpush_target (ops); + } - target_acknowledge_created_inferior (pid); + pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL, + NULL, NULL); + + if (! ops_already_pushed) + discard_cleanups (back_to); /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will be 1 or 2 depending on whether we're starting without or with a @@ -125,19 +149,6 @@ inf_ptrace_him (int pid) target_post_startup_inferior (pid_to_ptid (pid)); } -/* Start a new inferior Unix child process. EXEC_FILE is the file to - run, ALLARGS is a string containing the arguments to the program. - ENV is the environment vector to pass. If FROM_TTY is non-zero, be - chatty about it. */ - -static void -inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env, - int from_tty) -{ - fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him, - NULL, NULL); -} - #ifdef PT_GET_PROCESS_STATE static void @@ -158,7 +169,7 @@ inf_ptrace_post_startup_inferior (ptid_t pid) /* Clean up a rotting corpse of an inferior after it died. */ static void -inf_ptrace_mourn_inferior (void) +inf_ptrace_mourn_inferior (struct target_ops *ops) { int status; @@ -168,32 +179,40 @@ inf_ptrace_mourn_inferior (void) only report its exit status to its original parent. */ waitpid (ptid_get_pid (inferior_ptid), &status, 0); - unpush_target (ptrace_ops_hack); generic_mourn_inferior (); + + if (!have_inferiors ()) + unpush_target (ops); } /* Attach to the process specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */ static void -inf_ptrace_attach (char *args, int from_tty) +inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty) { char *exec_file; pid_t pid; - char *dummy; + struct inferior *inf; - if (!args) - error_no_arg (_("process-id to attach")); + /* Do not change either targets above or the same target if already present. + The reason is the target stack is shared across multiple inferiors. */ + int ops_already_pushed = target_is_pushed (ops); + struct cleanup *back_to = NULL; - dummy = args; - pid = strtol (args, &dummy, 0); - /* Some targets don't set errno on errors, grrr! */ - if (pid == 0 && args == dummy) - error (_("Illegal process-id: %s."), args); + pid = parse_pid_to_attach (args); if (pid == getpid ()) /* Trying to masturbate? */ error (_("I refuse to debug myself!")); + if (! ops_already_pushed) + { + /* target_pid_to_str already uses the target. Also clear possible core + file with its process_stratum. */ + push_target (ops); + back_to = make_cleanup_unpush_target (ops); + } + if (from_tty) { exec_file = get_exec_file (0); @@ -213,13 +232,21 @@ inf_ptrace_attach (char *args, int from_tty) ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0); if (errno != 0) perror_with_name (("ptrace")); - attach_flag = 1; #else error (_("This system does not support attaching to a process")); #endif + inf = current_inferior (); + inferior_appeared (inf, pid); + inf->attach_flag = 1; inferior_ptid = pid_to_ptid (pid); - push_target (ptrace_ops_hack); + + /* Always add a main thread. If some target extends the ptrace + target, it should decorate the ptid later with more info. */ + add_thread_silent (inferior_ptid); + + if (! ops_already_pushed) + discard_cleanups (back_to); } #ifdef PT_GET_PROCESS_STATE @@ -243,7 +270,7 @@ inf_ptrace_post_attach (int pid) specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */ static void -inf_ptrace_detach (char *args, int from_tty) +inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty) { pid_t pid = ptid_get_pid (inferior_ptid); int sig = 0; @@ -269,19 +296,21 @@ inf_ptrace_detach (char *args, int from_tty) ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig); if (errno != 0) perror_with_name (("ptrace")); - attach_flag = 0; #else error (_("This system does not support detaching from a process")); #endif inferior_ptid = null_ptid; - unpush_target (ptrace_ops_hack); + detach_inferior (pid); + + if (!have_inferiors ()) + unpush_target (ops); } /* Kill the inferior. */ static void -inf_ptrace_kill (void) +inf_ptrace_kill (struct target_ops *ops) { pid_t pid = ptid_get_pid (inferior_ptid); int status; @@ -298,14 +327,14 @@ inf_ptrace_kill (void) /* Stop the inferior. */ static void -inf_ptrace_stop (void) +inf_ptrace_stop (ptid_t ptid) { /* Send a SIGINT to the process group. This acts just like the user typed a ^C on the controlling terminal. Note that using a negative process number in kill() is a System V-ism. The proper BSD interface is killpg(). However, all modern BSDs support the System V interface too. */ - kill (-inferior_process_group, SIGINT); + kill (-inferior_process_group (), SIGINT); } /* Resume execution of thread PTID, or all threads if PTID is -1. If @@ -313,16 +342,22 @@ inf_ptrace_stop (void) that signal. */ static void -inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal) +inf_ptrace_resume (struct target_ops *ops, + ptid_t ptid, int step, enum target_signal signal) { pid_t pid = ptid_get_pid (ptid); - int request = PT_CONTINUE; + int request; if (pid == -1) /* Resume all threads. Traditionally ptrace() only supports single-threaded processes, so simply resume the inferior. */ pid = ptid_get_pid (inferior_ptid); + if (catch_syscall_enabled () > 0) + request = PT_SYSCALL; + else + request = PT_CONTINUE; + if (step) { /* If this system does not support PT_STEP, a higher level @@ -347,7 +382,8 @@ inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal) the status in *OURSTATUS. */ static ptid_t -inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) +inf_ptrace_wait (struct target_ops *ops, + ptid_t ptid, struct target_waitstatus *ourstatus, int options) { pid_t pid; int status, save_errno; @@ -355,7 +391,6 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) do { set_sigint_trap (); - set_sigio_trap (); do { @@ -364,7 +399,6 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) } while (pid == -1 && errno == EINTR); - clear_sigio_trap (); clear_sigint_trap (); if (pid == -1) @@ -376,7 +410,7 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) /* Claim it exited with unknown signal. */ ourstatus->kind = TARGET_WAITKIND_SIGNALLED; ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; - return minus_one_ptid; + return inferior_ptid; } /* Ignore terminated detached child processes. */ @@ -399,7 +433,7 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) { case PTRACE_FORK: ourstatus->kind = TARGET_WAITKIND_FORKED; - ourstatus->value.related_pid = pe.pe_other_pid; + ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); /* Make sure the other end of the fork is stopped too. */ fpid = waitpid (pe.pe_other_pid, &status, 0); @@ -414,7 +448,7 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) gdb_assert (pe.pe_other_pid == pid); if (fpid == ptid_get_pid (inferior_ptid)) { - ourstatus->value.related_pid = pe.pe_other_pid; + ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); return pid_to_ptid (fpid); } @@ -561,7 +595,7 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, /* Return non-zero if the thread specified by PTID is alive. */ static int -inf_ptrace_thread_alive (ptid_t ptid) +inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid) { /* ??? Is kill the right way to do this? */ return (kill (ptid_get_pid (ptid), 0) != -1); @@ -572,11 +606,19 @@ inf_ptrace_thread_alive (ptid_t ptid) static void inf_ptrace_files_info (struct target_ops *ignore) { + struct inferior *inf = current_inferior (); + printf_filtered (_("\tUsing the running image of %s %s.\n"), - attach_flag ? "attached" : "child", + inf->attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid)); } +static char * +inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid) +{ + return normal_pid_to_str (ptid); +} + /* Create a prototype ptrace target. The client can override it with local methods. */ @@ -599,11 +641,10 @@ inf_ptrace_target (void) #endif t->to_mourn_inferior = inf_ptrace_mourn_inferior; t->to_thread_alive = inf_ptrace_thread_alive; - t->to_pid_to_str = normal_pid_to_str; + t->to_pid_to_str = inf_ptrace_pid_to_str; t->to_stop = inf_ptrace_stop; t->to_xfer_partial = inf_ptrace_xfer_partial; - ptrace_ops_hack = t; return t; } @@ -617,15 +658,16 @@ static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int); static void inf_ptrace_fetch_register (struct regcache *regcache, int regnum) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int pid, i; /* This isn't really an address, but ptrace thinks of it as one. */ - addr = inf_ptrace_register_u_offset (current_gdbarch, regnum, 0); + addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0); if (addr == (CORE_ADDR)-1 - || gdbarch_cannot_fetch_register (current_gdbarch, regnum)) + || gdbarch_cannot_fetch_register (gdbarch, regnum)) { regcache_raw_supply (regcache, regnum, NULL); return; @@ -637,7 +679,7 @@ inf_ptrace_fetch_register (struct regcache *regcache, int regnum) if (pid == 0) pid = ptid_get_pid (inferior_ptid); - size = register_size (current_gdbarch, regnum); + size = register_size (gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); @@ -648,7 +690,7 @@ inf_ptrace_fetch_register (struct regcache *regcache, int regnum) buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0); if (errno != 0) error (_("Couldn't read register %s (#%d): %s."), - gdbarch_register_name (current_gdbarch, regnum), + gdbarch_register_name (gdbarch, regnum), regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); @@ -660,10 +702,13 @@ inf_ptrace_fetch_register (struct regcache *regcache, int regnum) for all registers. */ static void -inf_ptrace_fetch_registers (struct regcache *regcache, int regnum) +inf_ptrace_fetch_registers (struct target_ops *ops, + struct regcache *regcache, int regnum) { if (regnum == -1) - for (regnum = 0; regnum < gdbarch_num_regs (current_gdbarch); regnum++) + for (regnum = 0; + regnum < gdbarch_num_regs (get_regcache_arch (regcache)); + regnum++) inf_ptrace_fetch_register (regcache, regnum); else inf_ptrace_fetch_register (regcache, regnum); @@ -674,15 +719,16 @@ inf_ptrace_fetch_registers (struct regcache *regcache, int regnum) static void inf_ptrace_store_register (const struct regcache *regcache, int regnum) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int pid, i; /* This isn't really an address, but ptrace thinks of it as one. */ - addr = inf_ptrace_register_u_offset (current_gdbarch, regnum, 1); + addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1); if (addr == (CORE_ADDR)-1 - || gdbarch_cannot_store_register (current_gdbarch, regnum)) + || gdbarch_cannot_store_register (gdbarch, regnum)) return; /* Cater for systems like GNU/Linux, that implement threads as @@ -691,7 +737,7 @@ inf_ptrace_store_register (const struct regcache *regcache, int regnum) if (pid == 0) pid = ptid_get_pid (inferior_ptid); - size = register_size (current_gdbarch, regnum); + size = register_size (gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); @@ -703,7 +749,7 @@ inf_ptrace_store_register (const struct regcache *regcache, int regnum) ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), - gdbarch_register_name (current_gdbarch, regnum), + gdbarch_register_name (gdbarch, regnum), regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); @@ -713,11 +759,14 @@ inf_ptrace_store_register (const struct regcache *regcache, int regnum) /* Store register REGNUM back into the inferior. If REGNUM is -1, do this for all registers. */ -void -inf_ptrace_store_registers (struct regcache *regcache, int regnum) +static void +inf_ptrace_store_registers (struct target_ops *ops, + struct regcache *regcache, int regnum) { if (regnum == -1) - for (regnum = 0; regnum < gdbarch_num_regs (current_gdbarch); regnum++) + for (regnum = 0; + regnum < gdbarch_num_regs (get_regcache_arch (regcache)); + regnum++) inf_ptrace_store_register (regcache, regnum); else inf_ptrace_store_register (regcache, regnum);