// Handle an interrupt from the VM.
void DebuggerProxy::interrupt(CmdInterrupt &cmd) {
TRACE_RB(2, "DebuggerProxy::interrupt\n");
// Make any breakpoints that have passed breakable again.
setBreakableForBreakpointsNotMatching(cmd);
// At this point we have an interrupt, but we don't know if we're on the
// thread the proxy considers "current".
// NB: BreakPointReached really means we've got control of a VM thread from
// the opcode hook. This could be for a breakpoint, stepping, etc.
// Wait until this thread is the one this proxy wants to debug.
if (!blockUntilOwn(cmd, true)) return;
// We know we're on the "current" thread, so we can process any active flow
// command, stop if we're at a breakpoint, handle other interrupts, etc.
if (checkFlowBreak(cmd)) {
// We've hit a breakpoint and now need to make sure that breakpoints
// won't be hit again for this site until control leaves this site.
// (Breakpoints can still get hit if control reaches this site during
// a call that is part of this site because the flags are stacked.)
unsetBreakableForBreakpointsMatching(cmd);
while (true) {
try {
// We're about to send the client an interrupt and start
// waiting for commands back from it. Disable signal polling
// during this time, since our protocol requires that only one
// thread talk to the client at a time.
disableSignalPolling();
SCOPE_EXIT { enableSignalPolling(); };
processInterrupt(cmd);
} catch (const DebuggerException &e) {
TRACE(2, "DebuggerException from processInterrupt!\n");
switchThreadMode(Normal);
throw;
} catch (...) {
TRACE(2, "Unknown exception from processInterrupt!\n");
assertx(false); // no other exceptions should be seen here
switchThreadMode(Normal);
throw;
}
if (cmd.getInterruptType() == PSPEnded) break;
if (!m_newThread) break; // we're not switching threads
switchThreadMode(Normal, m_newThread->m_id);
m_newThread.reset();
blockUntilOwn(cmd, false);
}
}
if ((m_threadMode == Normal) || (cmd.getInterruptType() == PSPEnded)) {
// If the thread mode is Normal we let other threads with
// interrupts go ahead and process them. We also do this when the
// thread is at PSPEnded because the thread is done.
switchThreadMode(Normal);
}
}
std::string DebuggerProxy::requestAuthToken() {
Lock lock(m_signalMutex);
TRACE_RB(2, "DebuggerProxy::requestauthToken: sending auth request\n");
// Try to use the current sandbox's path, defaulting to the path from
// DebuggerDefaultSandboxPath if the current sandbox path is empty.
auto sandboxPath = getSandbox().m_path;
if (sandboxPath.empty()) {
sandboxPath = RuntimeOption::DebuggerDefaultSandboxPath;
}
CmdAuth cmd;
cmd.setSandboxPath(sandboxPath);
if (!cmd.onServer(*this)) {
TRACE_RB(2, "DebuggerProxy::requestAuthToken: "
"Failed to send CmdAuth to client\n");
return "";
}
DebuggerCommandPtr res;
while (!DebuggerCommand::Receive(m_thrift, res,
"DebuggerProxy::requestAuthToken()")) {
checkStop();
}
if (!res) {
TRACE_RB(2, "DebuggerProxy::requestAuthToken: "
"Failed to get CmdAuth back from client\n");
return "";
}
auto token = std::dynamic_pointer_cast<CmdAuth>(res);
if (!token) {
TRACE_RB(2, "DebuggerProxy::requestAuthToken: "
"bad response from token request: %d", res->getType());
return "";
}
return token->getToken();
}
// Primary entrypoint for the debugger from the VM. Called in response to a host
// of VM events that the debugger is interested in. The debugger will execute
// any logic needed to handle the event, and will block below this to wait for
// and process more commands from the debugger client. This function will only
// return when the debugger is letting the thread continue execution, e.g., for
// flow control command like continue, next, etc.
void Debugger::Interrupt(int type, const char *program,
InterruptSite *site /* = NULL */,
const char *error /* = NULL */) {
assert(RuntimeOption::EnableDebugger);
TRACE_RB(2, "Debugger::Interrupt type %d\n", type);
DebuggerProxyPtr proxy = GetProxy();
if (proxy) {
TRACE(3, "proxy != null\n");
RequestInjectionData &rjdata = ThreadInfo::s_threadInfo->m_reqInjectionData;
// The proxy will only service an interrupt if we've previously setup some
// form of flow control command (steps, breakpoints, etc.) or if it's
// an interrupt related to something like the session or request.
if (proxy->needInterrupt() || type != BreakPointReached) {
// Interrupts may execute some PHP code, causing another interruption.
std::stack<void *> &interrupts = rjdata.interrupts;
CmdInterrupt cmd((InterruptType)type, program, site, error);
interrupts.push(&cmd);
proxy->interrupt(cmd);
interrupts.pop();
}
// Some cmds require us to interpret all instructions until the cmd
// completes. Setting this will ensure we stay out of JIT code and in the
// interpreter so phpDebuggerOpcodeHook has a chance to work.
rjdata.setDebuggerIntr(proxy->needVMInterrupts());
} else {
TRACE(3, "proxy == null\n");
// Debugger clients are disconnected abnormally, or this sandbox is not
// being debugged.
if (type == SessionStarted || type == SessionEnded) {
// For command line programs, we need this exception to exit from
// the infinite execution loop.
throw DebuggerClientExitException();
}
}
}
void DebuggerProxy::processInterrupt(CmdInterrupt &cmd) {
TRACE_RB(2, "DebuggerProxy::processInterrupt\n");
// Do the server-side work for this interrupt, which just notifies the client.
if (!cmd.onServer(*this)) {
TRACE_RB(1, "Failed to send CmdInterrupt to client\n");
Debugger::UsageLog("server", getSandboxId(), "ProxyError",
"Send interrupt");
stopAndThrow();
}
Debugger::UsageLogInterrupt("server", getSandboxId(), cmd);
// Wait for commands from the debugger client and process them. We'll stay
// here until we get a command that should cause the thread to continue.
while (true) {
DebuggerCommandPtr res;
while (!DebuggerCommand::Receive(m_thrift, res,
"DebuggerProxy::processInterrupt()")) {
// we will wait forever until DebuggerClient sends us something
checkStop();
}
checkStop();
if (res) {
TRACE_RB(2, "Proxy got cmd type %d\n", res->getType());
Debugger::UsageLog("server", getSandboxId(),
folly::to<std::string>(res->getType()));
// Any control flow command gets installed here and we continue execution.
m_flow = std::dynamic_pointer_cast<CmdFlowControl>(res);
if (m_flow) {
m_flow->onSetup(*this, cmd);
if (!m_flow->complete()) {
TRACE_RB(2, "Incomplete flow command %d remaining on proxy for "
"further processing\n", m_flow->getType());
if (m_threadMode == Normal) {
// We want the flow command to complete on the thread that
// starts it.
switchThreadMode(Sticky);
}
} else {
// The flow cmd has determined that it is done with its work and
// doesn't need to remain for later processing.
TRACE_RB(2, "Flow command %d completed\n", m_flow->getType());
m_flow.reset();
}
return;
}
if (res->is(DebuggerCommand::KindOfQuit)) {
TRACE_RB(2, "Received quit command\n");
res->onServer(*this); // acknowledge receipt so that client can quit.
stopAndThrow();
}
}
bool cmdFailure = false;
try {
// Perform the server-side work for this command.
if (res) {
if (!res->onServer(*this)) {
TRACE_RB(1, "Failed to execute cmd %d from client\n", res->getType());
Debugger::UsageLog("server", getSandboxId(), "ProxyError",
"Command failed");
cmdFailure = true;
}
} else {
TRACE_RB(1, "Failed to receive cmd from client\n");
Debugger::UsageLog("server", getSandboxId(), "ProxyError",
"Command receive failed");
cmdFailure = true;
}
} catch (const DebuggerException &e) {
throw;
} catch (const Object &o) {
Logger::Warning(DEBUGGER_LOG_TAG
"Cmd type %d onServer() threw a php exception %s",
res->getType(), o->getVMClass()->name()->data());
Debugger::UsageLog("server", getSandboxId(), "ProxyError",
"Command exception");
cmdFailure = true;
} catch (const std::exception& e) {
Logger::Warning(DEBUGGER_LOG_TAG
"Cmd type %d onServer() threw exception %s", res->getType(), e.what());
Debugger::UsageLog("server", getSandboxId(), "ProxyError",
"Command exception");
cmdFailure = true;
} catch (...) {
Logger::Warning(DEBUGGER_LOG_TAG
"Cmd type %d onServer() threw non standard exception", res->getType());
Debugger::UsageLog("server", getSandboxId(), "ProxyError",
"Command exception");
cmdFailure = true;
}
if (cmdFailure) stopAndThrow();
if (res->shouldExitInterrupt()) return;
}
}
// This gets it's own thread, and polls the client once per second to see if
// there is a signal, i.e., if the user has pressed Ctrl-C, etc. If there is a
// signal, it is passed as an interrupt to the proxy in an attempt to get other
// threads in the sandbox to stop.
//
// If another thread in the sandbox fails to stop and consume the signal then
// it will be passed to the dummy sandbox instead.
void DebuggerProxy::pollSignal() {
TRACE_RB(2, "DebuggerProxy::pollSignal: starting\n");
int signalTimeout = RuntimeOption::DebuggerSignalTimeout;
while (!m_stopped) {
sleep(1);
// Block any threads that might be interrupting from communicating with the
// client until we're done with this poll.
Lock lock(m_signalMutex);
// After DebuggerSignalTimeout seconds that no active thread picks
// up the signal, we send it to dummy sandbox.
if ((m_signum != CmdSignal::SignalNone) && m_dummySandbox &&
(--signalTimeout <= 0)) {
TRACE_RB(2, "DebuggerProxy::pollSignal: sending to dummy sandbox\n");
m_dummySandbox->notifySignal(m_signum);
m_signum = CmdSignal::SignalNone;
}
// Don't actually poll if another thread is already in a command
// processing loop with the client.
if (!m_okayToPoll) continue;
// Send CmdSignal over to the client and wait for a response.
CmdSignal cmd;
if (!cmd.onServer(*this)) {
TRACE_RB(2, "DebuggerProxy::pollSignal: "
"Failed to send CmdSignal to client\n");
break;
}
// We've sent the client a command, and we expect an immediate
// response. Wait 10 times to give it a chance on especially
// overloaded computers.
DebuggerCommandPtr res;
for (int i = 0; i < 10; i++) {
if (DebuggerCommand::Receive(m_thrift, res,
"DebuggerProxy::pollSignal()")) break;
if (m_stopped) {
TRACE_RB(2, "DebuggerProxy::pollSignal: "
"signal thread asked to stop while waiting "
"for CmdSignal back from the client\n");
break;
}
}
if (!res) {
if (!m_stopped) {
TRACE_RB(2, "DebuggerProxy::pollSignal: "
"Failed to get CmdSignal back from client\n");
}
break;
}
auto sig = std::dynamic_pointer_cast<CmdSignal>(res);
if (!sig) {
TRACE_RB(2, "DebuggerProxy::pollSignal: "
"bad response from signal polling: %d", res->getType());
break;
}
auto newSignum = sig->getSignal();
if (newSignum != CmdSignal::SignalNone) {
TRACE_RB(2, "DebuggerProxy::pollSignal: "
"got interrupt signal from client\n");
m_signum = newSignum;
signalTimeout = RuntimeOption::DebuggerSignalTimeout;
Debugger::RequestInterrupt(shared_from_this());
}
}
if (!m_stopped) {
// We've noticed that the socket has closed. Stop and destory this proxy.
TRACE_RB(2, "DebuggerProxy::pollSignal: "
"lost communication with the client, stopping proxy\n");
Debugger::UsageLog("server", getSandboxId(), "ProxyError", "Signal poll");
stop();
}
TRACE_RB(2, "DebuggerProxy::pollSignal: ended\n");
}
// Returns false on timeout, true when data has been read even if that data
// didn't form a usable command. Is there is no usable command, cmd is null.
bool DebuggerCommand::Receive(DebuggerThriftBuffer &thrift,
DebuggerCommandPtr &cmd, const char *caller) {
TRACE(5, "DebuggerCommand::Receive\n");
cmd.reset();
struct pollfd fds[1];
fds[0].fd = thrift.getSocket()->fd();
fds[0].events = POLLIN|POLLERR|POLLHUP;
int ret = poll(fds, 1, POLLING_SECONDS * 1000);
if (ret == 0) return false; // Timeout
if (ret == -1) {
auto errorNumber = errno; // Just in case TRACE_RB changes errno
TRACE_RB(1, "DebuggerCommand::Receive: error %d\n", errorNumber);
return errorNumber != EINTR; // Treat signals as timeouts
}
// If we don't have any data to read (POLLIN) then we're done. If we
// do have data we'll attempt to read and decode it below, even if
// there are other error bits set.
if (!(fds[0].revents & POLLIN)) {
TRACE_RB(1, "DebuggerCommand::Receive: revents %d\n", fds[0].revents);
return true;
}
int32_t type;
std::string clsname;
try {
thrift.reset(true);
thrift.read(type);
thrift.read(clsname);
} catch (...) {
// Note: this error case is difficult to test. But, it's exactly the same
// as the error noted below. Make sure to keep handling of both of these
// errors in sync.
TRACE_RB(1, "%s: socket error receiving command", caller);
return true;
}
TRACE(1, "DebuggerCommand::Receive: got cmd of type %d\n", type);
// not all commands are here, as not all commands need to be sent over wire
switch (type) {
case KindOfBreak : cmd = DebuggerCommandPtr(new CmdBreak ()); break;
case KindOfContinue : cmd = DebuggerCommandPtr(new CmdContinue ()); break;
case KindOfDown : cmd = DebuggerCommandPtr(new CmdDown ()); break;
case KindOfException: cmd = DebuggerCommandPtr(new CmdException()); break;
case KindOfFrame : cmd = DebuggerCommandPtr(new CmdFrame ()); break;
case KindOfGlobal : cmd = DebuggerCommandPtr(new CmdGlobal ()); break;
case KindOfInfo : cmd = DebuggerCommandPtr(new CmdInfo ()); break;
case KindOfConstant : cmd = DebuggerCommandPtr(new CmdConstant ()); break;
case KindOfList : cmd = DebuggerCommandPtr(new CmdList ()); break;
case KindOfMachine : cmd = DebuggerCommandPtr(new CmdMachine ()); break;
case KindOfNext : cmd = DebuggerCommandPtr(new CmdNext ()); break;
case KindOfOut : cmd = DebuggerCommandPtr(new CmdOut ()); break;
case KindOfPrint : cmd = DebuggerCommandPtr(new CmdPrint ()); break;
case KindOfQuit : cmd = DebuggerCommandPtr(new CmdQuit ()); break;
case KindOfRun : cmd = DebuggerCommandPtr(new CmdRun ()); break;
case KindOfStep : cmd = DebuggerCommandPtr(new CmdStep ()); break;
case KindOfThread : cmd = DebuggerCommandPtr(new CmdThread ()); break;
case KindOfUp : cmd = DebuggerCommandPtr(new CmdUp ()); break;
case KindOfVariable : cmd = DebuggerCommandPtr(new CmdVariable ()); break;
case KindOfVariableAsync :
cmd = DebuggerCommandPtr(new CmdVariable (KindOfVariableAsync)); break;
case KindOfWhere : cmd = DebuggerCommandPtr(new CmdWhere ()); break;
case KindOfWhereAsync:
cmd = DebuggerCommandPtr(new CmdWhere(KindOfWhereAsync)); break;
case KindOfEval : cmd = DebuggerCommandPtr(new CmdEval ()); break;
case KindOfInterrupt: cmd = DebuggerCommandPtr(new CmdInterrupt()); break;
case KindOfSignal : cmd = DebuggerCommandPtr(new CmdSignal ()); break;
case KindOfShell : cmd = DebuggerCommandPtr(new CmdShell ()); break;
case KindOfInternalTesting :
cmd = DebuggerCommandPtr(new CmdInternalTesting()); break;
case KindOfExtended: {
assert(!clsname.empty());
cmd = CmdExtended::CreateExtendedCommand(clsname);
assert(cmd);
break;
}
default:
TRACE_RB(1, "%s: received bad cmd type: %d", caller, type);
cmd.reset();
return true;
}
if (!cmd->recv(thrift)) {
// Note: this error case is easily tested, and we have a test for it. But
// the error case noted above is quite difficult to test. Keep these two
// in sync.
TRACE_RB(1, "%s: socket error receiving command", caller);
cmd.reset();
}
return true;
}
