path: root/indra/llplugin/llpluginprocesschild.cpp

/**
* @file llpluginprocesschild.cpp
* @brief LLPluginProcessChild handles the child side of the external-process plugin API.
*
* @cond
* $LicenseInfo:firstyear=2008&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
* $/LicenseInfo$
* @endcond
*/

#include "linden_common.h"

#include "llpluginprocesschild.h"
#include "llplugininstance.h"
#include "llpluginmessagepipe.h"
#include "llpluginmessageclasses.h"

static const F32 GOODBYE_SECONDS = 12.0f; // Do not set it to be bigger than mPluginLockupTimeout or parent will kill LLPluginProcessChild
static const F32 HEARTBEAT_SECONDS = 1.0f;
static const F32 PLUGIN_IDLE_SECONDS = 1.0f / 100.0f;  // Each call to idle will give the plugin this much time.

LLPluginProcessChild::LLPluginProcessChild()
{
    mState = STATE_UNINITIALIZED;
    mInstance = NULL;
    mSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);
    mSleepTime = PLUGIN_IDLE_SECONDS;   // default: send idle messages at 100Hz
    mCPUElapsed = 0.0f;
    mBlockingRequest = false;
    mBlockingResponseReceived = false;
}

LLPluginProcessChild::~LLPluginProcessChild()
{
    if (mInstance != NULL)
    {
        sendMessageToPlugin(LLPluginMessage("base", "cleanup"));

        // IMPORTANT: under some (unknown) circumstances the apr_dso_unload() triggered when mInstance is deleted
        // appears to fail and lock up which means that a given instance of the slplugin process never exits.
        // This is bad, especially when users try to update their version of SL - it fails because the slplugin
        // process as well as a bunch of plugin specific files are locked and cannot be overwritten.
        exit(0);
        //delete mInstance;
        //mInstance = NULL;
    }
}

void LLPluginProcessChild::killSockets(void)
{
    killMessagePipe();
    mSocket.reset();
}

void LLPluginProcessChild::init(U32 launcher_port)
{
    mLauncherHost = LLHost("127.0.0.1", launcher_port);
    setState(STATE_INITIALIZED);
}

void LLPluginProcessChild::idle(void)
{
    bool idle_again;
    do
    {
        if (mState < STATE_SHUTDOWNREQ)
        {   // Once we have hit the shutdown request state checking for errors might put us in a spurious
            // error state... don't do that.

            if (APR_STATUS_IS_EOF(mSocketError))
            {
                // Plugin socket was closed.  This covers both normal plugin termination and host crashes.
                setState(STATE_ERROR);
            }
            else if (mSocketError != APR_SUCCESS)
            {
                LL_INFOS("Plugin") << "message pipe is in error state (" << mSocketError << "), moving to STATE_ERROR" << LL_ENDL;
                setState(STATE_ERROR);
            }

            if ((mState > STATE_INITIALIZED) && (mMessagePipe == NULL))
            {
                // The pipe has been closed -- we're done.
                // TODO: This could be slightly more subtle, but I'm not sure it needs to be.
                LL_INFOS("Plugin") << "message pipe went away, moving to STATE_ERROR" << LL_ENDL;
                setState(STATE_ERROR);
            }
        }

        // If a state needs to go directly to another state (as a performance enhancement), it can set idle_again to true after calling setState().
        // USE THIS CAREFULLY, since it can starve other code.  Specifically make sure there's no way to get into a closed cycle and never return.
        // When in doubt, don't do it.
        idle_again = false;

        if (mInstance != NULL)
        {
            // Provide some time to the plugin
            mInstance->idle();
        }

        switch (mState)
        {
        case STATE_UNINITIALIZED:
            break;

        case STATE_INITIALIZED:
            if (mSocket->blockingConnect(mLauncherHost))
            {
                // This automatically sets mMessagePipe
                new LLPluginMessagePipe(this, mSocket);

                setState(STATE_CONNECTED);
            }
            else
            {
                // connect failed
                setState(STATE_ERROR);
            }
            break;

        case STATE_CONNECTED:
            sendMessageToParent(LLPluginMessage(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "hello"));
            setState(STATE_PLUGIN_LOADING);
            break;

        case STATE_PLUGIN_LOADING:
            if (!mPluginFile.empty())
            {
                mInstance = new LLPluginInstance(this);
                if (mInstance->load(mPluginDir, mPluginFile) == 0)
                {
                    mHeartbeat.start();
                    mHeartbeat.setTimerExpirySec(HEARTBEAT_SECONDS);
                    mCPUElapsed = 0.0f;
                    setState(STATE_PLUGIN_LOADED);
                }
                else
                {
                    setState(STATE_ERROR);
                }
            }
            break;

        case STATE_PLUGIN_LOADED:
        {
            setState(STATE_PLUGIN_INITIALIZING);
            LLPluginMessage message("base", "init");
            sendMessageToPlugin(message);
        }
        break;

        case STATE_PLUGIN_INITIALIZING:
            // waiting for init_response...
            break;

        case STATE_RUNNING:
            if (mInstance != NULL)
            {
                // Provide some time to the plugin
                LLPluginMessage message("base", "idle");
                message.setValueReal("time", PLUGIN_IDLE_SECONDS);
                sendMessageToPlugin(message);

                mInstance->idle();

                if (mHeartbeat.hasExpired())
                {

                    // This just proves that we're not stuck down inside the plugin code.
                    LLPluginMessage heartbeat(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "heartbeat");

                    // Calculate the approximage CPU usage fraction (floating point value between 0 and 1) used by the plugin this heartbeat cycle.
                    // Note that this will not take into account any threads or additional processes the plugin spawns, but it's a first approximation.
                    // If we could write OS-specific functions to query the actual CPU usage of this process, that would be a better approximation.
                    heartbeat.setValueReal("cpu_usage", mCPUElapsed / mHeartbeat.getElapsedTimeF64());

                    sendMessageToParent(heartbeat);

                    mHeartbeat.reset();
                    mHeartbeat.setTimerExpirySec(HEARTBEAT_SECONDS);
                    mCPUElapsed = 0.0f;
                }
            }
            // receivePluginMessage will transition to STATE_UNLOADING
            break;

        case STATE_SHUTDOWNREQ:
            // set next state first thing in case "cleanup" message advances state.
            setState(STATE_UNLOADING);
            mWaitGoodbye.setTimerExpirySec(GOODBYE_SECONDS);

            if (mInstance != NULL)
            {
                sendMessageToPlugin(LLPluginMessage("base", "cleanup"));
            }
            break;

        case STATE_UNLOADING:
            // waiting for goodbye from plugin.
            if (mWaitGoodbye.hasExpired())
            {
                LL_WARNS() << "Wait for goodbye expired.  Advancing to UNLOADED" << LL_ENDL;
                if (mInstance != NULL)
                {
                    // Something went wrong, at least make sure plugin will terminate
                    sendMessageToPlugin(LLPluginMessage("base", "force_exit"));
                }
                setState(STATE_UNLOADED);
            }

            if (mInstance)
            {
                // Provide some time to the plugin
                // example: CEF on "cleanup" sets shutdown request, but it still needs idle loop to actually shutdown
                LLPluginMessage message("base", "idle");
                message.setValueReal("time", PLUGIN_IDLE_SECONDS);
                sendMessageToPlugin(message);

                mInstance->idle();
            }

            break;

        case STATE_UNLOADED:
            killSockets();
            delete mInstance;
            mInstance = NULL;
            setState(STATE_DONE);
            break;

        case STATE_ERROR:
            // Close the socket to the launcher
            killSockets();
            // TODO: Where do we go from here?  Just exit()?
            setState(STATE_DONE);
            break;

        case STATE_DONE:
            // just sit here.
            break;
        }

    } while (idle_again);
}

void LLPluginProcessChild::sleep(F64 seconds)
{
    deliverQueuedMessages();
    if (mMessagePipe)
    {
        mMessagePipe->pump(seconds);
    }
    else
    {
    ms_sleep((int)(seconds * 1000.0f));
    }
}

void LLPluginProcessChild::pump(void)
{
    deliverQueuedMessages();
    if (mMessagePipe)
    {
        mMessagePipe->pump(0.0f);
    }
    else
    {
        // Should we warn here?
    }
}


bool LLPluginProcessChild::isRunning(void)
{
    bool result = false;

    if (mState == STATE_RUNNING)
        result = true;

    return result;
}

bool LLPluginProcessChild::isDone(void)
{
    bool result = false;

    switch (mState)
    {
    case STATE_DONE:
        result = true;
        break;
    default:
        break;
    }

    return result;
}

void LLPluginProcessChild::sendMessageToPlugin(const LLPluginMessage &message)
{
    if (mInstance)
    {
        std::string buffer = message.generate();

        LL_DEBUGS("Plugin") << "Sending to plugin: " << buffer << LL_ENDL;
        LLTimer elapsed;

        mInstance->sendMessage(buffer);

        mCPUElapsed += elapsed.getElapsedTimeF64();
    }
    else
    {
        LL_WARNS("Plugin") << "mInstance == NULL" << LL_ENDL;
    }
}

void LLPluginProcessChild::sendMessageToParent(const LLPluginMessage &message)
{
    std::string buffer = message.generate();

    LL_DEBUGS("Plugin") << "Sending to parent: " << buffer << LL_ENDL;

    writeMessageRaw(buffer);
}

void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
{
    // Incoming message from the TCP Socket

    LL_DEBUGS("Plugin") << "Received from parent: " << message << LL_ENDL;

    // Decode this message
    LLPluginMessage parsed;
    parsed.parse(message);

    if (mBlockingRequest)
    {
        // We're blocking the plugin waiting for a response.

        if (parsed.hasValue("blocking_response"))
        {
            // This is the message we've been waiting for -- fall through and send it immediately.
            mBlockingResponseReceived = true;
        }
        else
        {
            // Still waiting.  Queue this message and don't process it yet.
            mMessageQueue.push(message);
            return;
        }
    }

    bool passMessage = true;

    // FIXME: how should we handle queueing here?

    {
        std::string message_class = parsed.getClass();
        if (message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
        {
            passMessage = false;

            std::string message_name = parsed.getName();
            if (message_name == "load_plugin")
            {
                mPluginFile = parsed.getValue("file");
                mPluginDir = parsed.getValue("dir");
            }
            else if (message_name == "shutdown_plugin")
            {
                setState(STATE_SHUTDOWNREQ);
            }
            else if (message_name == "shm_add")
            {
                std::string name = parsed.getValue("name");
                size_t size = (size_t)parsed.getValueS32("size");

                sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
                if (iter != mSharedMemoryRegions.end())
                {
                    // Need to remove the old region first
                    LL_WARNS("Plugin") << "Adding a duplicate shared memory segment!" << LL_ENDL;
                }
                else
                {
                    // This is a new region
                    LLPluginSharedMemory *region = new LLPluginSharedMemory;
                    if (region->attach(name, size))
                    {
                        mSharedMemoryRegions.insert(sharedMemoryRegionsType::value_type(name, region));

                        std::stringstream addr;
                        addr << region->getMappedAddress();

                        // Send the add notification to the plugin
                        LLPluginMessage message("base", "shm_added");
                        message.setValue("name", name);
                        message.setValueS32("size", (S32)size);
                        message.setValuePointer("address", region->getMappedAddress());
                        sendMessageToPlugin(message);

                        // and send the response to the parent
                        message.setMessage(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_add_response");
                        message.setValue("name", name);
                        sendMessageToParent(message);
                    }
                    else
                    {
                        LL_WARNS("Plugin") << "Couldn't create a shared memory segment!" << LL_ENDL;
                        delete region;
                    }
                }

            }
            else if (message_name == "shm_remove")
            {
                std::string name = parsed.getValue("name");
                sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
                if (iter != mSharedMemoryRegions.end())
                {
                    // forward the remove request to the plugin -- its response will trigger us to detach the segment.
                    LLPluginMessage message("base", "shm_remove");
                    message.setValue("name", name);
                    sendMessageToPlugin(message);
                }
                else
                {
                    LL_WARNS("Plugin") << "shm_remove for unknown memory segment!" << LL_ENDL;
                }
            }
            else if (message_name == "sleep_time")
            {
                mSleepTime = llmax(parsed.getValueReal("time"), 1.0 / 100.0); // clamp to maximum of 100Hz
            }
            else if (message_name == "crash")
            {
                // Crash the plugin
                LL_ERRS("Plugin") << "Plugin crash requested." << LL_ENDL;
            }
            else if (message_name == "hang")
            {
                // Hang the plugin
                LL_WARNS("Plugin") << "Plugin hang requested." << LL_ENDL;
                while (1)
                {
                    // wheeeeeeeee......
                }
            }
            else
            {
                LL_WARNS("Plugin") << "Unknown internal message from parent: " << message_name << LL_ENDL;
            }
        }
    }

    if (passMessage && mInstance != NULL)
    {
        LLTimer elapsed;

        mInstance->sendMessage(message);

        mCPUElapsed += elapsed.getElapsedTimeF64();
    }
}

/* virtual */
void LLPluginProcessChild::receivePluginMessage(const std::string &message)
{
    LL_DEBUGS("Plugin") << "Received from plugin: " << message << LL_ENDL;

    if (mBlockingRequest)
    {
        //
        LL_ERRS("Plugin") << "Can't send a message while already waiting on a blocking request -- aborting!" << LL_ENDL;
    }

    // Incoming message from the plugin instance
    bool passMessage = true;

    // FIXME: how should we handle queueing here?

    // Intercept certain base messages (responses to ones sent by this class)
    {
        // Decode this message
        LLPluginMessage parsed;
        parsed.parse(message);

        if (parsed.hasValue("blocking_request"))
        {
            mBlockingRequest = true;
        }

        std::string message_class = parsed.getClass();
        if (message_class == "base")
        {
            std::string message_name = parsed.getName();
            if (message_name == "init_response")
            {
                // The plugin has finished initializing.
                setState(STATE_RUNNING);

                // Don't pass this message up to the parent
                passMessage = false;

                LLPluginMessage new_message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin_response");
                LLSD versions = parsed.getValueLLSD("versions");
                new_message.setValueLLSD("versions", versions);

                if (parsed.hasValue("plugin_version"))
                {
                    std::string plugin_version = parsed.getValue("plugin_version");
                    new_message.setValueLLSD("plugin_version", plugin_version);
                }

                // Let the parent know it's loaded and initialized.
                sendMessageToParent(new_message);
            }
            else if (message_name == "goodbye")
            {
                setState(STATE_UNLOADED);
            }
            else if (message_name == "shm_remove_response")
            {
                // Don't pass this message up to the parent
                passMessage = false;

                std::string name = parsed.getValue("name");
                sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
                if (iter != mSharedMemoryRegions.end())
                {
                    // detach the shared memory region
                    iter->second->detach();

                    // and remove it from our map
                    mSharedMemoryRegions.erase(iter);

                    // Finally, send the response to the parent.
                    LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_remove_response");
                    message.setValue("name", name);
                    sendMessageToParent(message);
                }
                else
                {
                    LL_WARNS("Plugin") << "shm_remove_response for unknown memory segment!" << LL_ENDL;
                }
            }
        }
    }

    if (passMessage)
    {
        LL_DEBUGS("Plugin") << "Passing through to parent: " << message << LL_ENDL;
        writeMessageRaw(message);
    }

    while (mBlockingRequest)
    {
        // The plugin wants to block and wait for a response to this message.
        sleep(mSleepTime);  // this will pump the message pipe and process messages

        if (mBlockingResponseReceived || mSocketError != APR_SUCCESS || (mMessagePipe == NULL))
        {
            // Response has been received, or we've hit an error state.  Stop waiting.
            mBlockingRequest = false;
            mBlockingResponseReceived = false;
        }
    }
}


void LLPluginProcessChild::setState(EState state)
{
    LL_DEBUGS("Plugin") << "setting state to " << state << LL_ENDL;
    mState = state;
};

void LLPluginProcessChild::deliverQueuedMessages()
{
    if (!mBlockingRequest)
    {
        while (!mMessageQueue.empty())
        {
            receiveMessageRaw(mMessageQueue.front());
            mMessageQueue.pop();
        }
    }
}