/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  This class is for thread death monitoring.
*
*/

#include <e32base.h>

#include "osthreadsupervisor.h"

#include "runtimeexception.h"

#include "logger.h"
#include "javacommonutils.h"

using namespace java::runtime;
using namespace java::util;


OsThreadSupervisor::OsThreadSupervisor(bool tryThreadDumping) :
        mDoExit(false), mTryThreadDump(tryThreadDumping)
{
    JELOG2(EJavaRuntime);
    startUndertakerThread();
}

OsThreadSupervisor::~OsThreadSupervisor()
{
    JELOG2(EJavaRuntime);
    // Wake the undertaker thread in order to close it.
    mDoExit = true;
    mRequestStatus = KRequestPending;
    TRequestStatus* requestStatus = &mRequestStatus;
    mSupervisorThread.RequestComplete(requestStatus, KErrNone);
    mSupervisorThread.Close();
}


void OsThreadSupervisor::startUndertakerThread()
{
    JELOG2(EJavaRuntime);
    RThread thread;

    // Create the undertaker thread.
    _LIT(KUndertakerName, "JavaMidp undertaker");
    TInt err = thread.Create(KUndertakerName,
                             OsThreadSupervisor::underTakerThreadMain,
                             0x2000, 0, this);

    if (err == KErrNone)
    {
        // Set the prioroty to high.
        thread.SetPriority(EPriorityMuchMore);
        thread.Resume();
        thread.Close();
    }
    else
    {
        thread.Close();
        std::string errorStr("Not able to create undertaker thread. Reason: ");
        errorStr.append(JavaCommonUtils::intToString(err));
        throw RuntimeException(errorStr, __FILE__, __FUNCTION__, __LINE__);
    }

}

int OsThreadSupervisor::underTakerThreadMain(void* starter)
{
    JELOG2(EJavaRuntime);
    OsThreadSupervisor* supervisor =
        reinterpret_cast<OsThreadSupervisor*>(starter);

    // Open the thread handle so that RequstComplete methods can be
    // called from another thread.
    supervisor->mSupervisorThread.Open(RThread().Id());

    RUndertaker underTaker;
    if (underTaker.Create() == KErrNone)
    {
        // Get the process id of this process.
        TProcessId processId = RProcess().Id();
        int status = KErrNone;
        LOG1(EJavaRuntime, EInfo, "Starting to monitor MIDP process %lld",
             processId.Id());
        // We will receive notification from ALL the thread deaths from all
        // processes. That is why the looping is needed.
        while (status == KErrNone)
        {
            int threadHandle;

            // Logon to monitor thread deaths.
            status = underTaker.Logon(supervisor->mRequestStatus, threadHandle);
            if (status != KErrNone)
            {
                ELOG1(EJavaRuntime, "Undertaker thread failed to do logon. "
                      " Reason: %d", status);
                break;
            }

            // Start to wait thread deaths or shutdown indication.
            User::WaitForRequest(supervisor->mRequestStatus);
            if (supervisor->mDoExit)
            {
                // We are going down, so no need to monitor thread deaths.
                // Closing the undertaker thread.
                LOG(EJavaRuntime, EInfo, "Undertaker closed succesfully");
                return 0;
            }
            RThread thread;
            thread.SetHandle(threadHandle);
            LOG2(EJavaRuntime, EInfo, "A thread %lld has died with exit type %d",
                 thread.Id().Id(), thread.ExitType());

            // We are only interested in panicing threads.
            if (thread.ExitType() == EExitPanic)
            {
                RProcess terminatedProcess;
                status = thread.Process(terminatedProcess);
                if (status == KErrNone)
                {
                    LOG2(EJavaRuntime, EInfo,
                         "Thread panic from process id: %lld. "
                         "Our id is: %lld",
                         terminatedProcess.Id().Id(), processId.Id());
                    // Check if this thread belong to our process.
                    if (terminatedProcess.Id() == processId)
                    {
                        // One of MIDP threads has paniced, so lets terminate
                        // the whole process.
                        status = KErrDied;
                    }
                    terminatedProcess.Close();
                }
                else
                {
                    ELOG1(EJavaRuntime, "Solving paniced thread's process "
                          "failed. Reason: %d", status);
                }
            }
            thread.Close();
        }
    }
    ELOG(EJavaRuntime, "Panic in one of the MIDP threads. Stopping process!");
    RProcess().Terminate(KErrAbort);
    return 0;
}