static void
e7000_create_inferior (char *execfile, char *args, char **env)
{
int entry_pt;
if (args && *args)
error ("Can't pass arguments to remote E7000DEBUG process");
if (execfile == 0 || exec_bfd == 0)
error ("No executable file specified");
entry_pt = (int) bfd_get_start_address (exec_bfd);
#ifdef CREATE_INFERIOR_HOOK
CREATE_INFERIOR_HOOK (0); /* No process-ID */
#endif
/* The "process" (board) is already stopped awaiting our commands, and
the program is already downloaded. We just set its PC and go. */
clear_proceed_status ();
/* Tell wait_for_inferior that we've started a new process. */
init_wait_for_inferior ();
/* Set up the "saved terminal modes" of the inferior
based on what modes we are starting it with. */
target_terminal_init ();
/* Install inferior's terminal modes. */
target_terminal_inferior ();
/* insert_step_breakpoint (); FIXME, do we need this? */
proceed ((CORE_ADDR) entry_pt, -1, 0); /* Let 'er rip... */
}
void
startup_inferior (int ntraps)
{
int pending_execs = ntraps;
int terminal_initted = 0;
/* The process was started by the fork that created it, but it will
have stopped one instruction after execing the shell. Here we
must get it up to actual execution of the real program. */
clear_proceed_status ();
init_wait_for_inferior ();
inferior_ignoring_leading_exec_events =
target_reported_exec_events_per_exec_call () - 1;
while (1)
{
/* Make wait_for_inferior be quiet. */
stop_soon = STOP_QUIETLY;
wait_for_inferior ();
if (stop_signal != TARGET_SIGNAL_TRAP)
{
/* Let shell child handle its own signals in its own way.
FIXME: what if child has exited? Must exit loop
somehow. */
resume (0, stop_signal);
}
else
{
/* We handle SIGTRAP, however; it means child did an exec. */
if (!terminal_initted)
{
/* Now that the child has exec'd we know it has already
set its process group. On POSIX systems, tcsetpgrp
will fail with EPERM if we try it before the child's
setpgid. */
/* Set up the "saved terminal modes" of the inferior
based on what modes we are starting it with. */
target_terminal_init ();
/* Install inferior's terminal modes. */
target_terminal_inferior ();
terminal_initted = 1;
}
if (--pending_execs == 0)
break;
resume (0, TARGET_SIGNAL_0); /* Just make it go on. */
}
}
stop_soon = NO_STOP_QUIETLY;
}
void
startup_inferior (int ntraps)
{
int pending_execs = ntraps;
int terminal_initted = 0;
ptid_t resume_ptid;
if (target_supports_multi_process ())
resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
else
resume_ptid = minus_one_ptid;
/* The process was started by the fork that created it, but it will
have stopped one instruction after execing the shell. Here we
must get it up to actual execution of the real program. */
if (exec_wrapper)
pending_execs++;
while (1)
{
enum target_signal resume_signal = TARGET_SIGNAL_0;
ptid_t event_ptid;
struct target_waitstatus ws;
memset (&ws, 0, sizeof (ws));
event_ptid = target_wait (resume_ptid, &ws, 0);
if (ws.kind == TARGET_WAITKIND_IGNORE)
/* The inferior didn't really stop, keep waiting. */
continue;
switch (ws.kind)
{
case TARGET_WAITKIND_SPURIOUS:
case TARGET_WAITKIND_LOADED:
case TARGET_WAITKIND_FORKED:
case TARGET_WAITKIND_VFORKED:
case TARGET_WAITKIND_SYSCALL_ENTRY:
case TARGET_WAITKIND_SYSCALL_RETURN:
/* Ignore gracefully during startup of the inferior. */
switch_to_thread (event_ptid);
break;
case TARGET_WAITKIND_SIGNALLED:
target_terminal_ours ();
target_mourn_inferior ();
error (_("During startup program terminated with signal %s, %s."),
target_signal_to_name (ws.value.sig),
target_signal_to_string (ws.value.sig));
return;
case TARGET_WAITKIND_EXITED:
target_terminal_ours ();
target_mourn_inferior ();
if (ws.value.integer)
error (_("During startup program exited with code %d."),
ws.value.integer);
else
error (_("During startup program exited normally."));
return;
case TARGET_WAITKIND_EXECD:
/* Handle EXEC signals as if they were SIGTRAP signals. */
xfree (ws.value.execd_pathname);
resume_signal = TARGET_SIGNAL_TRAP;
switch_to_thread (event_ptid);
break;
case TARGET_WAITKIND_STOPPED:
resume_signal = ws.value.sig;
switch_to_thread (event_ptid);
break;
}
if (resume_signal != TARGET_SIGNAL_TRAP)
{
/* Let shell child handle its own signals in its own way. */
target_resume (resume_ptid, 0, resume_signal);
}
else
{
/* We handle SIGTRAP, however; it means child did an exec. */
if (!terminal_initted)
{
/* Now that the child has exec'd we know it has already
set its process group. On POSIX systems, tcsetpgrp
will fail with EPERM if we try it before the child's
setpgid. */
/* Set up the "saved terminal modes" of the inferior
based on what modes we are starting it with. */
target_terminal_init ();
/* Install inferior's terminal modes. */
target_terminal_inferior ();
terminal_initted = 1;
}
if (--pending_execs == 0)
break;
/* Just make it go on. */
target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
}
}
/* Mark all threads non-executing. */
set_executing (resume_ptid, 0);
}
static void
haiku_init_child_debugging (thread_id threadID, bool debugThread)
{
thread_info threadInfo;
status_t result;
port_id nubPort;
// get a thread info
result = get_thread_info(threadID, &threadInfo);
if (result != B_OK)
error("Thread with ID %ld not found: %s", threadID, strerror(result));
// init our team debug structure
sTeamDebugInfo.team = threadInfo.team;
sTeamDebugInfo.debugger_port = -1;
sTeamDebugInfo.context.nub_port = -1;
sTeamDebugInfo.context.reply_port = -1;
sTeamDebugInfo.threads = NULL;
sTeamDebugInfo.events.head = NULL;
sTeamDebugInfo.events.tail = NULL;
// create the debugger port
sTeamDebugInfo.debugger_port = create_port(10, "gdb debug");
if (sTeamDebugInfo.debugger_port < 0) {
error("Failed to create debugger port: %s",
strerror(sTeamDebugInfo.debugger_port));
}
// install ourselves as the team debugger
nubPort = install_team_debugger(sTeamDebugInfo.team,
sTeamDebugInfo.debugger_port);
if (nubPort < 0) {
error("Failed to install ourselves as debugger for team %ld: %s",
sTeamDebugInfo.team, strerror(nubPort));
}
// get the nub thread
{
team_info teamInfo;
result = get_team_info(sTeamDebugInfo.team, &teamInfo);
if (result != B_OK) {
error("Failed to get info for team %ld: %s\n",
sTeamDebugInfo.team, strerror(result));
}
sTeamDebugInfo.nub_thread = teamInfo.debugger_nub_thread;
}
// init the debug context
result = init_debug_context(&sTeamDebugInfo.context, sTeamDebugInfo.team,
nubPort);
if (result != B_OK) {
error("Failed to init debug context for team %ld: %s\n",
sTeamDebugInfo.team, strerror(result));
}
// start debugging the thread
if (debugThread) {
result = debug_thread(threadID);
if (result != B_OK) {
error("Failed to start debugging thread %ld: %s", threadID,
strerror(result));
}
}
// set the team debug flags
{
debug_nub_set_team_flags message;
message.flags = B_TEAM_DEBUG_SIGNALS /*| B_TEAM_DEBUG_PRE_SYSCALL
| B_TEAM_DEBUG_POST_SYSCALL*/ | B_TEAM_DEBUG_TEAM_CREATION
| B_TEAM_DEBUG_THREADS | B_TEAM_DEBUG_IMAGES;
// TODO: We probably don't need all events
haiku_send_debugger_message(&sTeamDebugInfo,
B_DEBUG_MESSAGE_SET_TEAM_FLAGS, &message, sizeof(message), NULL, 0);
}
// the fun can start: push the target and init the rest
push_target(sHaikuTarget);
haiku_init_thread_list(&sTeamDebugInfo);
haiku_init_image_list(&sTeamDebugInfo);
disable_breakpoints_in_shlibs (1);
// child_clear_solibs ();
// TODO: Implement? Do we need this?
clear_proceed_status ();
init_wait_for_inferior ();
target_terminal_init ();
target_terminal_inferior ();
}
