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

Commit 2372f9d8 authored by Steven Moreland's avatar Steven Moreland
Browse files

libbinder: RPC use 'status_t' over 'bool' 

For ease of debugging/handling errors (I realized that binderRpcTest
currently crashes on Pixel 3 because of some missing kernel patches -
this would have been easier with this, and one potential (even if
temporary) solution would be to check the return code).

Bug: 167966510
Test: binderRpcTest, binderRpcBenchmark, binder_parcel_fuzzer,
    binder_rpc_fuzzer, binderHostDeviceTest
Change-Id: I1baa2e9380e0ec8f82f8ceb250f3eeb632dc5fbc
parent 176a33a2

libs/binder/Binder.cpp

+3 −1
Original line number Diff line number Diff line
@@ -555,7 +555,9 @@ status_t BBinder::setRpcClientDebug(android::base::unique_fd socketFd, 
        return status;

    }

    rpcServer->setRootObjectWeak(weakThis);

    rpcServer->setupExternalServer(std::move(socketFd));

    if (auto status = rpcServer->setupExternalServer(std::move(socketFd)); status != OK) {

        return status;

    }

    rpcServer->setMaxThreads(binderThreadPoolMaxCount);

    rpcServer->start();

    e->mRpcServerLinks.emplace(link);

libs/binder/RpcServer.cpp

+22 −21
Original line number Diff line number Diff line
@@ -55,25 +55,25 @@ void RpcServer::iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction() 
    mAgreedExperimental = true;

}



bool RpcServer::setupUnixDomainServer(const char* path) {

status_t RpcServer::setupUnixDomainServer(const char* path) {

    return setupSocketServer(UnixSocketAddress(path));

}



bool RpcServer::setupVsockServer(unsigned int port) {

status_t RpcServer::setupVsockServer(unsigned int port) {

    // realizing value w/ this type at compile time to avoid ubsan abort

    constexpr unsigned int kAnyCid = VMADDR_CID_ANY;



    return setupSocketServer(VsockSocketAddress(kAnyCid, port));

}



bool RpcServer::setupInetServer(const char* address, unsigned int port,

status_t RpcServer::setupInetServer(const char* address, unsigned int port,

                                    unsigned int* assignedPort) {

    if (assignedPort != nullptr) *assignedPort = 0;

    auto aiStart = InetSocketAddress::getAddrInfo(address, port);

    if (aiStart == nullptr) return false;

    if (aiStart == nullptr) return UNKNOWN_ERROR;

    for (auto ai = aiStart.get(); ai != nullptr; ai = ai->ai_next) {

        InetSocketAddress socketAddress(ai->ai_addr, ai->ai_addrlen, address, port);

        if (!setupSocketServer(socketAddress)) {

        if (status_t status = setupSocketServer(socketAddress); status != OK) {

            continue;

        }
@@ -84,7 +84,7 @@ bool RpcServer::setupInetServer(const char* address, unsigned int port, 
            int savedErrno = errno;

            ALOGE("Could not getsockname at %s: %s", socketAddress.toString().c_str(),

                  strerror(savedErrno));

            return false;

            return -savedErrno;

        }

        LOG_ALWAYS_FATAL_IF(len != sizeof(addr), "Wrong socket type: len %zu vs len %zu",

                            static_cast<size_t>(len), sizeof(addr));
@@ -97,11 +97,11 @@ bool RpcServer::setupInetServer(const char* address, unsigned int port, 
            *assignedPort = realPort;

        }



        return true;

        return OK;

    }

    ALOGE("None of the socket address resolved for %s:%u can be set up as inet server.", address,

          port);

    return false;

    return UNKNOWN_ERROR;

}



void RpcServer::setMaxThreads(size_t threads) {
@@ -366,7 +366,7 @@ void RpcServer::establishConnection(sp<RpcServer>&& server, base::unique_fd clie 
        }



        if (incoming) {

            LOG_ALWAYS_FATAL_IF(!session->addOutgoingConnection(std::move(client), true),

            LOG_ALWAYS_FATAL_IF(OK != session->addOutgoingConnection(std::move(client), true),

                                "server state must already be initialized");

            return;

        }
@@ -383,21 +383,22 @@ void RpcServer::establishConnection(sp<RpcServer>&& server, base::unique_fd clie 
    RpcSession::join(std::move(session), std::move(setupResult));

}



bool RpcServer::setupSocketServer(const RpcSocketAddress& addr) {

status_t RpcServer::setupSocketServer(const RpcSocketAddress& addr) {

    LOG_RPC_DETAIL("Setting up socket server %s", addr.toString().c_str());

    LOG_ALWAYS_FATAL_IF(hasServer(), "Each RpcServer can only have one server.");



    unique_fd serverFd(

            TEMP_FAILURE_RETRY(socket(addr.addr()->sa_family, SOCK_STREAM | SOCK_CLOEXEC, 0)));

    if (serverFd == -1) {

        ALOGE("Could not create socket: %s", strerror(errno));

        return false;

        int savedErrno = errno;

        ALOGE("Could not create socket: %s", strerror(savedErrno));

        return -savedErrno;

    }



    if (0 != TEMP_FAILURE_RETRY(bind(serverFd.get(), addr.addr(), addr.addrSize()))) {

        int savedErrno = errno;

        ALOGE("Could not bind socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));

        return false;

        return -savedErrno;

    }



    // Right now, we create all threads at once, making accept4 slow. To avoid hanging the client,
@@ -407,16 +408,16 @@ bool RpcServer::setupSocketServer(const RpcSocketAddress& addr) { 
    if (0 != TEMP_FAILURE_RETRY(listen(serverFd.get(), 50 /*backlog*/))) {

        int savedErrno = errno;

        ALOGE("Could not listen socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));

        return false;

        return -savedErrno;

    }



    LOG_RPC_DETAIL("Successfully setup socket server %s", addr.toString().c_str());



    if (!setupExternalServer(std::move(serverFd))) {

    if (status_t status = setupExternalServer(std::move(serverFd)); status != OK) {

        ALOGE("Another thread has set up server while calling setupSocketServer. Race?");

        return false;

        return status;

    }

    return true;

    return OK;

}



void RpcServer::onSessionAllIncomingThreadsEnded(const sp<RpcSession>& session) {
@@ -449,15 +450,15 @@ unique_fd RpcServer::releaseServer() { 
    return std::move(mServer);

}



bool RpcServer::setupExternalServer(base::unique_fd serverFd) {

status_t RpcServer::setupExternalServer(base::unique_fd serverFd) {

    LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!");

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

    if (mServer.ok()) {

        ALOGE("Each RpcServer can only have one server.");

        return false;

        return INVALID_OPERATION;

    }

    mServer = std::move(serverFd);

    return true;

    return OK;

}



} // namespace android

libs/binder/RpcSession.cpp

+53 −44
Original line number Diff line number Diff line
@@ -107,54 +107,55 @@ std::optional<uint32_t> RpcSession::getProtocolVersion() { 
    return mProtocolVersion;

}



bool RpcSession::setupUnixDomainClient(const char* path) {

status_t RpcSession::setupUnixDomainClient(const char* path) {

    return setupSocketClient(UnixSocketAddress(path));

}



bool RpcSession::setupVsockClient(unsigned int cid, unsigned int port) {

status_t RpcSession::setupVsockClient(unsigned int cid, unsigned int port) {

    return setupSocketClient(VsockSocketAddress(cid, port));

}



bool RpcSession::setupInetClient(const char* addr, unsigned int port) {

status_t RpcSession::setupInetClient(const char* addr, unsigned int port) {

    auto aiStart = InetSocketAddress::getAddrInfo(addr, port);

    if (aiStart == nullptr) return false;

    if (aiStart == nullptr) return UNKNOWN_ERROR;

    for (auto ai = aiStart.get(); ai != nullptr; ai = ai->ai_next) {

        InetSocketAddress socketAddress(ai->ai_addr, ai->ai_addrlen, addr, port);

        if (setupSocketClient(socketAddress)) return true;

        if (status_t status = setupSocketClient(socketAddress); status == OK) return OK;

    }

    ALOGE("None of the socket address resolved for %s:%u can be added as inet client.", addr, port);

    return false;

    return NAME_NOT_FOUND;

}



bool RpcSession::setupPreconnectedClient(unique_fd fd, std::function<unique_fd()>&& request) {

    return setupClient([&](const RpcAddress& sessionId, bool incoming) {

status_t RpcSession::setupPreconnectedClient(unique_fd fd, std::function<unique_fd()>&& request) {

    return setupClient([&](const RpcAddress& sessionId, bool incoming) -> status_t {

        // std::move'd from fd becomes -1 (!ok())

        if (!fd.ok()) {

            fd = request();

            if (!fd.ok()) return false;

            if (!fd.ok()) return BAD_VALUE;

        }

        return initAndAddConnection(std::move(fd), sessionId, incoming);

    });

}



bool RpcSession::addNullDebuggingClient() {

status_t RpcSession::addNullDebuggingClient() {

    // Note: only works on raw sockets.

    unique_fd serverFd(TEMP_FAILURE_RETRY(open("/dev/null", O_WRONLY | O_CLOEXEC)));



    if (serverFd == -1) {

        ALOGE("Could not connect to /dev/null: %s", strerror(errno));

        return false;

        int savedErrno = errno;

        ALOGE("Could not connect to /dev/null: %s", strerror(savedErrno));

        return -savedErrno;

    }



    auto ctx = mRpcTransportCtxFactory->newClientCtx();

    if (ctx == nullptr) {

        ALOGE("Unable to create RpcTransportCtx for null debugging client");

        return false;

        return NO_MEMORY;

    }

    auto server = ctx->newTransport(std::move(serverFd));

    if (server == nullptr) {

        ALOGE("Unable to set up RpcTransport");

        return false;

        return UNKNOWN_ERROR;

    }

    return addOutgoingConnection(std::move(server), false);

}
@@ -475,8 +476,8 @@ sp<RpcServer> RpcSession::server() { 
    return server;

}



bool RpcSession::setupClient(

        const std::function<bool(const RpcAddress& sessionId, bool incoming)>& connectAndInit) {

status_t RpcSession::setupClient(

        const std::function<status_t(const RpcAddress& sessionId, bool incoming)>& connectAndInit) {

    {

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

        LOG_ALWAYS_FATAL_IF(mOutgoingConnections.size() != 0,
@@ -484,18 +485,23 @@ bool RpcSession::setupClient( 
                            mOutgoingConnections.size());

    }



    if (!connectAndInit(RpcAddress::zero(), false /*incoming*/)) return false;

    if (status_t status = connectAndInit(RpcAddress::zero(), false /*incoming*/); status != OK)

        return status;



    {

        ExclusiveConnection connection;

        status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),

        if (status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),

                                                        ConnectionUse::CLIENT, &connection);

        if (status != OK) return false;

            status != OK)

            return status;



        uint32_t version;

        status = state()->readNewSessionResponse(connection.get(),

        if (status_t status =

                    state()->readNewSessionResponse(connection.get(),

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

        if (!setProtocolVersion(version)) return false;

            status != OK)

            return status;

        if (!setProtocolVersion(version)) return BAD_VALUE;

    }



    // TODO(b/189955605): we should add additional sessions dynamically
@@ -505,13 +511,13 @@ bool RpcSession::setupClient( 
    if (status_t status = getRemoteMaxThreads(&numThreadsAvailable); status != OK) {

        ALOGE("Could not get max threads after initial session setup: %s",

              statusToString(status).c_str());

        return false;

        return status;

    }



    if (status_t status = readId(); status != OK) {

        ALOGE("Could not get session id after initial session setup: %s",

              statusToString(status).c_str());

        return false;

        return status;

    }



    // TODO(b/189955605): we should add additional sessions dynamically
@@ -522,24 +528,26 @@ bool RpcSession::setupClient( 


    // we've already setup one client

    for (size_t i = 0; i + 1 < numThreadsAvailable; i++) {

        if (!connectAndInit(mId.value(), false /*incoming*/)) return false;

        if (status_t status = connectAndInit(mId.value(), false /*incoming*/); status != OK)

            return status;

    }



    for (size_t i = 0; i < mMaxThreads; i++) {

        if (!connectAndInit(mId.value(), true /*incoming*/)) return false;

        if (status_t status = connectAndInit(mId.value(), true /*incoming*/); status != OK)

            return status;

    }



    return true;

    return OK;

}



bool RpcSession::setupSocketClient(const RpcSocketAddress& addr) {

status_t RpcSession::setupSocketClient(const RpcSocketAddress& addr) {

    return setupClient([&](const RpcAddress& sessionId, bool incoming) {

        return setupOneSocketConnection(addr, sessionId, incoming);

    });

}



bool RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr, const RpcAddress& sessionId,

                                          bool incoming) {

status_t RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr,

                                              const RpcAddress& sessionId, bool incoming) {

    for (size_t tries = 0; tries < 5; tries++) {

        if (tries > 0) usleep(10000);
@@ -549,7 +557,7 @@ bool RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr, const Rp 
            int savedErrno = errno;

            ALOGE("Could not create socket at %s: %s", addr.toString().c_str(),

                  strerror(savedErrno));

            return false;

            return -savedErrno;

        }



        if (0 != TEMP_FAILURE_RETRY(connect(serverFd.get(), addr.addr(), addr.addrSize()))) {
@@ -560,7 +568,7 @@ bool RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr, const Rp 
            int savedErrno = errno;

            ALOGE("Could not connect socket at %s: %s", addr.toString().c_str(),

                  strerror(savedErrno));

            return false;

            return -savedErrno;

        }

        LOG_RPC_DETAIL("Socket at %s client with fd %d", addr.toString().c_str(), serverFd.get());
@@ -568,20 +576,21 @@ bool RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr, const Rp 
    }



    ALOGE("Ran out of retries to connect to %s", addr.toString().c_str());

    return false;

    return UNKNOWN_ERROR;

}



bool RpcSession::initAndAddConnection(unique_fd fd, const RpcAddress& sessionId, bool incoming) {

status_t RpcSession::initAndAddConnection(unique_fd fd, const RpcAddress& sessionId,

                                          bool incoming) {

    auto ctx = mRpcTransportCtxFactory->newClientCtx();

    if (ctx == nullptr) {

        ALOGE("Unable to create client RpcTransportCtx with %s sockets",

              mRpcTransportCtxFactory->toCString());

        return false;

        return NO_MEMORY;

    }

    auto server = ctx->newTransport(std::move(fd));

    if (server == nullptr) {

        ALOGE("Unable to set up RpcTransport in %s context", mRpcTransportCtxFactory->toCString());

        return false;

        return UNKNOWN_ERROR;

    }



    LOG_RPC_DETAIL("Socket at client with RpcTransport %p", server.get());
@@ -598,12 +607,12 @@ bool RpcSession::initAndAddConnection(unique_fd fd, const RpcAddress& sessionId, 
    if (!sentHeader.ok()) {

        ALOGE("Could not write connection header to socket: %s",

              sentHeader.error().message().c_str());

        return false;

        return -sentHeader.error().code();

    }

    if (*sentHeader != sizeof(header)) {

        ALOGE("Could not write connection header to socket: sent %zd bytes, expected %zd",

              *sentHeader, sizeof(header));

        return false;

        return UNKNOWN_ERROR;

    }



    LOG_RPC_DETAIL("Socket at client: header sent");
@@ -615,7 +624,7 @@ bool RpcSession::initAndAddConnection(unique_fd fd, const RpcAddress& sessionId, 
    }

}



bool RpcSession::addIncomingConnection(std::unique_ptr<RpcTransport> rpcTransport) {

status_t RpcSession::addIncomingConnection(std::unique_ptr<RpcTransport> rpcTransport) {

    std::mutex mutex;

    std::condition_variable joinCv;

    std::unique_lock<std::mutex> lock(mutex);
@@ -641,10 +650,10 @@ bool RpcSession::addIncomingConnection(std::unique_ptr<RpcTransport> rpcTranspor 
    });

    joinCv.wait(lock, [&] { return ownershipTransferred; });

    LOG_ALWAYS_FATAL_IF(!ownershipTransferred);

    return true;

    return OK;

}



bool RpcSession::addOutgoingConnection(std::unique_ptr<RpcTransport> rpcTransport, bool init) {

status_t RpcSession::addOutgoingConnection(std::unique_ptr<RpcTransport> rpcTransport, bool init) {

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

    {

        std::lock_guard<std::mutex> _l(mMutex);
@@ -654,7 +663,7 @@ bool RpcSession::addOutgoingConnection(std::unique_ptr<RpcTransport> rpcTranspor 
        if (mShutdownTrigger == nullptr) {

            mShutdownTrigger = FdTrigger::make();

            mEventListener = mShutdownListener = sp<WaitForShutdownListener>::make();

            if (mShutdownTrigger == nullptr) return false;

            if (mShutdownTrigger == nullptr) return INVALID_OPERATION;

        }



        connection->rpcTransport = std::move(rpcTransport);
@@ -672,7 +681,7 @@ bool RpcSession::addOutgoingConnection(std::unique_ptr<RpcTransport> rpcTranspor 
        connection->exclusiveTid = std::nullopt;

    }



    return status == OK;

    return status;

}



bool RpcSession::setForServer(const wp<RpcServer>& server, const wp<EventListener>& eventListener,

libs/binder/ServiceManagerHost.cpp

+4 −2
Original line number Diff line number Diff line
@@ -158,8 +158,10 @@ sp<IBinder> getDeviceService(std::vector<std::string>&& serviceDispatcherArgs) { 
    LOG_ALWAYS_FATAL_IF(!forwardResult->hostPort().has_value());



    auto rpcSession = RpcSession::make();

    if (!rpcSession->setupInetClient("127.0.0.1", *forwardResult->hostPort())) {

        ALOGE("Unable to set up inet client on host port %u", *forwardResult->hostPort());

    if (status_t status = rpcSession->setupInetClient("127.0.0.1", *forwardResult->hostPort());

        status != OK) {

        ALOGE("Unable to set up inet client on host port %u: %s", *forwardResult->hostPort(),

              statusToString(status).c_str());

        return nullptr;

    }

    auto binder = rpcSession->getRootObject();

libs/binder/include/binder/RpcServer.h

+6 −6
Original line number Diff line number Diff line
@@ -59,12 +59,12 @@ public: 
     *     process B makes binder b and sends it to A

     *     A uses this 'back session' to send things back to B

     */

    [[nodiscard]] bool setupUnixDomainServer(const char* path);

    [[nodiscard]] status_t setupUnixDomainServer(const char* path);



    /**

     * Creates an RPC server at the current port.

     */

    [[nodiscard]] bool setupVsockServer(unsigned int port);

    [[nodiscard]] status_t setupVsockServer(unsigned int port);



    /**

     * Creates an RPC server at the current port using IPv4.
@@ -80,7 +80,7 @@ public: 
     * "0.0.0.0" allows for connections on any IP address that the device may

     * have

     */

    [[nodiscard]] bool setupInetServer(const char* address, unsigned int port,

    [[nodiscard]] status_t setupInetServer(const char* address, unsigned int port,

                                           unsigned int* assignedPort);



    /**
@@ -97,7 +97,7 @@ public: 
     * Set up server using an external FD previously set up by releaseServer().

     * Return false if there's already a server.

     */

    bool setupExternalServer(base::unique_fd serverFd);

    [[nodiscard]] status_t setupExternalServer(base::unique_fd serverFd);



    void iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction();
@@ -175,7 +175,7 @@ private: 
    void onSessionIncomingThreadEnded() override;



    static void establishConnection(sp<RpcServer>&& server, base::unique_fd clientFd);

    bool setupSocketServer(const RpcSocketAddress& address);

    status_t setupSocketServer(const RpcSocketAddress& address);



    const std::unique_ptr<RpcTransportCtxFactory> mRpcTransportCtxFactory;

    bool mAgreedExperimental = false;