#include <errno.h>
|
|
#include <bufferhub/BufferHubService.h>
|
#include <bufferhub/BufferNode.h>
|
#include <log/log.h>
|
#include <ui/GraphicBufferAllocator.h>
|
|
namespace android {
|
namespace frameworks {
|
namespace bufferhub {
|
namespace V1_0 {
|
namespace implementation {
|
|
void BufferNode::initializeMetadata() {
|
// Using placement new here to reuse shared memory instead of new allocation
|
// Initialize the atomic variables to zero.
|
BufferHubDefs::MetadataHeader* metadataHeader = mMetadata.metadataHeader();
|
mBufferState = new (&metadataHeader->bufferState) std::atomic<uint32_t>(0);
|
mFenceState = new (&metadataHeader->fenceState) std::atomic<uint32_t>(0);
|
mActiveClientsBitMask = new (&metadataHeader->activeClientsBitMask) std::atomic<uint32_t>(0);
|
// 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.");
|
}
|
|
// Allocates a new BufferNode.
|
BufferNode::BufferNode(uint32_t width, uint32_t height, uint32_t layerCount, uint32_t format,
|
uint64_t usage, size_t userMetadataSize, int id)
|
: mId(id) {
|
uint32_t outStride = 0;
|
// graphicBufferId is not used in GraphicBufferAllocator::allocate
|
// TODO(b/112338294) After move to the service folder, stop using the
|
// hardcoded service name "bufferhub".
|
int ret = GraphicBufferAllocator::get().allocate(width, height, format, layerCount, usage,
|
const_cast<const native_handle_t**>(
|
&mBufferHandle),
|
&outStride,
|
/*graphicBufferId=*/0,
|
/*requestor=*/"bufferhub");
|
|
if (ret != OK || mBufferHandle == nullptr) {
|
ALOGE("%s: Failed to allocate buffer: %s", __FUNCTION__, strerror(-ret));
|
return;
|
}
|
|
mBufferDesc.width = width;
|
mBufferDesc.height = height;
|
mBufferDesc.layers = layerCount;
|
mBufferDesc.format = format;
|
mBufferDesc.usage = usage;
|
mBufferDesc.stride = outStride;
|
|
mMetadata = BufferHubMetadata::create(userMetadataSize);
|
if (!mMetadata.isValid()) {
|
ALOGE("%s: Failed to allocate metadata.", __FUNCTION__);
|
return;
|
}
|
initializeMetadata();
|
}
|
|
BufferNode::~BufferNode() {
|
// Free the handle
|
if (mBufferHandle != nullptr) {
|
status_t ret = GraphicBufferAllocator::get().free(mBufferHandle);
|
if (ret != OK) {
|
ALOGE("%s: Failed to free handle; Got error: %d", __FUNCTION__, ret);
|
}
|
}
|
|
// Free the id, if valid
|
if (mId >= 0) {
|
BufferHubIdGenerator::getInstance().freeId(mId);
|
}
|
}
|
|
uint32_t BufferNode::getActiveClientsBitMask() const {
|
return mActiveClientsBitMask->load(std::memory_order_acquire);
|
}
|
|
uint32_t BufferNode::addNewActiveClientsBitToMask() {
|
uint32_t currentActiveClientsBitMask = getActiveClientsBitMask();
|
uint32_t clientStateMask = 0U;
|
uint32_t updatedActiveClientsBitMask = 0U;
|
do {
|
clientStateMask =
|
BufferHubDefs::findNextAvailableClientStateMask(currentActiveClientsBitMask);
|
if (clientStateMask == 0U) {
|
ALOGE("%s: reached the maximum number of channels per buffer node: %d.", __FUNCTION__,
|
BufferHubDefs::kMaxNumberOfClients);
|
errno = E2BIG;
|
return 0U;
|
}
|
updatedActiveClientsBitMask = currentActiveClientsBitMask | clientStateMask;
|
} while (!(mActiveClientsBitMask->compare_exchange_weak(currentActiveClientsBitMask,
|
updatedActiveClientsBitMask,
|
std::memory_order_acq_rel,
|
std::memory_order_acquire)));
|
return clientStateMask;
|
}
|
|
void BufferNode::removeClientsBitFromMask(const uint32_t& value) {
|
mActiveClientsBitMask->fetch_and(~value);
|
}
|
|
} // namespace implementation
|
} // namespace V1_0
|
} // namespace bufferhub
|
} // namespace frameworks
|
} // namespace android
|
