Merge "libbinder: s/mClients|mServers/\0Connections/g" am: ca4019be

    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.");

}

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;

    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) {

    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;

        // 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

        // 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)

        // 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 */);

        }

        }

        // 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--;

        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.

    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;

};