Merge "Clean up BufferReleaseChannel logging" into main (9a815099) · Commits · e / os / android_frameworks_native

libs/gui/BufferReleaseChannel.cpp

+27 −32

Original line number	Diff line number	Diff line
		@@ -35,35 +35,35 @@ namespace android::gui {
		namespace {

		template <typename T>
		static void readAligned(const void*& buffer, size_t& size, T& value) {
		void readAligned(const void*& buffer, size_t& size, T& value) {
		size -= FlattenableUtils::align<alignof(T)>(buffer);
		FlattenableUtils::read(buffer, size, value);
		}

		template <typename T>
		static void writeAligned(void*& buffer, size_t& size, T value) {
		void writeAligned(void*& buffer, size_t& size, T value) {
		size -= FlattenableUtils::align<alignof(T)>(buffer);
		FlattenableUtils::write(buffer, size, value);
		}

		template <typename T>
		static void addAligned(size_t& size, T /* value */) {
		void addAligned(size_t& size, T /* value */) {
		size = FlattenableUtils::align<sizeof(T)>(size);
		size += sizeof(T);
		}

		template <typename T>
		static inline constexpr uint32_t low32(const T n) {
		inline constexpr uint32_t low32(const T n) {
		return static_cast<uint32_t>(static_cast<uint64_t>(n));
		}

		template <typename T>
		static inline constexpr uint32_t high32(const T n) {
		inline constexpr uint32_t high32(const T n) {
		return static_cast<uint32_t>(static_cast<uint64_t>(n) >> 32);
		}

		template <typename T>
		static inline constexpr T to64(const uint32_t lo, const uint32_t hi) {
		inline constexpr T to64(const uint32_t lo, const uint32_t hi) {
		return static_cast<T>(static_cast<uint64_t>(hi) << 32 \| lo);
		}

		@@ -139,19 +139,18 @@ status_t BufferReleaseChannel::ConsumerEndpoint::readReleaseFence(
		std::lock_guard lock{mMutex};
		Message message;
		mFlattenedBuffer.resize(message.getFlattenedSize());
		std::array<uint8_t, CMSG_SPACE(sizeof(int))> controlMessageBuffer;
		std::array<uint8_t, CMSG_SPACE(sizeof(int))> controlMessageBuffer{};

		iovec iov{
		.iov_base = mFlattenedBuffer.data(),
		.iov_len = mFlattenedBuffer.size(),
		};

		msghdr msg{
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = controlMessageBuffer.data(),
		.msg_controllen = controlMessageBuffer.size(),
		};
		msghdr msg{};
		msg.msg_iov = &iov;
		msg.msg_iovlen = 1;
		msg.msg_control = controlMessageBuffer.data();
		msg.msg_controllen = controlMessageBuffer.size();

		ssize_t result;
		do {
		@@ -161,7 +160,7 @@ status_t BufferReleaseChannel::ConsumerEndpoint::readReleaseFence(
		if (errno == EWOULDBLOCK \|\| errno == EAGAIN) {
		return WOULD_BLOCK;
		}
		ALOGE("Error reading release fence from socket: error %#x (%s)", errno, strerror(errno));
		ALOGE("Error reading release fence from socket: error %d (%s)", errno, strerror(errno));
		return UNKNOWN_ERROR;
		}

		@@ -200,8 +199,8 @@ status_t BufferReleaseChannel::ConsumerEndpoint::readReleaseFence(
		return OK;
		}

		int BufferReleaseChannel::ProducerEndpoint::writeReleaseFence(const ReleaseCallbackId& callbackId,
		const sp<Fence>& fence,
		status_t BufferReleaseChannel::ProducerEndpoint::writeReleaseFence(
		const ReleaseCallbackId& callbackId, const sp<Fence>& fence,
		uint32_t maxAcquiredBufferCount) {
		Message message{callbackId, fence ? fence : Fence::NO_FENCE, maxAcquiredBufferCount};
		mFlattenedBuffer.resize(message.getFlattenedSize());
		@@ -213,25 +212,22 @@ int BufferReleaseChannel::ProducerEndpoint::writeReleaseFence(const ReleaseCallb
		size_t flattenedBufferSize = mFlattenedBuffer.size();
		int* flattenedFdPtr = &flattenedFd;
		size_t flattenedFdCount = 1;
		if (status_t err = message.flatten(flattenedBufferPtr, flattenedBufferSize, flattenedFdPtr,
		flattenedFdCount);
		err != OK) {
		ALOGE("Failed to flatten BufferReleaseChannel message.");
		return err;
		if (status_t status = message.flatten(flattenedBufferPtr, flattenedBufferSize,
		flattenedFdPtr, flattenedFdCount);
		status != OK) {
		return status;
		}
		}

		iovec iov{
		.iov_base = mFlattenedBuffer.data(),
		.iov_len = mFlattenedBuffer.size(),
		};
		iovec iov{};
		iov.iov_base = mFlattenedBuffer.data();
		iov.iov_len = mFlattenedBuffer.size();

		msghdr msg{
		.msg_iov = &iov,
		.msg_iovlen = 1,
		};
		msghdr msg{};
		msg.msg_iov = &iov;
		msg.msg_iovlen = 1;

		std::array<uint8_t, CMSG_SPACE(sizeof(int))> controlMessageBuffer;
		std::array<uint8_t, CMSG_SPACE(sizeof(int))> controlMessageBuffer{};
		if (fence && fence->isValid()) {
		msg.msg_control = controlMessageBuffer.data();
		msg.msg_controllen = controlMessageBuffer.size();
		@@ -248,7 +244,6 @@ int BufferReleaseChannel::ProducerEndpoint::writeReleaseFence(const ReleaseCallb
		result = sendmsg(mFd, &msg, 0);
		} while (result == -1 && errno == EINTR);
		if (result == -1) {
		ALOGD("Error writing release fence to socket: error %#x (%s)", errno, strerror(errno));
		return -errno;
		}

services/surfaceflinger/Layer.cpp

+14 −2

Original line number	Diff line number	Diff line
		@@ -689,8 +689,20 @@ void Layer::callReleaseBufferCallback(const sp<ITransactionCompletedListener>& l
		listener->onReleaseBuffer(callbackId, fence, currentMaxAcquiredBufferCount);
		}

		if (mBufferReleaseChannel) {
		mBufferReleaseChannel->writeReleaseFence(callbackId, fence, currentMaxAcquiredBufferCount);
		if (!mBufferReleaseChannel) {
		return;
		}

		status_t status = mBufferReleaseChannel->writeReleaseFence(callbackId, fence,
		currentMaxAcquiredBufferCount);
		if (status != OK) {
		int error = -status;
		// callReleaseBufferCallback is called during Layer's destructor. In this case, it's
		// expected to receive connection errors.
		if (error != EPIPE && error != ECONNRESET) {
		ALOGD("[%s] writeReleaseFence failed. error %d (%s)", getDebugName(), error,
		strerror(error));
		}
		}
		}

services/surfaceflinger/TransactionCallbackInvoker.cpp

+8 −3

Original line number	Diff line number	Diff line
		@@ -144,7 +144,7 @@ status_t TransactionCallbackInvoker::addCallbackHandle(const sp<CallbackHandle>&
		eventStats, handle->previousReleaseCallbackId);
		if (handle->bufferReleaseChannel &&
		handle->previousReleaseCallbackId != ReleaseCallbackId::INVALID_ID) {
		mBufferReleases.emplace_back(handle->bufferReleaseChannel,
		mBufferReleases.emplace_back(handle->name, handle->bufferReleaseChannel,
		handle->previousReleaseCallbackId,
		handle->previousReleaseFence,
		handle->currentMaxAcquiredBufferCount);
		@@ -159,8 +159,13 @@ void TransactionCallbackInvoker::addPresentFence(sp<Fence> presentFence) {

		void TransactionCallbackInvoker::sendCallbacks(bool onCommitOnly) {
		for (const auto& bufferRelease : mBufferReleases) {
		bufferRelease.channel->writeReleaseFence(bufferRelease.callbackId, bufferRelease.fence,
		status_t status = bufferRelease.channel
		->writeReleaseFence(bufferRelease.callbackId, bufferRelease.fence,
		bufferRelease.currentMaxAcquiredBufferCount);
		if (status != OK) {
		ALOGE("[%s] writeReleaseFence failed. error %d (%s)", bufferRelease.layerName.c_str(),
		-status, strerror(-status));
		}
		}
		mBufferReleases.clear();

services/surfaceflinger/TransactionCallbackInvoker.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -83,6 +83,7 @@ private:
		mCompletedTransactions;

		struct BufferRelease {
		std::string layerName;
		std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint> channel;
		ReleaseCallbackId callbackId;
		sp<Fence> fence;