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

Commit 9adfeaf0 authored by Colin Cross's avatar Colin Cross
Browse files

Fix building libbinder against musl 

musl libc uses the posix definition of msg_iovlen as int.  Change the
niovs argument to an int, make sure it is not negative, and cast it to
size_t if necessary.

Bug: 190084016
Test: m USE_HOST_MUSL=true host-native
Change-Id: I6ff9206e9e7396f2f89622735f790b4fac18f76c
parent 6d5ef677

libs/binder/RpcState.cpp

+7 −8
Original line number Diff line number Diff line
@@ -310,9 +310,9 @@ RpcState::CommandData::CommandData(size_t size) : mSize(size) { 
}



status_t RpcState::rpcSend(const sp<RpcSession::RpcConnection>& connection,

                           const sp<RpcSession>& session, const char* what, iovec* iovs,

                           size_t niovs, const std::function<status_t()>& altPoll) {

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

                           const sp<RpcSession>& session, const char* what, iovec* iovs, int niovs,

                           const std::function<status_t()>& altPoll) {

    for (int i = 0; i < niovs; i++) {

        LOG_RPC_DETAIL("Sending %s on RpcTransport %p: %s", what, connection->rpcTransport.get(),

                       android::base::HexString(iovs[i].iov_base, iovs[i].iov_len).c_str());

    }
@@ -321,7 +321,7 @@ status_t RpcState::rpcSend(const sp<RpcSession::RpcConnection>& connection, 
                connection->rpcTransport->interruptableWriteFully(session->mShutdownTrigger.get(),

                                                                  iovs, niovs, altPoll);

        status != OK) {

        LOG_RPC_DETAIL("Failed to write %s (%zu iovs) on RpcTransport %p, error: %s", what, niovs,

        LOG_RPC_DETAIL("Failed to write %s (%d iovs) on RpcTransport %p, error: %s", what, niovs,

                       connection->rpcTransport.get(), statusToString(status).c_str());

        (void)session->shutdownAndWait(false);

        return status;
@@ -331,19 +331,18 @@ status_t RpcState::rpcSend(const sp<RpcSession::RpcConnection>& connection, 
}



status_t RpcState::rpcRec(const sp<RpcSession::RpcConnection>& connection,

                          const sp<RpcSession>& session, const char* what, iovec* iovs,

                          size_t niovs) {

                          const sp<RpcSession>& session, const char* what, iovec* iovs, int niovs) {

    if (status_t status =

                connection->rpcTransport->interruptableReadFully(session->mShutdownTrigger.get(),

                                                                 iovs, niovs, {});

        status != OK) {

        LOG_RPC_DETAIL("Failed to read %s (%zu iovs) on RpcTransport %p, error: %s", what, niovs,

        LOG_RPC_DETAIL("Failed to read %s (%d iovs) on RpcTransport %p, error: %s", what, niovs,

                       connection->rpcTransport.get(), statusToString(status).c_str());

        (void)session->shutdownAndWait(false);

        return status;

    }



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

    for (int i = 0; i < niovs; i++) {

        LOG_RPC_DETAIL("Received %s on RpcTransport %p: %s", what, connection->rpcTransport.get(),

                       android::base::HexString(iovs[i].iov_base, iovs[i].iov_len).c_str());

    }

libs/binder/RpcState.h

+2 −3
Original line number Diff line number Diff line
@@ -180,11 +180,10 @@ private: 


    [[nodiscard]] status_t rpcSend(const sp<RpcSession::RpcConnection>& connection,

                                   const sp<RpcSession>& session, const char* what, iovec* iovs,

                                   size_t niovs,

                                   const std::function<status_t()>& altPoll = nullptr);

                                   int niovs, const std::function<status_t()>& altPoll = nullptr);

    [[nodiscard]] status_t rpcRec(const sp<RpcSession::RpcConnection>& connection,

                                  const sp<RpcSession>& session, const char* what, iovec* iovs,

                                  size_t niovs);

                                  int niovs);



    [[nodiscard]] status_t waitForReply(const sp<RpcSession::RpcConnection>& connection,

                                        const sp<RpcSession>& session, Parcel* reply);

libs/binder/RpcTransportRaw.cpp

+10 −4
Original line number Diff line number Diff line
@@ -44,11 +44,15 @@ public: 
    }



    template <typename SendOrReceive>

    status_t interruptableReadOrWrite(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

    status_t interruptableReadOrWrite(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                      SendOrReceive sendOrReceiveFun, const char* funName,

                                      int16_t event, const std::function<status_t()>& altPoll) {

        MAYBE_WAIT_IN_FLAKE_MODE;



        if (niovs < 0) {

            return BAD_VALUE;

        }



        // Since we didn't poll, we need to manually check to see if it was triggered. Otherwise, we

        // may never know we should be shutting down.

        if (fdTrigger->isTriggered()) {
@@ -74,7 +78,9 @@ public: 
        while (true) {

            msghdr msg{

                    .msg_iov = iovs,

                    .msg_iovlen = niovs,

                    // posix uses int, glibc uses size_t.  niovs is a

                    // non-negative int and can be cast to either.

                    .msg_iovlen = static_cast<decltype(msg.msg_iovlen)>(niovs),

            };

            ssize_t processSize =

                    TEMP_FAILURE_RETRY(sendOrReceiveFun(mSocket.get(), &msg, MSG_NOSIGNAL));
@@ -128,13 +134,13 @@ public: 
        }

    }



    status_t interruptableWriteFully(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

    status_t interruptableWriteFully(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                     const std::function<status_t()>& altPoll) override {

        return interruptableReadOrWrite(fdTrigger, iovs, niovs, sendmsg, "sendmsg", POLLOUT,

                                        altPoll);

    }



    status_t interruptableReadFully(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

    status_t interruptableReadFully(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                    const std::function<status_t()>& altPoll) override {

        return interruptableReadOrWrite(fdTrigger, iovs, niovs, recvmsg, "recvmsg", POLLIN,

                                        altPoll);

libs/binder/RpcTransportTls.cpp

+10 −6
Original line number Diff line number Diff line
@@ -275,9 +275,9 @@ public: 
    RpcTransportTls(android::base::unique_fd socket, Ssl ssl)

          : mSocket(std::move(socket)), mSsl(std::move(ssl)) {}

    Result<size_t> peek(void* buf, size_t size) override;

    status_t interruptableWriteFully(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

    status_t interruptableWriteFully(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                     const std::function<status_t()>& altPoll) override;

    status_t interruptableReadFully(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

    status_t interruptableReadFully(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                    const std::function<status_t()>& altPoll) override;



private:
@@ -303,16 +303,18 @@ Result<size_t> RpcTransportTls::peek(void* buf, size_t size) { 
    return ret;

}



status_t RpcTransportTls::interruptableWriteFully(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

status_t RpcTransportTls::interruptableWriteFully(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                                  const std::function<status_t()>& altPoll) {

    MAYBE_WAIT_IN_FLAKE_MODE;



    if (niovs < 0) return BAD_VALUE;



    // Before doing any I/O, check trigger once. This ensures the trigger is checked at least

    // once. The trigger is also checked via triggerablePoll() after every SSL_write().

    if (fdTrigger->isTriggered()) return DEAD_OBJECT;



    size_t size = 0;

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

    for (int i = 0; i < niovs; i++) {

        const iovec& iov = iovs[i];

        if (iov.iov_len == 0) {

            continue;
@@ -343,16 +345,18 @@ status_t RpcTransportTls::interruptableWriteFully(FdTrigger* fdTrigger, iovec* i 
    return OK;

}



status_t RpcTransportTls::interruptableReadFully(FdTrigger* fdTrigger, iovec* iovs, size_t niovs,

status_t RpcTransportTls::interruptableReadFully(FdTrigger* fdTrigger, iovec* iovs, int niovs,

                                                 const std::function<status_t()>& altPoll) {

    MAYBE_WAIT_IN_FLAKE_MODE;



    if (niovs < 0) return BAD_VALUE;



    // Before doing any I/O, check trigger once. This ensures the trigger is checked at least

    // once. The trigger is also checked via triggerablePoll() after every SSL_write().

    if (fdTrigger->isTriggered()) return DEAD_OBJECT;



    size_t size = 0;

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

    for (int i = 0; i < niovs; i++) {

        const iovec& iov = iovs[i];

        if (iov.iov_len == 0) {

            continue;

libs/binder/include/binder/RpcTransport.h

+2 −2
Original line number Diff line number Diff line
@@ -58,10 +58,10 @@ public: 
     *   error - interrupted (failure or trigger)

     */

    [[nodiscard]] virtual status_t interruptableWriteFully(

            FdTrigger *fdTrigger, iovec *iovs, size_t niovs,

            FdTrigger *fdTrigger, iovec *iovs, int niovs,

            const std::function<status_t()> &altPoll) = 0;

    [[nodiscard]] virtual status_t interruptableReadFully(

            FdTrigger *fdTrigger, iovec *iovs, size_t niovs,

            FdTrigger *fdTrigger, iovec *iovs, int niovs,

            const std::function<status_t()> &altPoll) = 0;



protected: