void add_target_sections (void *owner, struct target_section *sections, struct target_section *sections_end) { int count; struct target_section_table *table = current_target_sections; count = sections_end - sections; if (count > 0) { int space = resize_section_table (table, count); int i; for (i = 0; i < count; ++i) { table->sections[space + i] = sections[i]; table->sections[space + i].owner = owner; } /* If these are the first file sections we can provide memory from, push the file_stratum target. */ if (!target_is_pushed (&exec_ops)) push_target (&exec_ops); } }
static void inf_ptrace_create_inferior (struct target_ops *ops, char *exec_file, char *allargs, char **env, int from_tty) { int pid; /* 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 = make_cleanup (null_cleanup, NULL); if (! ops_already_pushed) { /* Clear possible core file with its process_stratum. */ push_target (ops); make_cleanup_unpush_target (ops); } pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL, NULL, NULL, NULL); discard_cleanups (back_to); startup_inferior (START_INFERIOR_TRAPS_EXPECTED); /* On some targets, there must be some explicit actions taken after the inferior has been started up. */ target_post_startup_inferior (pid_to_ptid (pid)); }
static void inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty) { char *exec_file; pid_t pid; struct inferior *inf; /* 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; pid = parse_pid_to_attach (args); if (pid == getpid ()) /* Trying to m********e? */ 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); if (exec_file) printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, target_pid_to_str (pid_to_ptid (pid))); else printf_unfiltered (_("Attaching to %s\n"), target_pid_to_str (pid_to_ptid (pid))); gdb_flush (gdb_stdout); } #ifdef PT_ATTACH errno = 0; ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0); if (errno != 0) perror_with_name (("ptrace")); #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); /* 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); }
void inf_ptrace_target::create_inferior (const char *exec_file, const std::string &allargs, char **env, int from_tty) { pid_t pid; ptid_t ptid; /* 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 (this); target_unpush_up unpusher; if (! ops_already_pushed) { /* Clear possible core file with its process_stratum. */ push_target (this); unpusher.reset (this); } pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL, NULL, NULL, NULL); ptid = ptid_t (pid); /* We have something that executes now. We'll be running through the shell at this point (if startup-with-shell is true), but the pid shouldn't change. */ add_thread_silent (ptid); unpusher.release (); gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED); /* On some targets, there must be some explicit actions taken after the inferior has been started up. */ target_post_startup_inferior (ptid); }
void inf_ptrace_target::attach (const char *args, int from_tty) { char *exec_file; pid_t pid; struct inferior *inf; /* 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 (this); pid = parse_pid_to_attach (args); if (pid == getpid ()) /* Trying to m********e? */ error (_("I refuse to debug myself!")); target_unpush_up unpusher; if (! ops_already_pushed) { /* target_pid_to_str already uses the target. Also clear possible core file with its process_stratum. */ push_target (this); unpusher.reset (this); } if (from_tty) { exec_file = get_exec_file (0); if (exec_file) printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, target_pid_to_str (ptid_t (pid))); else printf_unfiltered (_("Attaching to %s\n"), target_pid_to_str (ptid_t (pid))); gdb_flush (gdb_stdout); } #ifdef PT_ATTACH errno = 0; ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0); if (errno != 0) perror_with_name (("ptrace")); #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 = ptid_t (pid); /* Always add a main thread. If some target extends the ptrace target, it should decorate the ptid later with more info. */ thread_info *thr = add_thread_silent (inferior_ptid); /* Don't consider the thread stopped until we've processed its initial SIGSTOP stop. */ set_executing (thr->ptid, true); unpusher.release (); }