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

Commit bb543a85 authored by Steven Moreland's avatar Steven Moreland
Browse files

libbinder: s/mClients|mServers/\0Connections/g 

As requested by jiyong@ - to distinguish libbinder RpcServer from the
TCP connections used as server connections.

Bug: N/A
Test: N/A
Change-Id: If39ad30fc20ae660f2ea911b54c30e760e061f49
parent 4fccd098

libs/binder/RpcSession.cpp

+17 −14
Original line number Diff line number Diff line
@@ -49,7 +49,7 @@ RpcSession::~RpcSession() { 
    LOG_RPC_DETAIL("RpcSession destroyed %p", this);



    std::lock_guard<std::mutex> _l(mMutex);

    LOG_ALWAYS_FATAL_IF(mServers.size() != 0,

    LOG_ALWAYS_FATAL_IF(mServerConnections.size() != 0,

                        "Should not be able to destroy a session with servers in use.");

}
@@ -194,9 +194,9 @@ wp<RpcServer> RpcSession::server() { 
bool RpcSession::setupSocketClient(const RpcSocketAddress& addr) {

    {

        std::lock_guard<std::mutex> _l(mMutex);

        LOG_ALWAYS_FATAL_IF(mClients.size() != 0,

        LOG_ALWAYS_FATAL_IF(mClientConnections.size() != 0,

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

                            mClients.size());

                            mClientConnections.size());

    }



    if (!setupOneSocketClient(addr, RPC_SESSION_ID_NEW)) return false;
@@ -261,7 +261,7 @@ void RpcSession::addClient(unique_fd fd) { 
    std::lock_guard<std::mutex> _l(mMutex);

    sp<RpcConnection> session = sp<RpcConnection>::make();

    session->fd = std::move(fd);

    mClients.push_back(session);

    mClientConnections.push_back(session);

}



void RpcSession::setForServer(const wp<RpcServer>& server, int32_t sessionId) {
@@ -274,16 +274,17 @@ sp<RpcSession::RpcConnection> RpcSession::assignServerToThisThread(unique_fd fd) 
    sp<RpcConnection> session = sp<RpcConnection>::make();

    session->fd = std::move(fd);

    session->exclusiveTid = gettid();

    mServers.push_back(session);

    mServerConnections.push_back(session);



    return session;

}



bool RpcSession::removeServerConnection(const sp<RpcConnection>& connection) {

    std::lock_guard<std::mutex> _l(mMutex);

    if (auto it = std::find(mServers.begin(), mServers.end(), connection); it != mServers.end()) {

        mServers.erase(it);

        if (mServers.size() == 0) {

    if (auto it = std::find(mServerConnections.begin(), mServerConnections.end(), connection);

        it != mServerConnections.end()) {

        mServerConnections.erase(it);

        if (mServerConnections.size() == 0) {

            terminateLocked();

        }

        return true;
@@ -305,10 +306,11 @@ RpcSession::ExclusiveConnection::ExclusiveConnection(const sp<RpcSession>& sessi 
        // CHECK FOR DEDICATED CLIENT SOCKET

        //

        // A server/looper should always use a dedicated session if available

        findConnection(tid, &exclusive, &available, mSession->mClients, mSession->mClientsOffset);

        findConnection(tid, &exclusive, &available, mSession->mClientConnections,

                       mSession->mClientConnectionsOffset);



        // WARNING: this assumes a server cannot request its client to send

        // a transaction, as mServers is excluded below.

        // a transaction, as mServerConnections is excluded below.

        //

        // Imagine we have more than one thread in play, and a single thread

        // sends a synchronous, then an asynchronous command. Imagine the
@@ -318,7 +320,8 @@ RpcSession::ExclusiveConnection::ExclusiveConnection(const sp<RpcSession>& sessi 
        // command. So, we move to considering the second available thread

        // for subsequent calls.

        if (use == ConnectionUse::CLIENT_ASYNC && (exclusive != nullptr || available != nullptr)) {

            mSession->mClientsOffset = (mSession->mClientsOffset + 1) % mSession->mClients.size();

            mSession->mClientConnectionsOffset =

                    (mSession->mClientConnectionsOffset + 1) % mSession->mClientConnections.size();

        }



        // USE SERVING SOCKET (for nested transaction)
@@ -326,7 +329,7 @@ RpcSession::ExclusiveConnection::ExclusiveConnection(const sp<RpcSession>& sessi 
        // asynchronous calls cannot be nested

        if (use != ConnectionUse::CLIENT_ASYNC) {

            // server connections are always assigned to a thread

            findConnection(tid, &exclusive, nullptr /*available*/, mSession->mServers,

            findConnection(tid, &exclusive, nullptr /*available*/, mSession->mServerConnections,

                           0 /* index hint */);

        }
@@ -342,13 +345,13 @@ RpcSession::ExclusiveConnection::ExclusiveConnection(const sp<RpcSession>& sessi 
        }



        // in regular binder, this would usually be a deadlock :)

        LOG_ALWAYS_FATAL_IF(mSession->mClients.size() == 0,

        LOG_ALWAYS_FATAL_IF(mSession->mClientConnections.size() == 0,

                            "Not a client of any session. You must create a session to an "

                            "RPC server to make any non-nested (e.g. oneway or on another thread) "

                            "calls.");



        LOG_RPC_DETAIL("No available session (have %zu clients and %zu servers). Waiting...",

                       mSession->mClients.size(), mSession->mServers.size());

                       mSession->mClientConnections.size(), mSession->mServerConnections.size());

        mSession->mAvailableConnectionCv.wait(_l);

    }

    mSession->mWaitingThreads--;

libs/binder/include/binder/RpcSession.h

+9 −8
Original line number Diff line number Diff line
@@ -163,13 +163,13 @@ private: 
        bool mReentrant = false;

    };



    // On the other side of a session, for each of mClients here, there should

    // be one of mServers on the other side (and vice versa).

    // On the other side of a session, for each of mClientConnections here, there should

    // be one of mServerConnections on the other side (and vice versa).

    //

    // For the simplest session, a single server with one client, you would

    // have:

    //  - the server has a single 'mServers' and a thread listening on this

    //  - the client has a single 'mClients' and makes calls to this

    //  - the server has a single 'mServerConnections' and a thread listening on this

    //  - the client has a single 'mClientConnections' and makes calls to this

    //  - here, when the client makes a call, the server can call back into it

    //    (nested calls), but outside of this, the client will only ever read

    //    calls from the server when it makes a call itself.
@@ -188,14 +188,15 @@ private: 


    std::condition_variable mAvailableConnectionCv; // for mWaitingThreads

    size_t mWaitingThreads = 0;

    size_t mClientsOffset = 0; // hint index into clients, ++ when sending an async transaction

    std::vector<sp<RpcConnection>> mClients;

    std::vector<sp<RpcConnection>> mServers;

    // hint index into clients, ++ when sending an async transaction

    size_t mClientConnectionsOffset = 0;

    std::vector<sp<RpcConnection>> mClientConnections;

    std::vector<sp<RpcConnection>> mServerConnections;



    // TODO(b/185167543): use for reverse sessions (allow client to also

    // serve calls on a session).

    // TODO(b/185167543): allow sharing between different sessions in a

    // process? (or combine with mServers)

    // process? (or combine with mServerConnections)

    std::map<std::thread::id, std::thread> mThreads;

    bool mTerminated = false;

};