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

Commit dfb8bb84 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "libbinder: allow multiple outgoing threads for single-threaded" am:... 

Merge "libbinder: allow multiple outgoing threads for single-threaded" am: 1c63a158 am: 6daa07a8 am: ee057f40 am: bc3d4de0

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/2167825



Change-Id: Ife033ca0c1c9056acd18fa625ab1039276aacfe0
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fa5d19d3 bc3d4de0

libs/binder/RpcSession.cpp

+26 −17
Original line number Original line Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include <utils/Compat.h>

#include <utils/Compat.h>

#include <utils/String8.h>

#include <utils/String8.h>





#include "BuildFlags.h"

#include "FdTrigger.h"

#include "FdTrigger.h"

#include "OS.h"

#include "OS.h"

#include "RpcSocketAddress.h"

#include "RpcSocketAddress.h"
@@ -78,10 +79,8 @@ sp<RpcSession> RpcSession::make(std::unique_ptr<RpcTransportCtxFactory> rpcTrans 




void RpcSession::setMaxIncomingThreads(size_t threads) {

void RpcSession::setMaxIncomingThreads(size_t threads) {

    RpcMutexLockGuard _l(mMutex);

    RpcMutexLockGuard _l(mMutex);

    LOG_ALWAYS_FATAL_IF(!mConnections.mOutgoing.empty() || !mConnections.mIncoming.empty(),

    LOG_ALWAYS_FATAL_IF(mStartedSetup,

                        "Must set max incoming threads before setting up connections, but has %zu "

                        "Must set max incoming threads before setting up connections");

                        "client(s) and %zu server(s)",

                        mConnections.mOutgoing.size(), mConnections.mIncoming.size());

    mMaxIncomingThreads = threads;

    mMaxIncomingThreads = threads;

}

}
@@ -92,10 +91,8 @@ size_t RpcSession::getMaxIncomingThreads() { 




void RpcSession::setMaxOutgoingThreads(size_t threads) {

void RpcSession::setMaxOutgoingThreads(size_t threads) {

    RpcMutexLockGuard _l(mMutex);

    RpcMutexLockGuard _l(mMutex);

    LOG_ALWAYS_FATAL_IF(!mConnections.mOutgoing.empty() || !mConnections.mIncoming.empty(),

    LOG_ALWAYS_FATAL_IF(mStartedSetup,

                        "Must set max outgoing threads before setting up connections, but has %zu "

                        "Must set max outgoing threads before setting up connections");

                        "client(s) and %zu server(s)",

                        mConnections.mOutgoing.size(), mConnections.mIncoming.size());

    mMaxOutgoingThreads = threads;

    mMaxOutgoingThreads = threads;

}

}
@@ -104,7 +101,7 @@ size_t RpcSession::getMaxOutgoingThreads() { 
    return mMaxOutgoingThreads;

    return mMaxOutgoingThreads;

}

}





bool RpcSession::setProtocolVersion(uint32_t version) {

bool RpcSession::setProtocolVersionInternal(uint32_t version, bool checkStarted) {

    if (version >= RPC_WIRE_PROTOCOL_VERSION_NEXT &&

    if (version >= RPC_WIRE_PROTOCOL_VERSION_NEXT &&

        version != RPC_WIRE_PROTOCOL_VERSION_EXPERIMENTAL) {

        version != RPC_WIRE_PROTOCOL_VERSION_EXPERIMENTAL) {

        ALOGE("Cannot start RPC session with version %u which is unknown (current protocol version "

        ALOGE("Cannot start RPC session with version %u which is unknown (current protocol version "
@@ -114,6 +111,8 @@ bool RpcSession::setProtocolVersion(uint32_t version) { 
    }

    }





    RpcMutexLockGuard _l(mMutex);

    RpcMutexLockGuard _l(mMutex);

    LOG_ALWAYS_FATAL_IF(checkStarted && mStartedSetup,

                        "Must set protocol version before setting up connections");

    if (mProtocolVersion && version > *mProtocolVersion) {

    if (mProtocolVersion && version > *mProtocolVersion) {

        ALOGE("Cannot upgrade explicitly capped protocol version %u to newer version %u",

        ALOGE("Cannot upgrade explicitly capped protocol version %u to newer version %u",

              *mProtocolVersion, version);

              *mProtocolVersion, version);
@@ -124,12 +123,19 @@ bool RpcSession::setProtocolVersion(uint32_t version) { 
    return true;

    return true;

}

}





bool RpcSession::setProtocolVersion(uint32_t version) {

    return setProtocolVersionInternal(version, true);

}



std::optional<uint32_t> RpcSession::getProtocolVersion() {

std::optional<uint32_t> RpcSession::getProtocolVersion() {

    RpcMutexLockGuard _l(mMutex);

    RpcMutexLockGuard _l(mMutex);

    return mProtocolVersion;

    return mProtocolVersion;

}

}





void RpcSession::setFileDescriptorTransportMode(FileDescriptorTransportMode mode) {

void RpcSession::setFileDescriptorTransportMode(FileDescriptorTransportMode mode) {

    RpcMutexLockGuard _l(mMutex);

    LOG_ALWAYS_FATAL_IF(mStartedSetup,

                        "Must set file descriptor transport mode before setting up connections");

    mFileDescriptorTransportMode = mode;

    mFileDescriptorTransportMode = mode;

}

}
@@ -445,9 +451,16 @@ status_t RpcSession::setupClient(const std::function<status_t(const std::vector< 
                                                              bool incoming)>& connectAndInit) {

                                                              bool incoming)>& connectAndInit) {

    {

    {

        RpcMutexLockGuard _l(mMutex);

        RpcMutexLockGuard _l(mMutex);

        LOG_ALWAYS_FATAL_IF(mConnections.mOutgoing.size() != 0,

        LOG_ALWAYS_FATAL_IF(mStartedSetup, "Must only setup session once");

                            "Must only setup session once, but already has %zu clients",

        mStartedSetup = true;

                            mConnections.mOutgoing.size());



        if constexpr (!kEnableRpcThreads) {

            LOG_ALWAYS_FATAL_IF(mMaxIncomingThreads > 0,

                                "Incoming threads are not supported on single-threaded libbinder");

            // mMaxIncomingThreads should not change from here to its use below,

            // since we set mStartedSetup==true and setMaxIncomingThreads checks

            // for that

        }

    }

    }





    if (auto status = initShutdownTrigger(); status != OK) return status;

    if (auto status = initShutdownTrigger(); status != OK) return status;
@@ -488,7 +501,7 @@ status_t RpcSession::setupClient(const std::function<status_t(const std::vector< 
                                                    sp<RpcSession>::fromExisting(this), &version);

                                                    sp<RpcSession>::fromExisting(this), &version);

            status != OK)

            status != OK)

            return status;

            return status;

        if (!setProtocolVersion(version)) return BAD_VALUE;

        if (!setProtocolVersionInternal(version, false)) return BAD_VALUE;

    }

    }





    // TODO(b/189955605): we should add additional sessions dynamically

    // TODO(b/189955605): we should add additional sessions dynamically
@@ -506,11 +519,7 @@ status_t RpcSession::setupClient(const std::function<status_t(const std::vector< 
        return status;

        return status;

    }

    }





#ifdef BINDER_RPC_SINGLE_THREADED

    constexpr size_t outgoingThreads = 1;

#else  // BINDER_RPC_SINGLE_THREADED

    size_t outgoingThreads = std::min(numThreadsAvailable, mMaxOutgoingThreads);

    size_t outgoingThreads = std::min(numThreadsAvailable, mMaxOutgoingThreads);

#endif // BINDER_RPC_SINGLE_THREADED

    ALOGI_IF(outgoingThreads != numThreadsAvailable,

    ALOGI_IF(outgoingThreads != numThreadsAvailable,

             "Server hints client to start %zu outgoing threads, but client will only start %zu "

             "Server hints client to start %zu outgoing threads, but client will only start %zu "

             "because it is preconfigured to start at most %zu outgoing threads.",

             "because it is preconfigured to start at most %zu outgoing threads.",

libs/binder/include/binder/RpcSession.h

+5 −0
Original line number Original line Diff line number Diff line
@@ -207,6 +207,10 @@ private: 
    friend RpcState;

    friend RpcState;

    explicit RpcSession(std::unique_ptr<RpcTransportCtx> ctx);

    explicit RpcSession(std::unique_ptr<RpcTransportCtx> ctx);





    // internal version of setProtocolVersion that

    // optionally skips the mStartedSetup check

    [[nodiscard]] bool setProtocolVersionInternal(uint32_t version, bool checkStarted);



    // for 'target', see RpcState::sendDecStrongToTarget

    // for 'target', see RpcState::sendDecStrongToTarget

    [[nodiscard]] status_t sendDecStrongToTarget(uint64_t address, size_t target);

    [[nodiscard]] status_t sendDecStrongToTarget(uint64_t address, size_t target);
@@ -344,6 +348,7 @@ private: 




    RpcMutex mMutex; // for all below

    RpcMutex mMutex; // for all below





    bool mStartedSetup = false;

    size_t mMaxIncomingThreads = 0;

    size_t mMaxIncomingThreads = 0;

    size_t mMaxOutgoingThreads = kDefaultMaxOutgoingThreads;

    size_t mMaxOutgoingThreads = kDefaultMaxOutgoingThreads;

    std::optional<uint32_t> mProtocolVersion;

    std::optional<uint32_t> mProtocolVersion;