llwatchdog.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"
#include "llwatchdog.h"

// This class runs the watchdog timing thread.
class LLWatchdogTimerThread : public LLThread
{
public:
        LLWatchdogTimerThread() : 
                LLThread("Watchdog"),
                mSleepMsecs(0),
                mStopping(false)
        {
        }
            
        ~LLWatchdogTimerThread() {}
    
        void setSleepTime(long ms) { mSleepMsecs = ms; }
        void stop() 
        {
                mStopping = true; 
                ms_sleep(1);
        }
    
        /* virtual */ void run()
        {
                while(!mStopping)
                {
                        LLWatchdog::getInstance()->run();
                        ms_sleep(mSleepMsecs);
                }
        }

private:
        long mSleepMsecs;
        bool mStopping;
};

// LLWatchdogEntry
LLWatchdogEntry::LLWatchdogEntry()
{
}

LLWatchdogEntry::~LLWatchdogEntry()
{
}

void LLWatchdogEntry::start()
{
        LLWatchdog::getInstance()->add(this);
}

void LLWatchdogEntry::stop()
{
        LLWatchdog::getInstance()->remove(this);
}

// LLWatchdogTimeout
LLWatchdogTimeout::LLWatchdogTimeout() : 
        mTimeout(0.0f) 
{
}

LLWatchdogTimeout::~LLWatchdogTimeout() 
{
}

bool LLWatchdogTimeout::isAlive() const 
{ 
        return (mTimer.getStarted() && !mTimer.hasExpired()); 
}

void LLWatchdogTimeout::setTimeout(F32 d) 
{
        mTimeout = d;
}

void LLWatchdogTimeout::start() 
{
        // Order of operation is very impmortant here.
        // After LLWatchdogEntry::start() is called
        // LLWatchdogTimeout::isAlive() will be called asynchronously. 
        mTimer.start(); 
        mTimer.setTimerExpirySec(mTimeout); 
        LLWatchdogEntry::start();
}
void LLWatchdogTimeout::stop() 
{
        LLWatchdogEntry::stop();
        mTimer.stop();
}

void LLWatchdogTimeout::ping() 
{ 
        mTimer.setTimerExpirySec(mTimeout); 
}

// LlWatchdog
LLWatchdog::LLWatchdog() :
        mSuspectsAccessMutex(NULL),
        mTimer(NULL)
{
}

LLWatchdog::~LLWatchdog()
{
}

void LLWatchdog::add(LLWatchdogEntry* e)
{
        mSuspectsAccessMutex->lock();
        mSuspects.insert(e);
        mSuspectsAccessMutex->unlock();
}

void LLWatchdog::remove(LLWatchdogEntry* e)
{
        mSuspectsAccessMutex->lock();
    mSuspects.erase(e);
        mSuspectsAccessMutex->unlock();
}

void LLWatchdog::init()
{
        mSuspectsAccessMutex = new LLMutex(NULL);
        mTimer = new LLWatchdogTimerThread();
        mTimer->setSleepTime(1000);
        mTimer->start();
}

void LLWatchdog::cleanup()
{
        mTimer->stop();
        delete mTimer;
        delete mSuspectsAccessMutex;
}

void LLWatchdog::run()
{
        mSuspectsAccessMutex->lock();
        
        SuspectsRegistry::iterator result = 
                std::find_if(mSuspects.begin(), 
                        mSuspects.end(), 
                        std::not1(std::mem_fun(&LLWatchdogEntry::isAlive))
                        );

        if(result != mSuspects.end())
        {
                // error!!!
                mTimer->stop();

                llinfos << "Watchdog detected error:" << llendl;
#ifdef LL_WINDOWS
                RaiseException(0,0,0,0);
#else
                raise(SIGQUIT);
#endif
        }

        mSuspectsAccessMutex->unlock();
}

---