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

Commit 1a0d924b authored by Colin Cross's avatar Colin Cross Committed by Automerger Merge Worker
Browse files

Merge "Fix building libbinder against musl" am: c2f1f144

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

Change-Id: If34672af8d87890727471e18835d54cc6e8e8138
parents 6191fc04 c2f1f144
Loading
Loading
Loading
Loading
+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());
    }
+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);
+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);
+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;
+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: