#include "config.h"
#include "Watchdog.h"
#include "CallFrame.h"
#include <wtf/CurrentTime.h>
#include <wtf/MathExtras.h>
namespace JSC {
const std::chrono::microseconds Watchdog::noTimeLimit = std::chrono::microseconds::max();
static std::chrono::microseconds currentWallClockTime()
{
auto steadyTimeSinceEpoch = std::chrono::steady_clock::now().time_since_epoch();
return std::chrono::duration_cast<std::chrono::microseconds>(steadyTimeSinceEpoch);
}
Watchdog::Watchdog()
: m_timerDidFire(false)
, m_timeLimit(noTimeLimit)
, m_cpuDeadline(noTimeLimit)
, m_wallClockDeadline(noTimeLimit)
, m_callback(0)
, m_callbackData1(0)
, m_callbackData2(0)
, m_timerQueue(WorkQueue::create("jsc.watchdog.queue", WorkQueue::Type::Serial, WorkQueue::QOS::Utility))
{
}
void Watchdog::setTimeLimit(std::chrono::microseconds limit,
ShouldTerminateCallback callback, void* data1, void* data2)
{
LockHolder locker(m_lock);
m_timeLimit = limit;
m_callback = callback;
m_callbackData1 = data1;
m_callbackData2 = data2;
if (m_hasEnteredVM && hasTimeLimit())
startTimer(locker, m_timeLimit);
}
JS_EXPORT_PRIVATE void Watchdog::terminateSoon()
{
LockHolder locker(m_lock);
m_timeLimit = std::chrono::microseconds(0);
m_cpuDeadline = std::chrono::microseconds(0);
m_wallClockDeadline = std::chrono::microseconds(0);
m_timerDidFire = true;
}
bool Watchdog::shouldTerminateSlow(ExecState* exec)
{
{
LockHolder locker(m_lock);
ASSERT(m_timerDidFire);
m_timerDidFire = false;
if (currentWallClockTime() < m_wallClockDeadline)
return false;
m_wallClockDeadline = noTimeLimit;
auto cpuTime = currentCPUTime();
if (cpuTime < m_cpuDeadline) {
auto remainingCPUTime = m_cpuDeadline - cpuTime;
startTimer(locker, remainingCPUTime);
return false;
}
}
bool needsTermination = !m_callback
|| m_callback(exec, m_callbackData1, m_callbackData2);
if (needsTermination)
return true;
{
LockHolder locker(m_lock);
ASSERT(m_hasEnteredVM);
bool callbackAlreadyStartedTimer = (m_cpuDeadline != noTimeLimit);
if (hasTimeLimit() && !callbackAlreadyStartedTimer)
startTimer(locker, m_timeLimit);
}
return false;
}
bool Watchdog::hasTimeLimit()
{
return (m_timeLimit != noTimeLimit);
}
void Watchdog::enteredVM()
{
m_hasEnteredVM = true;
if (hasTimeLimit()) {
LockHolder locker(m_lock);
startTimer(locker, m_timeLimit);
}
}
void Watchdog::exitedVM()
{
ASSERT(m_hasEnteredVM);
LockHolder locker(m_lock);
stopTimer(locker);
m_hasEnteredVM = false;
}
void Watchdog::startTimer(LockHolder&, std::chrono::microseconds timeLimit)
{
ASSERT(m_hasEnteredVM);
ASSERT(hasTimeLimit());
ASSERT(timeLimit <= m_timeLimit);
m_cpuDeadline = currentCPUTime() + timeLimit;
auto wallClockTime = currentWallClockTime();
auto wallClockDeadline = wallClockTime + timeLimit;
if ((wallClockTime < m_wallClockDeadline)
&& (m_wallClockDeadline <= wallClockDeadline))
return;
this->ref(); m_wallClockDeadline = wallClockDeadline;
m_timerQueue->dispatchAfter(std::chrono::nanoseconds(timeLimit), [this] {
{
LockHolder locker(m_lock);
m_timerDidFire = true;
}
deref();
});
}
void Watchdog::stopTimer(LockHolder&)
{
m_cpuDeadline = noTimeLimit;
}
}