Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8d96cab8 authored by Todd Poynor's avatar Todd Poynor
Browse files

binder: add polling / single-threaded operation 

This is currently safe to do only for processes that disallow any binder
threads to be created: setThreadPoolMaxThreadCount(0).

Change-Id: I8a27f3cf26f4d51edb7f222af487ac256cbcab65
parent 3e5fa737

include/binder/IPCThreadState.h

+4 −0
Original line number Diff line number Diff line
@@ -51,6 +51,8 @@ public: 
            int64_t             clearCallingIdentity();

            void                restoreCallingIdentity(int64_t token);

            

            int                 setupPolling(int* fd);

            status_t            handlePolledCommands();

            void                flushCommands();



            void                joinThreadPool(bool isMain = true);
@@ -96,7 +98,9 @@ private: 
                                                     uint32_t code,

                                                     const Parcel& data,

                                                     status_t* statusBuffer);

            status_t            getAndExecuteCommand();

            status_t            executeCommand(int32_t command);

            void                processPendingDerefs();

            

            void                clearCaller();

libs/binder/IPCThreadState.cpp

+88 −51
Original line number Diff line number Diff line
@@ -418,22 +418,39 @@ void IPCThreadState::flushCommands() 
    talkWithDriver(false);

}



void IPCThreadState::joinThreadPool(bool isMain)

status_t IPCThreadState::getAndExecuteCommand()

{

    LOG_THREADPOOL("**** THREAD %p (PID %d) IS JOINING THE THREAD POOL\n", (void*)pthread_self(), getpid());

    status_t result;

    int32_t cmd;



    mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

    result = talkWithDriver();

    if (result >= NO_ERROR) {

        size_t IN = mIn.dataAvail();

        if (IN < sizeof(int32_t)) return result;

        cmd = mIn.readInt32();

        IF_LOG_COMMANDS() {

            alog << "Processing top-level Command: "

                 << getReturnString(cmd) << endl;

        }



    // This thread may have been spawned by a thread that was in the background

    // scheduling group, so first we will make sure it is in the foreground

    // one to avoid performing an initial transaction in the background.

        result = executeCommand(cmd);



        // After executing the command, ensure that the thread is returned to the

        // foreground cgroup before rejoining the pool.  The driver takes care of

        // restoring the priority, but doesn't do anything with cgroups so we

        // need to take care of that here in userspace.  Note that we do make

        // sure to go in the foreground after executing a transaction, but

        // there are other callbacks into user code that could have changed

        // our group so we want to make absolutely sure it is put back.

        set_sched_policy(mMyThreadId, SP_FOREGROUND);

    }



    status_t result;

    do {

        int32_t cmd;

    return result;

}



// When we've cleared the incoming command queue, process any pending derefs

void IPCThreadState::processPendingDerefs()

{

    if (mIn.dataPosition() >= mIn.dataSize()) {

        size_t numPending = mPendingWeakDerefs.size();

        if (numPending > 0) {
@@ -453,35 +470,31 @@ void IPCThreadState::joinThreadPool(bool isMain) 
            mPendingStrongDerefs.clear();

        }

    }



        // now get the next command to be processed, waiting if necessary

        result = talkWithDriver();

        if (result >= NO_ERROR) {

            size_t IN = mIn.dataAvail();

            if (IN < sizeof(int32_t)) continue;

            cmd = mIn.readInt32();

            IF_LOG_COMMANDS() {

                alog << "Processing top-level Command: "

                    << getReturnString(cmd) << endl;

}



void IPCThreadState::joinThreadPool(bool isMain)

{

    LOG_THREADPOOL("**** THREAD %p (PID %d) IS JOINING THE THREAD POOL\n", (void*)pthread_self(), getpid());



            result = executeCommand(cmd);

        } else if (result != TIMED_OUT && result != -ECONNREFUSED && result != -EBADF) {

            ALOGE("talkWithDriver(fd=%d) returned unexpected error %d, aborting",

    mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

    

    // This thread may have been spawned by a thread that was in the background

    // scheduling group, so first we will make sure it is in the foreground

    // one to avoid performing an initial transaction in the background.

    set_sched_policy(mMyThreadId, SP_FOREGROUND);

        

    status_t result;

    do {

        processPendingDerefs();

        // now get the next command to be processed, waiting if necessary

        result = getAndExecuteCommand();



        if (result < NO_ERROR && result != TIMED_OUT && result != -ECONNREFUSED && result != -EBADF) {

            ALOGE("getAndExecuteCommand(fd=%d) returned unexpected error %d, aborting",

                  mProcess->mDriverFD, result);

            abort();

        }

        

        // After executing the command, ensure that the thread is returned to the

        // foreground cgroup before rejoining the pool.  The driver takes care of

        // restoring the priority, but doesn't do anything with cgroups so we

        // need to take care of that here in userspace.  Note that we do make

        // sure to go in the foreground after executing a transaction, but

        // there are other callbacks into user code that could have changed

        // our group so we want to make absolutely sure it is put back.

        set_sched_policy(mMyThreadId, SP_FOREGROUND);



        // Let this thread exit the thread pool if it is no longer

        // needed and it is not the main process thread.

        if(result == TIMED_OUT && !isMain) {
@@ -496,6 +509,30 @@ void IPCThreadState::joinThreadPool(bool isMain) 
    talkWithDriver(false);

}



int IPCThreadState::setupPolling(int* fd)

{

    if (mProcess->mDriverFD <= 0) {

        return -EBADF;

    }



    mOut.writeInt32(BC_ENTER_LOOPER);

    *fd = mProcess->mDriverFD;

    return 0;

}



status_t IPCThreadState::handlePolledCommands()

{

    status_t result;



    do {

        result = getAndExecuteCommand();

    } while (mIn.dataPosition() < mIn.dataSize());



    processPendingDerefs();

    flushCommands();

    return result;

}



void IPCThreadState::stopProcess(bool immediate)

{

    //ALOGI("**** STOPPING PROCESS");