path: root/cmds/runtime/SignalHandler.cpp

//
// Copyright 2005 The Android Open Source Project
//

#define LOG_TAG "SignalHandler"

#include "SignalHandler.h"

#include <utils/Atomic.h>
#include <utils/Debug.h>
#include <utils/Log.h>

#include <errno.h>
#include <sys/wait.h>
#include <unistd.h>

namespace android {

class SignalHandler::ProcessThread : public Thread
{
public:
    ProcessThread(SignalHandler& sh)
        : Thread(false)
        , mOwner(sh)
    {
    }

    virtual bool threadLoop()
    {
        char buffer[32];
        read(mOwner.mAvailMsg[0], buffer, sizeof(buffer));

        LOGV("Signal command processing thread woke up!");

        if (mOwner.mLostCommands) {
            LOGE("Lost %d signals!", mOwner.mLostCommands);
            mOwner.mLostCommands = 0;
        }

        int cur;
        while ((cur=mOwner.mCommandBottom) != mOwner.mCommandTop) {
            if (mOwner.mCommands[cur].filled == 0) {
                LOGV("Command at %d is not yet filled", cur);
                break;
            }

            LOGV("Processing command at %d, top is %d",
                 cur, mOwner.mCommandTop);
            processCommand(mOwner.mCommands[cur]);
            mOwner.mCommands[cur].filled = 0;

            int next = mOwner.mCommandBottom+1;
            if (next >= COMMAND_QUEUE_SIZE) {
                next = 0;
            }

            mOwner.mCommandBottom = next;
        }

        return true;
    }

    void processCommand(const CommandEntry& entry)
    {
        switch (entry.signum) {
        case SIGCHLD: {
            mOwner.mLock.lock();
            ssize_t i = mOwner.mChildHandlers.indexOfKey(entry.info.si_pid);
            ChildHandler ch;
            if (i >= 0) {
                ch = mOwner.mChildHandlers.valueAt(i);
                mOwner.mChildHandlers.removeItemsAt(i);
            }
            mOwner.mLock.unlock();

            LOGD("SIGCHLD: pid=%d, handle index=%d", entry.info.si_pid, i);

            if (i >= 0) {
                int res = waitpid(entry.info.si_pid, NULL, WNOHANG);
                LOGW_IF(res == 0,
                        "Received SIGCHLD, but pid %d is not yet stopped",
                        entry.info.si_pid);
                if (ch.handler) {
                    ch.handler(entry.info.si_pid, ch.userData);
                }
            } else {
                LOGW("Unhandled SIGCHLD for pid %d", entry.info.si_pid);
            }
        } break;
        }
    }

    SignalHandler& mOwner;
};


Mutex SignalHandler::mInstanceLock;
SignalHandler* SignalHandler::mInstance = NULL;

status_t SignalHandler::setChildHandler(pid_t childPid,
                                        int tag,
                                        child_callback_t handler,
                                        void* userData)
{
    SignalHandler* const self = getInstance();

    self->mLock.lock();

    // First make sure this child hasn't already exited.
    pid_t res = waitpid(childPid, NULL, WNOHANG);
    if (res != 0) {
        if (res < 0) {
            LOGW("setChildHandler waitpid of %d failed: %d (%s)",
                 childPid, res, strerror(errno));
        } else {
            LOGW("setChildHandler waitpid of %d said %d already dead",
                 childPid, res);
        }

        // Some kind of error...  just handle the exit now.
        self->mLock.unlock();

        if (handler) {
            handler(childPid, userData);
        }

        // Return an error code -- 0 means it already exited.
        return (status_t)res;
    }

    ChildHandler entry;
    entry.childPid = childPid;
    entry.tag = tag;
    entry.handler = handler;
    entry.userData = userData;

    // Note: this replaces an existing entry for this pid, if there already
    // is one.  This is the required behavior.
    LOGD("setChildHandler adding pid %d, tag %d, handler %p, data %p",
         childPid, tag, handler, userData);
    self->mChildHandlers.add(childPid, entry);

    self->mLock.unlock();

    return NO_ERROR;
}

void SignalHandler::killAllChildren(int tag)
{
    SignalHandler* const self = getInstance();

    AutoMutex _l (self->mLock);
    const size_t N = self->mChildHandlers.size();
    for (size_t i=0; i<N; i++) {
        const ChildHandler& ch(self->mChildHandlers.valueAt(i));
        if (tag == 0 || ch.tag == tag) {
            const pid_t pid = ch.childPid;
            LOGI("Killing child %d (tag %d)\n", pid, ch.tag);
            kill(pid, SIGKILL);
        }
    }
}

SignalHandler::SignalHandler()
    : mCommandTop(0)
    , mCommandBottom(0)
    , mLostCommands(0)
{
    memset(mCommands, 0, sizeof(mCommands));

    int res = pipe(mAvailMsg);
    LOGE_IF(res != 0, "Unable to create signal handler pipe: %s", strerror(errno));

    mProcessThread = new ProcessThread(*this);
    mProcessThread->run("SignalHandler", PRIORITY_HIGHEST);

    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_sigaction = sigAction;
    sa.sa_flags = SA_NOCLDSTOP|SA_SIGINFO;
    sigaction(SIGCHLD, &sa, NULL);
}

SignalHandler::~SignalHandler()
{
}

SignalHandler* SignalHandler::getInstance()
{
    AutoMutex _l(mInstanceLock);
    if (mInstance == NULL) {
        mInstance = new SignalHandler();
    }
    return mInstance;
}

void SignalHandler::sigAction(int signum, siginfo_t* info, void*)
{
    static const char wakeupMsg[1] = { 0xff };

    // If our signal handler is being called, then we know we have
    // already initialized the SignalHandler class and thus mInstance
    // is valid.
    SignalHandler* const self = mInstance;

    // XXX This is not safe!
    #if 0
    LOGV("Signal %d: signo=%d, errno=%d, code=%d, pid=%d\n",
           signum,
           info->si_signo, info->si_errno, info->si_code,
           info->si_pid);
    #endif

    int32_t oldTop, newTop;

    // Find the next command slot...
    do {
        oldTop = self->mCommandTop;

        newTop = oldTop + 1;
        if (newTop >= COMMAND_QUEUE_SIZE) {
            newTop = 0;
        }

        if (newTop == self->mCommandBottom) {
            // The buffer is filled up!  Ouch!
            // XXX This is not safe!
            #if 0
            LOGE("Command buffer overflow!  newTop=%d\n", newTop);
            #endif
            android_atomic_add(1, &self->mLostCommands);
            write(self->mAvailMsg[1], wakeupMsg, sizeof(wakeupMsg));
            return;
        }
    } while(android_atomic_cmpxchg(oldTop, newTop, &(self->mCommandTop)));

    // Fill in the command data...
    self->mCommands[oldTop].signum = signum;
    self->mCommands[oldTop].info = *info;

    // And now make this command available.
    self->mCommands[oldTop].filled = 1;

    // Wake up the processing thread.
    write(self->mAvailMsg[1], wakeupMsg, sizeof(wakeupMsg));
}

}; // namespace android