Merge "Remove binder-based BufferHub from libui" into rvc-dev (9bb4cfb0) · Commits · e / os / platform_frameworks_native

libs/gui/BufferHubProducer.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -19,7 +19,6 @@
		#include <inttypes.h>
		#include <log/log.h>
		#include <system/window.h>
		#include <ui/BufferHubBuffer.h>

		namespace android {

libs/ui/Android.bp

+0 −14

Original line number	Diff line number	Diff line
		@@ -36,9 +36,6 @@ cc_library_shared {

		srcs: [
		"ColorSpace.cpp",
		"BufferHubBuffer.cpp",
		"BufferHubEventFd.cpp",
		"BufferHubMetadata.cpp",
		"DebugUtils.cpp",
		"Fence.cpp",
		"FenceTime.cpp",
		@@ -72,7 +69,6 @@ cc_library_shared {
		//defaults: ["libui-validate-regions-defaults"],

		shared_libs: [
		"android.frameworks.bufferhub@1.0",
		"android.hardware.graphics.allocator@2.0",
		"android.hardware.graphics.allocator@3.0",
		"android.hardware.graphics.allocator@4.0",
		@@ -109,30 +105,20 @@ cc_library_shared {
		vendor: {
		cflags: ["-DLIBUI_IN_VNDK"],
		exclude_srcs: [
		"BufferHubBuffer.cpp",
		"BufferHubEventFd.cpp",
		"BufferHubMetadata.cpp",
		],
		exclude_header_libs: [
		"libbufferhub_headers",
		"libdvr_headers",
		],
		exclude_shared_libs: [
		"android.frameworks.bufferhub@1.0",
		"libpdx_default_transport",
		],
		},
		},

		header_libs: [
		"libbase_headers",
		"libbufferhub_headers",
		"libdvr_headers",
		"libnativebase_headers",
		"libnativewindow_headers",
		"libhardware_headers",
		"libui_headers",
		"libpdx_headers",
		],

		export_static_lib_headers: [

libs/ui/BufferHubBuffer.cpp

deleted100644 → 0

+0 −358

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define LOG_TAG "BufferHubBuffer"
		#include <poll.h>

		#include <android-base/unique_fd.h>
		#include <android/frameworks/bufferhub/1.0/IBufferHub.h>
		#include <log/log.h>
		#include <ui/BufferHubBuffer.h>
		#include <ui/BufferHubDefs.h>
		#include <utils/Trace.h>

		using ::android::base::unique_fd;
		using ::android::BufferHubDefs::isAnyClientAcquired;
		using ::android::BufferHubDefs::isAnyClientGained;
		using ::android::BufferHubDefs::isClientAcquired;
		using ::android::BufferHubDefs::isClientGained;
		using ::android::BufferHubDefs::isClientPosted;
		using ::android::BufferHubDefs::isClientReleased;
		using ::android::frameworks::bufferhub::V1_0::BufferHubStatus;
		using ::android::frameworks::bufferhub::V1_0::BufferTraits;
		using ::android::frameworks::bufferhub::V1_0::IBufferClient;
		using ::android::frameworks::bufferhub::V1_0::IBufferHub;
		using ::android::hardware::hidl_handle;
		using ::android::hardware::graphics::common::V1_2::HardwareBufferDescription;

		namespace android {

		std::unique_ptr<BufferHubBuffer> BufferHubBuffer::create(uint32_t width, uint32_t height,
		uint32_t layerCount, uint32_t format,
		uint64_t usage, size_t userMetadataSize) {
		auto buffer = std::unique_ptr<BufferHubBuffer>(
		new BufferHubBuffer(width, height, layerCount, format, usage, userMetadataSize));
		return buffer->isValid() ? std::move(buffer) : nullptr;
		}

		std::unique_ptr<BufferHubBuffer> BufferHubBuffer::import(const sp<NativeHandle>& token) {
		if (token == nullptr \|\| token.get() == nullptr) {
		ALOGE("%s: token cannot be nullptr!", __FUNCTION__);
		return nullptr;
		}

		auto buffer = std::unique_ptr<BufferHubBuffer>(new BufferHubBuffer(token));
		return buffer->isValid() ? std::move(buffer) : nullptr;
		}

		BufferHubBuffer::BufferHubBuffer(uint32_t width, uint32_t height, uint32_t layerCount,
		uint32_t format, uint64_t usage, size_t userMetadataSize) {
		ATRACE_CALL();
		ALOGD("%s: width=%u height=%u layerCount=%u, format=%u "
		"usage=%" PRIx64 " mUserMetadataSize=%zu",
		__FUNCTION__, width, height, layerCount, format, usage, userMetadataSize);

		sp<IBufferHub> bufferhub = IBufferHub::getService();
		if (bufferhub.get() == nullptr) {
		ALOGE("%s: BufferHub service not found!", __FUNCTION__);
		return;
		}

		AHardwareBuffer_Desc aDesc = {width, height, layerCount, format,
		usage, /stride=/0UL, /rfu0=/0UL, /rfu1=/0ULL};
		HardwareBufferDescription desc;
		memcpy(&desc, &aDesc, sizeof(HardwareBufferDescription));

		BufferHubStatus ret;
		sp<IBufferClient> client;
		BufferTraits bufferTraits;
		IBufferHub::allocateBuffer_cb allocCb = [&](const auto& status, const auto& outClient,
		const auto& outTraits) {
		ret = status;
		client = std::move(outClient);
		bufferTraits = std::move(outTraits);
		};

		if (!bufferhub->allocateBuffer(desc, static_cast<uint32_t>(userMetadataSize), allocCb).isOk()) {
		ALOGE("%s: allocateBuffer transaction failed!", __FUNCTION__);
		return;
		} else if (ret != BufferHubStatus::NO_ERROR) {
		ALOGE("%s: allocateBuffer failed with error %u.", __FUNCTION__, ret);
		return;
		} else if (client == nullptr) {
		ALOGE("%s: allocateBuffer got null BufferClient.", __FUNCTION__);
		return;
		}

		const int importRet = initWithBufferTraits(bufferTraits);
		if (importRet < 0) {
		ALOGE("%s: Failed to import buffer: %s", __FUNCTION__, strerror(-importRet));
		client->close();
		}
		mBufferClient = std::move(client);
		}

		BufferHubBuffer::BufferHubBuffer(const sp<NativeHandle>& token) {
		sp<IBufferHub> bufferhub = IBufferHub::getService();
		if (bufferhub.get() == nullptr) {
		ALOGE("%s: BufferHub service not found!", __FUNCTION__);
		return;
		}

		BufferHubStatus ret;
		sp<IBufferClient> client;
		BufferTraits bufferTraits;
		IBufferHub::importBuffer_cb importCb = [&](const auto& status, const auto& outClient,
		const auto& outTraits) {
		ret = status;
		client = std::move(outClient);
		bufferTraits = std::move(outTraits);
		};

		// hidl_handle(native_handle_t*) simply creates a raw pointer reference withouth ownership
		// transfer.
		if (!bufferhub->importBuffer(hidl_handle(token.get()->handle()), importCb).isOk()) {
		ALOGE("%s: importBuffer transaction failed!", __FUNCTION__);
		return;
		} else if (ret != BufferHubStatus::NO_ERROR) {
		ALOGE("%s: importBuffer failed with error %u.", __FUNCTION__, ret);
		return;
		} else if (client == nullptr) {
		ALOGE("%s: importBuffer got null BufferClient.", __FUNCTION__);
		return;
		}

		const int importRet = initWithBufferTraits(bufferTraits);
		if (importRet < 0) {
		ALOGE("%s: Failed to import buffer: %s", __FUNCTION__, strerror(-importRet));
		client->close();
		}
		mBufferClient = std::move(client);
		}

		BufferHubBuffer::~BufferHubBuffer() {
		// Close buffer client to avoid possible race condition: user could first duplicate and hold
		// token with the original buffer gone, and then try to import the token. The close function
		// will explicitly invalidate the token to avoid this.
		if (mBufferClient != nullptr) {
		if (!mBufferClient->close().isOk()) {
		ALOGE("%s: close BufferClient transaction failed!", __FUNCTION__);
		}
		}
		}

		int BufferHubBuffer::initWithBufferTraits(const BufferTraits& bufferTraits) {
		ATRACE_CALL();

		if (bufferTraits.bufferInfo.getNativeHandle() == nullptr) {
		ALOGE("%s: missing buffer info handle.", __FUNCTION__);
		return -EINVAL;
		}

		if (bufferTraits.bufferHandle.getNativeHandle() == nullptr) {
		ALOGE("%s: missing gralloc handle.", __FUNCTION__);
		return -EINVAL;
		}

		// Import fds. Dup fds because hidl_handle owns the fds.
		unique_fd ashmemFd(fcntl(bufferTraits.bufferInfo->data[0], F_DUPFD_CLOEXEC, 0));
		mMetadata = BufferHubMetadata::import(std::move(ashmemFd));
		if (!mMetadata.isValid()) {
		ALOGE("%s: Received an invalid metadata.", __FUNCTION__);
		return -EINVAL;
		}

		mEventFd = BufferHubEventFd(fcntl(bufferTraits.bufferInfo->data[1], F_DUPFD_CLOEXEC, 0));
		if (!mEventFd.isValid()) {
		ALOGE("%s: Received ad invalid event fd.", __FUNCTION__);
		return -EINVAL;
		}

		int bufferId = bufferTraits.bufferInfo->data[2];
		if (bufferId < 0) {
		ALOGE("%s: Received an invalid (negative) id.", __FUNCTION__);
		return -EINVAL;
		}

		uint32_t clientBitMask;
		memcpy(&clientBitMask, &bufferTraits.bufferInfo->data[3], sizeof(clientBitMask));
		if (clientBitMask == 0U) {
		ALOGE("%s: Received an invalid client state mask.", __FUNCTION__);
		return -EINVAL;
		}

		uint32_t userMetadataSize;
		memcpy(&userMetadataSize, &bufferTraits.bufferInfo->data[4], sizeof(userMetadataSize));
		if (mMetadata.userMetadataSize() != userMetadataSize) {
		ALOGE("%s: user metadata size not match: expected %u, actual %zu.", __FUNCTION__,
		userMetadataSize, mMetadata.userMetadataSize());
		return -EINVAL;
		}

		size_t metadataSize = static_cast<size_t>(mMetadata.metadataSize());
		if (metadataSize < BufferHubDefs::kMetadataHeaderSize) {
		ALOGE("%s: metadata too small: %zu", __FUNCTION__, metadataSize);
		return -EINVAL;
		}

		// Populate shortcuts to the atomics in metadata.
		auto metadataHeader = mMetadata.metadataHeader();
		mBufferState = &metadataHeader->bufferState;
		mFenceState = &metadataHeader->fenceState;
		mActiveClientsBitMask = &metadataHeader->activeClientsBitMask;
		// The C++ standard recommends (but does not require) that lock-free atomic operations are
		// also address-free, that is, suitable for communication between processes using shared
		// memory.
		LOG_ALWAYS_FATAL_IF(!std::atomic_is_lock_free(mBufferState) \|\|
		!std::atomic_is_lock_free(mFenceState) \|\|
		!std::atomic_is_lock_free(mActiveClientsBitMask),
		"Atomic variables in ashmen are not lock free.");

		// Import the buffer: We only need to hold on the native_handle_t here so that
		// GraphicBuffer instance can be created in future.
		mBufferHandle = std::move(bufferTraits.bufferHandle);
		memcpy(&mBufferDesc, &bufferTraits.bufferDesc, sizeof(AHardwareBuffer_Desc));

		mId = bufferId;
		mClientStateMask = clientBitMask;

		// TODO(b/112012161) Set up shared fences.
		ALOGD("%s: id=%d, mBufferState=%" PRIx32 ".", __FUNCTION__, mId,
		mBufferState->load(std::memory_order_acquire));
		return 0;
		}

		int BufferHubBuffer::gain() {
		uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);
		if (isClientGained(currentBufferState, mClientStateMask)) {
		ALOGV("%s: Buffer is already gained by this client %" PRIx32 ".", __FUNCTION__,
		mClientStateMask);
		return 0;
		}
		do {
		if (isAnyClientGained(currentBufferState & (~mClientStateMask)) \|\|
		isAnyClientAcquired(currentBufferState)) {
		ALOGE("%s: Buffer is in use, id=%d mClientStateMask=%" PRIx32 " state=%" PRIx32 ".",
		__FUNCTION__, mId, mClientStateMask, currentBufferState);
		return -EBUSY;
		}
		// Change the buffer state to gained state, whose value happens to be the same as
		// mClientStateMask.
		} while (!mBufferState->compare_exchange_weak(currentBufferState, mClientStateMask,
		std::memory_order_acq_rel,
		std::memory_order_acquire));
		// TODO(b/119837586): Update fence state and return GPU fence.
		return 0;
		}

		int BufferHubBuffer::post() {
		uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);
		uint32_t updatedBufferState = (~mClientStateMask) & BufferHubDefs::kHighBitsMask;
		do {
		if (!isClientGained(currentBufferState, mClientStateMask)) {
		ALOGE("%s: Cannot post a buffer that is not gained by this client. buffer_id=%d "
		"mClientStateMask=%" PRIx32 " state=%" PRIx32 ".",
		__FUNCTION__, mId, mClientStateMask, currentBufferState);
		return -EBUSY;
		}
		// Set the producer client buffer state to released, other clients' buffer state to posted.
		// Post to all existing and non-existing clients.
		} while (!mBufferState->compare_exchange_weak(currentBufferState, updatedBufferState,
		std::memory_order_acq_rel,
		std::memory_order_acquire));
		// TODO(b/119837586): Update fence state and return GPU fence if needed.
		return 0;
		}

		int BufferHubBuffer::acquire() {
		uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);
		if (isClientAcquired(currentBufferState, mClientStateMask)) {
		ALOGV("%s: Buffer is already acquired by this client %" PRIx32 ".", __FUNCTION__,
		mClientStateMask);
		return 0;
		}
		uint32_t updatedBufferState = 0U;
		do {
		if (!isClientPosted(currentBufferState, mClientStateMask)) {
		ALOGE("%s: Cannot acquire a buffer that is not in posted state. buffer_id=%d "
		"mClientStateMask=%" PRIx32 " state=%" PRIx32 ".",
		__FUNCTION__, mId, mClientStateMask, currentBufferState);
		return -EBUSY;
		}
		// Change the buffer state for this consumer from posted to acquired.
		updatedBufferState = currentBufferState ^ mClientStateMask;
		} while (!mBufferState->compare_exchange_weak(currentBufferState, updatedBufferState,
		std::memory_order_acq_rel,
		std::memory_order_acquire));
		// TODO(b/119837586): Update fence state and return GPU fence.
		return 0;
		}

		int BufferHubBuffer::release() {
		uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);
		if (isClientReleased(currentBufferState, mClientStateMask)) {
		ALOGV("%s: Buffer is already released by this client %" PRIx32 ".", __FUNCTION__,
		mClientStateMask);
		return 0;
		}
		uint32_t updatedBufferState = 0U;
		do {
		updatedBufferState = currentBufferState & (~mClientStateMask);
		} while (!mBufferState->compare_exchange_weak(currentBufferState, updatedBufferState,
		std::memory_order_acq_rel,
		std::memory_order_acquire));
		// TODO(b/119837586): Update fence state and return GPU fence if needed.
		return 0;
		}

		bool BufferHubBuffer::isReleased() const {
		return (mBufferState->load(std::memory_order_acquire) &
		mActiveClientsBitMask->load(std::memory_order_acquire)) == 0;
		}

		bool BufferHubBuffer::isValid() const {
		return mBufferHandle.getNativeHandle() != nullptr && mId >= 0 && mClientStateMask != 0U &&
		mEventFd.get() >= 0 && mMetadata.isValid() && mBufferClient != nullptr;
		}

		sp<NativeHandle> BufferHubBuffer::duplicate() {
		if (mBufferClient == nullptr) {
		ALOGE("%s: missing BufferClient!", __FUNCTION__);
		return nullptr;
		}

		hidl_handle token;
		BufferHubStatus ret;
		IBufferClient::duplicate_cb dupCb = [&](const auto& outToken, const auto& status) {
		token = std::move(outToken);
		ret = status;
		};

		if (!mBufferClient->duplicate(dupCb).isOk()) {
		ALOGE("%s: duplicate transaction failed!", __FUNCTION__);
		return nullptr;
		} else if (ret != BufferHubStatus::NO_ERROR) {
		ALOGE("%s: duplicate failed with error %u.", __FUNCTION__, ret);
		return nullptr;
		} else if (token.getNativeHandle() == nullptr) {
		ALOGE("%s: duplicate got null token.", __FUNCTION__);
		return nullptr;
		}

		return NativeHandle::create(native_handle_clone(token.getNativeHandle()), /ownsHandle=/true);
		}

		} // namespace android

libs/ui/BufferHubEventFd.cpp

deleted100644 → 0

+0 −49

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <sys/eventfd.h>

		#include <log/log.h>
		#include <ui/BufferHubEventFd.h>

		namespace android {

		BufferHubEventFd::BufferHubEventFd() : mFd(eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK)) {}

		BufferHubEventFd::BufferHubEventFd(int fd) : mFd(fd) {}

		status_t BufferHubEventFd::signal() const {
		if (!isValid()) {
		ALOGE("%s: cannot signal an invalid eventfd.", __FUNCTION__);
		return DEAD_OBJECT;
		}

		eventfd_write(mFd.get(), 1);
		return OK;
		}

		status_t BufferHubEventFd::clear() const {
		if (!isValid()) {
		ALOGE("%s: cannot clear an invalid eventfd.", __FUNCTION__);
		return DEAD_OBJECT;
		}

		eventfd_t value;
		eventfd_read(mFd.get(), &value);
		return OK;
		}

		} // namespace android

libs/ui/BufferHubMetadata.cpp

deleted100644 → 0

+0 −104

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <errno.h>
		#include <sys/mman.h>
		#include <limits>

		#include <cutils/ashmem.h>
		#include <log/log.h>
		#include <ui/BufferHubMetadata.h>

		namespace android {

		namespace {

		static const int kAshmemProt = PROT_READ \| PROT_WRITE;

		} // namespace

		using BufferHubDefs::kMetadataHeaderSize;
		using BufferHubDefs::MetadataHeader;

		/* static */
		BufferHubMetadata BufferHubMetadata::create(size_t userMetadataSize) {
		// The size the of metadata buffer is used as the "width" parameter during allocation. Thus it
		// cannot overflow uint32_t.
		if (userMetadataSize >= (std::numeric_limits<uint32_t>::max() - kMetadataHeaderSize)) {
		ALOGE("BufferHubMetadata::Create: metadata size too big: %zu.", userMetadataSize);
		return {};
		}

		const size_t metadataSize = userMetadataSize + kMetadataHeaderSize;
		int fd = ashmem_create_region(/name=/"BufferHubMetadata", metadataSize);
		if (fd < 0) {
		ALOGE("BufferHubMetadata::Create: failed to create ashmem region.");
		return {};
		}

		// Hand over the ownership of the fd to a unique_fd immediately after the successful
		// return of ashmem_create_region. The ashmemFd is going to own the fd and to prevent fd
		// leaks during error handling.
		unique_fd ashmemFd{fd};

		if (ashmem_set_prot_region(ashmemFd.get(), kAshmemProt) != 0) {
		ALOGE("BufferHubMetadata::Create: failed to set protect region.");
		return {};
		}

		return BufferHubMetadata::import(std::move(ashmemFd));
		}

		/* static */
		BufferHubMetadata BufferHubMetadata::import(unique_fd ashmemFd) {
		if (!ashmem_valid(ashmemFd.get())) {
		ALOGE("BufferHubMetadata::Import: invalid ashmem fd.");
		return {};
		}

		size_t metadataSize = static_cast<size_t>(ashmem_get_size_region(ashmemFd.get()));
		size_t userMetadataSize = metadataSize - kMetadataHeaderSize;

		// Note that here the buffer state is mapped from shared memory as an atomic object. The
		// std::atomic's constructor will not be called so that the original value stored in the memory
		// region can be preserved.
		auto metadataHeader = static_cast<MetadataHeader*>(mmap(nullptr, metadataSize, kAshmemProt,
		MAP_SHARED, ashmemFd.get(),
		/offset=/0));
		if (metadataHeader == nullptr) {
		ALOGE("BufferHubMetadata::Import: failed to map region.");
		return {};
		}

		return BufferHubMetadata(userMetadataSize, std::move(ashmemFd), metadataHeader);
		}

		BufferHubMetadata::BufferHubMetadata(size_t userMetadataSize, unique_fd ashmemFd,
		MetadataHeader* metadataHeader)
		: mUserMetadataSize(userMetadataSize),
		mAshmemFd(std::move(ashmemFd)),
		mMetadataHeader(metadataHeader) {}

		BufferHubMetadata::~BufferHubMetadata() {
		if (mMetadataHeader != nullptr) {
		int ret = munmap(mMetadataHeader, metadataSize());
		ALOGE_IF(ret != 0,
		"BufferHubMetadata::~BufferHubMetadata: failed to unmap ashmem, error=%d.", errno);
		mMetadataHeader = nullptr;
		}
		}

		} // namespace android