Merge "Fix building libbinder against musl" (c2f1f144) · Commits · e / devices / smdk4412 / android_frameworks_native

libs/binder/RpcState.cpp

+7 −8

Original line number	Original line	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,		status_t RpcState::rpcSend(const sp<RpcSession::RpcConnection>& connection,
	const sp<RpcSession>& session, const char* what, iovec* iovs,		const sp<RpcSession>& session, const char* what, iovec* iovs, int niovs,
	size_t niovs, const std::function<status_t()>& altPoll) {		const std::function<status_t()>& altPoll) {
	for (size_t i = 0; i < niovs; i++) {		for (int i = 0; i < niovs; i++) {
	LOG_RPC_DETAIL("Sending %s on RpcTransport %p: %s", what, connection->rpcTransport.get(),		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());		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(),		connection->rpcTransport->interruptableWriteFully(session->mShutdownTrigger.get(),
	iovs, niovs, altPoll);		iovs, niovs, altPoll);
	status != OK) {		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());		connection->rpcTransport.get(), statusToString(status).c_str());
	(void)session->shutdownAndWait(false);		(void)session->shutdownAndWait(false);
	return status;		return status;
	@@ -331,19 +331,18 @@ status_t RpcState::rpcSend(const sp<RpcSession::RpcConnection>& connection,
	}		}

	status_t RpcState::rpcRec(const sp<RpcSession::RpcConnection>& connection,		status_t RpcState::rpcRec(const sp<RpcSession::RpcConnection>& connection,
	const sp<RpcSession>& session, const char* what, iovec* iovs,		const sp<RpcSession>& session, const char* what, iovec* iovs, int niovs) {
	size_t niovs) {
	if (status_t status =		if (status_t status =
	connection->rpcTransport->interruptableReadFully(session->mShutdownTrigger.get(),		connection->rpcTransport->interruptableReadFully(session->mShutdownTrigger.get(),
	iovs, niovs, {});		iovs, niovs, {});
	status != OK) {		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());		connection->rpcTransport.get(), statusToString(status).c_str());
	(void)session->shutdownAndWait(false);		(void)session->shutdownAndWait(false);
	return status;		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(),		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());		android::base::HexString(iovs[i].iov_base, iovs[i].iov_len).c_str());
	}		}

libs/binder/RpcState.h

+2 −3

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

	[[nodiscard]] status_t rpcSend(const sp<RpcSession::RpcConnection>& connection,		[[nodiscard]] status_t rpcSend(const sp<RpcSession::RpcConnection>& connection,
	const sp<RpcSession>& session, const char* what, iovec* iovs,		const sp<RpcSession>& session, const char* what, iovec* iovs,
	size_t niovs,		int niovs, const std::function<status_t()>& altPoll = nullptr);
	const std::function<status_t()>& altPoll = nullptr);
	[[nodiscard]] status_t rpcRec(const sp<RpcSession::RpcConnection>& connection,		[[nodiscard]] status_t rpcRec(const sp<RpcSession::RpcConnection>& connection,
	const sp<RpcSession>& session, const char* what, iovec* iovs,		const sp<RpcSession>& session, const char* what, iovec* iovs,
	size_t niovs);		int niovs);

	[[nodiscard]] status_t waitForReply(const sp<RpcSession::RpcConnection>& connection,		[[nodiscard]] status_t waitForReply(const sp<RpcSession::RpcConnection>& connection,
	const sp<RpcSession>& session, Parcel* reply);		const sp<RpcSession>& session, Parcel* reply);

libs/binder/RpcTransportRaw.cpp

+10 −4

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

	template <typename SendOrReceive>		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,		SendOrReceive sendOrReceiveFun, const char* funName,
	int16_t event, const std::function<status_t()>& altPoll) {		int16_t event, const std::function<status_t()>& altPoll) {
	MAYBE_WAIT_IN_FLAKE_MODE;		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		// 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.		// may never know we should be shutting down.
	if (fdTrigger->isTriggered()) {		if (fdTrigger->isTriggered()) {
	@@ -74,7 +78,9 @@ public:
	while (true) {		while (true) {
	msghdr msg{		msghdr msg{
	.msg_iov = iovs,		.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 =		ssize_t processSize =
	TEMP_FAILURE_RETRY(sendOrReceiveFun(mSocket.get(), &msg, MSG_NOSIGNAL));		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 {		const std::function<status_t()>& altPoll) override {
	return interruptableReadOrWrite(fdTrigger, iovs, niovs, sendmsg, "sendmsg", POLLOUT,		return interruptableReadOrWrite(fdTrigger, iovs, niovs, sendmsg, "sendmsg", POLLOUT,
	altPoll);		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 {		const std::function<status_t()>& altPoll) override {
	return interruptableReadOrWrite(fdTrigger, iovs, niovs, recvmsg, "recvmsg", POLLIN,		return interruptableReadOrWrite(fdTrigger, iovs, niovs, recvmsg, "recvmsg", POLLIN,
	altPoll);		altPoll);

libs/binder/RpcTransportTls.cpp

+10 −6

Original line number	Original line	Diff line number	Diff line
	@@ -275,9 +275,9 @@ public:
	RpcTransportTls(android::base::unique_fd socket, Ssl ssl)		RpcTransportTls(android::base::unique_fd socket, Ssl ssl)
	: mSocket(std::move(socket)), mSsl(std::move(ssl)) {}		: mSocket(std::move(socket)), mSsl(std::move(ssl)) {}
	Result<size_t> peek(void* buf, size_t size) override;		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;		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;		const std::function<status_t()>& altPoll) override;

	private:		private:
	@@ -303,16 +303,18 @@ Result<size_t> RpcTransportTls::peek(void* buf, size_t size) {
	return ret;		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) {		const std::function<status_t()>& altPoll) {
	MAYBE_WAIT_IN_FLAKE_MODE;		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		// 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().		// once. The trigger is also checked via triggerablePoll() after every SSL_write().
	if (fdTrigger->isTriggered()) return DEAD_OBJECT;		if (fdTrigger->isTriggered()) return DEAD_OBJECT;

	size_t size = 0;		size_t size = 0;
	for (size_t i = 0; i < niovs; i++) {		for (int i = 0; i < niovs; i++) {
	const iovec& iov = iovs[i];		const iovec& iov = iovs[i];
	if (iov.iov_len == 0) {		if (iov.iov_len == 0) {
	continue;		continue;
	@@ -343,16 +345,18 @@ status_t RpcTransportTls::interruptableWriteFully(FdTrigger* fdTrigger, iovec* i
	return OK;		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) {		const std::function<status_t()>& altPoll) {
	MAYBE_WAIT_IN_FLAKE_MODE;		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		// 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().		// once. The trigger is also checked via triggerablePoll() after every SSL_write().
	if (fdTrigger->isTriggered()) return DEAD_OBJECT;		if (fdTrigger->isTriggered()) return DEAD_OBJECT;

	size_t size = 0;		size_t size = 0;
	for (size_t i = 0; i < niovs; i++) {		for (int i = 0; i < niovs; i++) {
	const iovec& iov = iovs[i];		const iovec& iov = iovs[i];
	if (iov.iov_len == 0) {		if (iov.iov_len == 0) {
	continue;		continue;

libs/binder/include/binder/RpcTransport.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -58,10 +58,10 @@ public:
	* error - interrupted (failure or trigger)		* error - interrupted (failure or trigger)
	*/		*/
	[[nodiscard]] virtual status_t interruptableWriteFully(		[[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;		const std::function<status_t()> &altPoll) = 0;
	[[nodiscard]] virtual status_t interruptableReadFully(		[[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;		const std::function<status_t()> &altPoll) = 0;

	protected:		protected: