TRACE(2, "Debugger::StartClient\n");

SmartPtr<Socket> localProxy = DebuggerClient::Start(options);

if (localProxy.get()) {

s_clientStarted = true;

return CreateProxy(localProxy, true);

}

return DebuggerProxyPtr();

TRACE(2, "Debugger::Stop\n");

LogShutdown(ShutdownKind::Normal);

s_debugger.m_proxyMap.clear();

DebuggerServer::Stop();

CleanupRetiredProxies();

if (s_clientStarted) {

DebuggerClient::Stop();

}

TRACE(7, "Debugger::GetProxy\n");

const String& sandboxId = g_context->getSandboxId();

return s_debugger.findProxy(sandboxId.get());

const std::string &newId,

bool force) {

TRACE(2, "Debugger::SwitchSandbox\n");

return s_debugger.switchSandbox(proxy, newId, force);

bool restart) {

TRACE(2, "Debugger::DebuggerSession: restart=%d\n", restart);

if (options.extension.empty()) {

// even if it's empty, still need to call for warmup

hphp_invoke_simple("", true); // not to run the 1st file if compiled

} else {

hphp_invoke_simple(options.extension);

}

ThreadInfo *ti = ThreadInfo::s_threadInfo.getNoCheck();

ti->m_reqInjectionData.setDebugger(true);

if (!restart) {

DebuggerDummyEnv dde;

Debugger::InterruptSessionStarted(options.fileName.c_str());

}

if (!options.fileName.empty()) {

hphp_invoke_simple(options.fileName);

}

{

DebuggerDummyEnv dde;

Debugger::InterruptSessionEnded(options.fileName.c_str());

}

int proxyCount = s_debugger.countConnectedProxy();

if (proxyCount > 0) {

Logger::Warning(DEBUGGER_LOG_TAG "%s with connected debuggers!",

shutdownKind == ShutdownKind::Normal ?

"Normal shutdown" : "Unexpected crash");

for (const auto& proxyEntry: s_debugger.m_proxyMap) {

auto sid = proxyEntry.first;

auto proxy = proxyEntry.second;

auto dummySid = makeStaticString(proxy->getDummyInfo().id());

if (sid != dummySid) {

auto sandbox = proxy->getSandbox();

if (sandbox.valid()) {

Logger::Warning(DEBUGGER_LOG_TAG "Debugging %s\n",

sandbox.desc().c_str());

}

}

}

}

const char *error /* = NULL */) {

TRACE(2, "Debugger::InterruptSessionStarted\n");

ThreadInfo::s_threadInfo->m_reqInjectionData.setDebugger(true);

s_debugger.registerThread(); // Register this thread as being debugged

Interrupt(SessionStarted, file, nullptr, error);

// Build a site to represent the URL. Note it won't have any source info

// in it, because this event is raised with no PHP on the stack.

InterruptSite site(false, null_variant);

site.url() = url ? url : "";

Interrupt(type, url, &site);

TRACE(2, "Debugger::InterruptRequestStarted\n");

if (ThreadInfo::s_threadInfo->m_reqInjectionData.getDebugger()) {

s_debugger.registerThread(); // Register this thread as being debugged

InterruptWithUrl(RequestStarted, url);

}

TRACE(2, "Debugger::InterruptRequestEnded: url=%s\n", url);

if (ThreadInfo::s_threadInfo->m_reqInjectionData.getDebugger()) {

InterruptWithUrl(RequestEnded, url);

}

const String& sandboxId = g_context->getSandboxId();

s_debugger.unregisterSandbox(sandboxId.get());

TRACE(2, "Debugger::InterruptPSPEnded\n");

if (ThreadInfo::s_threadInfo->m_reqInjectionData.getDebugger()) {

InterruptWithUrl(PSPEnded, url);

}

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();

}

}

CVarRef e /* = null_variant */) {

TRACE(2, "Debugger::InterruptVMHook\n");

// Computing the interrupt site here pulls in more data from the Unit to

// describe the current execution point.

InterruptSite site(type == HardBreakPoint, e);

if (!site.valid()) {

// An invalid site is missing something like an ActRec, a func, or a

// Unit. Currently the debugger has no action to take at such sites.

return;

}

Interrupt(type, nullptr, &site);

TRACE(2, "Debugger::SetTextColors\n");

s_stdout_color = ANSI_COLOR_CYAN;

s_stderr_color = ANSI_COLOR_RED;

TRACE(2, "Debugger::ColorStdout\n");

if (s_stdout_color) {

return String(s_stdout_color) + s + String(ANSI_COLOR_END);

}

return s;

TRACE(2, "Debugger::ColorStderr\n");

if (s_stderr_color) {

return String(s_stderr_color) + s + String(ANSI_COLOR_END);

}

return s;

TRACE(2, "Debugger::isThreadDebugging tid=%" PRIx64 "\n", tid);

ThreadInfoMap::const_accessor acc;

if (m_threadInfos.find(acc, tid)) {

ThreadInfo* ti = acc->second;

auto isDebugging = ti->m_reqInjectionData.getDebugger();

TRACE(2, "Is thread debugging? %d\n", isDebugging);

return isDebugging;

}

TRACE(2, "Thread was never registered, assuming it is not debugging\n");

return false;

TRACE(2, "Debugger::registerThread\n");

ThreadInfo* ti = ThreadInfo::s_threadInfo.getNoCheck();

int64_t tid = (int64_t)Process::GetThreadId();

ThreadInfoMap::accessor acc;

m_threadInfos.insert(acc, tid);

acc->second = ti;

TRACE(2, "Debugger::addOrUpdateSandbox\n");

const StringData* sd = makeStaticString(sandbox.id());

SandboxMap::accessor acc;

if (m_sandboxMap.insert(acc, sd)) {

DSandboxInfoPtr sb(new DSandboxInfo());

*sb = sandbox;

acc->second = sb;

} else {

acc->second->update(sandbox);

}

TRACE(2, "Debugger::getSandboxes\n");

sandboxes.reserve(m_sandboxMap.size());

for (SandboxMap::const_iterator iter =

m_sandboxMap.begin(); iter != m_sandboxMap.end(); ++iter) {

if (!iter->second->m_user.empty()) {

DSandboxInfoPtr sandbox(new DSandboxInfo());

*sandbox = *iter->second;

sandboxes.push_back(sandbox);

}

}

TRACE(2, "Debugger::registerSandbox\n");

// update sandbox first

addOrUpdateSandbox(sandbox);

// add thread to m_sandboxThreadInfoMap

const StringData* sid = makeStaticString(sandbox.id());

ThreadInfo* ti = ThreadInfo::s_threadInfo.getNoCheck();

{

SandboxThreadInfoMap::accessor acc;

m_sandboxThreadInfoMap.insert(acc, sid);

ThreadInfoSet& set = acc->second;

set.insert(ti);

}

// find out whether this sandbox is being debugged

DebuggerProxyPtr proxy = findProxy(sid);

if (proxy) {

ti->m_reqInjectionData.setDebugger(true);

}

TRACE(2, "Debugger::unregisterSandbox\n");

ThreadInfo *ti = ThreadInfo::s_threadInfo.getNoCheck();

SandboxThreadInfoMap::accessor acc;

if (m_sandboxThreadInfoMap.find(acc, sandboxId)) {

ThreadInfoSet& set = acc->second;

set.erase(ti);

}

TRACE(2, "Debugger::requestInterrupt\n");

const StringData* sid = makeStaticString(proxy->getSandboxId());

FOREACH_SANDBOX_THREAD_BEGIN(sid, ti)

ti->m_reqInjectionData.setDebuggerIntr(true);

ti->m_reqInjectionData.setDebuggerSignalFlag();

FOREACH_SANDBOX_THREAD_END()

sid = makeStaticString(proxy->getDummyInfo().id());

FOREACH_SANDBOX_THREAD_BEGIN(sid, ti)

ti->m_reqInjectionData.setDebuggerIntr(true);

ti->m_reqInjectionData.setDebuggerSignalFlag();

FOREACH_SANDBOX_THREAD_END()

TRACE(2, "Debugger::setDebuggerFlag\n");

FOREACH_SANDBOX_THREAD_BEGIN(sandboxId, ti)

ti->m_reqInjectionData.setDebugger(flag);

FOREACH_SANDBOX_THREAD_END()

TRACE(2, "Debugger::createProxy\n");

// Creates a proxy and threads needed to handle it. At this point, there is

// not enough information to attach a sandbox.

DebuggerProxyPtr proxy(new DebuggerProxy(socket, local));

{

// Place this new proxy into the proxy map keyed on the dummy sandbox id.

// This keeps the proxy alive in the server case, which drops the result of

// this function on the floor. It also makes the proxy findable when we a

// dummy sandbox thread needs to interrupt.

const StringData* sid =

makeStaticString(proxy->getDummyInfo().id());

assert(sid);

ProxyMap::accessor acc;

m_proxyMap.insert(acc, sid);

acc->second = proxy;

}

if (!local) {

proxy->startDummySandbox();

}

proxy->startSignalThread();

return proxy;

TRACE(7, "Debugger::cleanupRetiredProxies\n");

DebuggerProxyPtr proxy;

while (m_retiredProxyQueue.try_pop(proxy)) {

try {

// We give the proxy a short period of time to wait for any

// threads it owns. If it doesn't succeed, we put it back and

// try again later.

TRACE(2, "Cleanup proxy %p\n", proxy.get());

if (!proxy->cleanup(1)) {

TRACE(2, "Proxy %p has not stopped yet\n", proxy.get());

m_retiredProxyQueue.push(proxy);

}

} catch (Exception &e) {

Logger::Error("Exception during proxy %p retirement: %s",

proxy.get(), e.getMessage().c_str());

}

}

TRACE(2, "Debugger::removeProxy\n");

if (proxy->getSandbox().valid()) {

const StringData* sid = makeStaticString(proxy->getSandboxId());

setDebuggerFlag(sid, false);

m_proxyMap.erase(sid);

}

const StringData* dummySid =

makeStaticString(proxy->getDummyInfo().id());

m_proxyMap.erase(dummySid);

// Clear the debugger blacklist PC upon last detach if JIT is used

if (RuntimeOption::EvalJit && countConnectedProxy() == 0) {

JIT::tx64->clearDbgBL();

}

TRACE(7, "Debugger::findProxy\n");

if (sandboxId) {

ProxyMap::const_accessor acc;

if (m_proxyMap.find(acc, sandboxId)) {

return acc->second;

}

}

return DebuggerProxyPtr();

const std::string &newId,

bool force) {

TRACE(2, "Debugger::switchSandbox\n");

const StringData* newSid = makeStaticString(newId);

// Lock the proxy during the switch

Lock l(proxy.get());

if (proxy->getSandboxId() != newId) {

if (!switchSandboxImpl(proxy, newSid, force)) {

// failed to switch

return false;

}

}

updateProxySandbox(proxy, newSid);

return true;

const StringData* newSid,

bool force) {

TRACE(2, "Debugger::switchSandboxImpl\n");

// Take the new sandbox

DebuggerProxyPtr otherProxy;

{

ProxyMap::accessor acc;

if (m_proxyMap.insert(acc, newSid)) {

acc->second = proxy;

} else {

// the sandbox indicated by newId is already attached by another proxy

if (!force) {

return false;

}

// Delay the destruction of the proxy originally attached to the sandbox

// to avoid calling a DebuggerProxy destructor (which can sleep) while

// holding m_mutex.

otherProxy = acc->second;

acc->second = proxy;

}

}

if (proxy->getSandbox().valid()) {

// Detach from the old sandbox

const StringData* oldSid =

makeStaticString(proxy->getSandboxId());

setDebuggerFlag(oldSid, false);

m_proxyMap.erase(oldSid);

}

setDebuggerFlag(newSid, true);

if (otherProxy) {

otherProxy->stop();

}

return true;

const StringData* sandboxId) {

TRACE(2, "Debugger::updateProxySandbox\n");

// update proxy's sandbox info from what is on file

SandboxMap::const_accessor acc;

if (m_sandboxMap.find(acc, sandboxId)) {

proxy->updateSandbox(acc->second);

} else {

// don't have the sandbox on file yet. create a sandbox info with

// no path for now. Sandbox path will be updated upon first request

// with that sandbox arrives

DSandboxInfoPtr sb(new DSandboxInfo(sandboxId->toCPPString()));

proxy->updateSandbox(sb);

}

const std::string &cmd, const std::string &data) {

if (s_debugger.m_usageLogger) s_debugger.m_usageLogger->log(mode, sandboxId,

cmd, data);

const std::string &sandboxId,

CmdInterrupt &cmd) {

UsageLog(mode, sandboxId, "interrupt", InterruptTypeName(cmd));

TRACE(2, "EvalBreakControl::EvalBreakControl\n");

m_noBreakSave = g_vmContext->m_dbgNoBreak;

g_vmContext->m_dbgNoBreak = noBreak;