debugserver_launch_info.SetMonitorProcessCallback(std::bind(MonitorDebugserverProcess, this, _1, _2, _3, _4),

ProcessGDBRemote::MonitorDebugserverProcess(ProcessGDBRemote *process, lldb::pid_t debugserver_pid,

// The baton is a "ProcessGDBRemote *". Now this class might be gone

// and might not exist anymore, so we need to carefully try to get the

// target for this process first since we have a race condition when

// we are done running between getting the notice that the inferior

// process has died and the debugserver that was debugging this process.

// In our test suite, we are also continually running process after

// process, so we must be very careful to make sure:

// 1 - process object hasn't been deleted already

// 2 - that a new process object hasn't been recreated in its place

// Get a shared pointer to the target that has a matching process pointer.

// This target could be gone, or the target could already have a new process

// object inside of it

TargetSP target_sp (Debugger::FindTargetWithProcess(process));

log->Printf("ProcessGDBRemote::%s(process=%p, pid=%" PRIu64 ", signo=%i (0x%x), exit_status=%i)", __FUNCTION__,

process, debugserver_pid, signo, signo, exit_status);

if (target_sp)

{

// We found a process in a target that matches, but another thread

// might be in the process of launching a new process that will

// soon replace it, so get a shared pointer to the process so we

// can keep it alive.

ProcessSP process_sp (target_sp->GetProcessSP());

// Now we have a shared pointer to the process that can't go away on us

// so we now make sure it was the same as the one passed in, and also make

// sure that our previous "process *" didn't get deleted and have a new

// "process *" created in its place with the same pointer. To verify this

// we make sure the process has our debugserver process ID. If we pass all

// of these tests, then we are sure that this process is the one we were

// looking for.

if (process_sp && process == process_sp.get() && process->m_debugserver_pid == debugserver_pid)

// Sleep for a half a second to make sure our inferior process has

// time to set its exit status before we set it incorrectly when

// both the debugserver and the inferior process shut down.

usleep (500000);

// If our process hasn't yet exited, debugserver might have died.

// If the process did exit, the we are reaping it.

const StateType state = process->GetState();

if (process->m_debugserver_pid != LLDB_INVALID_PROCESS_ID &&

state != eStateInvalid &&

state != eStateUnloaded &&

state != eStateExited &&

state != eStateDetached)

{

char error_str[1024];

if (signo)

{

const char *signal_cstr = process->GetUnixSignals()->GetSignalAsCString(signo);

if (signal_cstr)

::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %s", signal_cstr);

else

::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %i", signo);

}

else

{

::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x", exit_status);

}

process->SetExitStatus (-1, error_str);

}

// Debugserver has exited we need to let our ProcessGDBRemote

// know that it no longer has a debugserver instance

process->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;

return true;

MonitorDebugserverProcess(ProcessGDBRemote *process, lldb::pid_t pid, bool exited, int signo, int exit_status);