| #include <sys/epoll.h> |
| #include <sys/eventfd.h> |
| #include <sys/poll.h> |
| |
| #include <algorithm> |
| #include <atomic> |
| #include <thread> |
| |
| #include <log/log.h> |
| #include <private/dvr/bufferhub_rpc.h> |
| #include <private/dvr/consumer_channel.h> |
| #include <private/dvr/producer_channel.h> |
| #include <sync/sync.h> |
| #include <utils/Trace.h> |
| |
| using android::pdx::BorrowedHandle; |
| using android::pdx::ErrorStatus; |
| using android::pdx::Message; |
| using android::pdx::RemoteChannelHandle; |
| using android::pdx::Status; |
| using android::pdx::rpc::BufferWrapper; |
| using android::pdx::rpc::DispatchRemoteMethod; |
| using android::pdx::rpc::WrapBuffer; |
| |
| namespace android { |
| namespace dvr { |
| |
| ProducerChannel::ProducerChannel(BufferHubService* service, int buffer_id, |
| int channel_id, IonBuffer buffer, |
| IonBuffer metadata_buffer, |
| size_t user_metadata_size, int* error) |
| : BufferHubChannel(service, buffer_id, channel_id, kProducerType), |
| buffer_(std::move(buffer)), |
| metadata_buffer_(std::move(metadata_buffer)), |
| user_metadata_size_(user_metadata_size), |
| metadata_buf_size_(BufferHubDefs::kMetadataHeaderSize + |
| user_metadata_size) { |
| if (!buffer_.IsValid()) { |
| ALOGE("ProducerChannel::ProducerChannel: Invalid buffer."); |
| *error = -EINVAL; |
| return; |
| } |
| if (!metadata_buffer_.IsValid()) { |
| ALOGE("ProducerChannel::ProducerChannel: Invalid metadata buffer."); |
| *error = -EINVAL; |
| return; |
| } |
| |
| *error = InitializeBuffer(); |
| } |
| |
| ProducerChannel::ProducerChannel(BufferHubService* service, int channel_id, |
| uint32_t width, uint32_t height, |
| uint32_t layer_count, uint32_t format, |
| uint64_t usage, size_t user_metadata_size, |
| int* error) |
| : BufferHubChannel(service, channel_id, channel_id, kProducerType), |
| user_metadata_size_(user_metadata_size), |
| metadata_buf_size_(BufferHubDefs::kMetadataHeaderSize + |
| user_metadata_size) { |
| if (int ret = buffer_.Alloc(width, height, layer_count, format, usage)) { |
| ALOGE("ProducerChannel::ProducerChannel: Failed to allocate buffer: %s", |
| strerror(-ret)); |
| *error = ret; |
| return; |
| } |
| |
| if (int ret = metadata_buffer_.Alloc(metadata_buf_size_, /*height=*/1, |
| /*layer_count=*/1, |
| BufferHubDefs::kMetadataFormat, |
| BufferHubDefs::kMetadataUsage)) { |
| ALOGE("ProducerChannel::ProducerChannel: Failed to allocate metadata: %s", |
| strerror(-ret)); |
| *error = ret; |
| return; |
| } |
| |
| *error = InitializeBuffer(); |
| } |
| |
| int ProducerChannel::InitializeBuffer() { |
| void* metadata_ptr = nullptr; |
| if (int ret = metadata_buffer_.Lock(BufferHubDefs::kMetadataUsage, /*x=*/0, |
| /*y=*/0, metadata_buf_size_, |
| /*height=*/1, &metadata_ptr)) { |
| ALOGE("ProducerChannel::ProducerChannel: Failed to lock metadata."); |
| return ret; |
| } |
| metadata_header_ = |
| reinterpret_cast<BufferHubDefs::MetadataHeader*>(metadata_ptr); |
| |
| // Using placement new here to reuse shared memory instead of new allocation |
| // and also initialize the value to zero. |
| buffer_state_ = new (&metadata_header_->bufferState) std::atomic<uint32_t>(0); |
| fence_state_ = new (&metadata_header_->fenceState) std::atomic<uint32_t>(0); |
| active_clients_bit_mask_ = |
| new (&metadata_header_->activeClientsBitMask) std::atomic<uint32_t>(0); |
| |
| // Producer channel is never created after consumer channel, and one buffer |
| // only have one fixed producer for now. Thus, it is correct to assume |
| // producer state bit is kFirstClientBitMask for now. |
| active_clients_bit_mask_->store(BufferHubDefs::kFirstClientBitMask, |
| std::memory_order_release); |
| |
| acquire_fence_fd_.Reset(epoll_create1(EPOLL_CLOEXEC)); |
| release_fence_fd_.Reset(epoll_create1(EPOLL_CLOEXEC)); |
| if (!acquire_fence_fd_ || !release_fence_fd_) { |
| ALOGE("ProducerChannel::ProducerChannel: Failed to create shared fences."); |
| return -EIO; |
| } |
| |
| dummy_fence_fd_.Reset(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK)); |
| if (!dummy_fence_fd_) { |
| ALOGE("ProducerChannel::ProducerChannel: Failed to create dummy fences."); |
| return EIO; |
| } |
| |
| epoll_event event; |
| event.events = 0; |
| event.data.u32 = 0U; |
| if (epoll_ctl(release_fence_fd_.Get(), EPOLL_CTL_ADD, dummy_fence_fd_.Get(), |
| &event) < 0) { |
| ALOGE( |
| "ProducerChannel::ProducerChannel: Failed to modify the shared " |
| "release fence to include the dummy fence: %s", |
| strerror(errno)); |
| return -EIO; |
| } |
| |
| // Success. |
| return 0; |
| } |
| |
| std::unique_ptr<ProducerChannel> ProducerChannel::Create( |
| BufferHubService* service, int buffer_id, int channel_id, IonBuffer buffer, |
| IonBuffer metadata_buffer, size_t user_metadata_size) { |
| int error = 0; |
| std::unique_ptr<ProducerChannel> producer(new ProducerChannel( |
| service, buffer_id, channel_id, std::move(buffer), |
| std::move(metadata_buffer), user_metadata_size, &error)); |
| |
| if (error < 0) |
| return nullptr; |
| else |
| return producer; |
| } |
| |
| Status<std::shared_ptr<ProducerChannel>> ProducerChannel::Create( |
| BufferHubService* service, int channel_id, uint32_t width, uint32_t height, |
| uint32_t layer_count, uint32_t format, uint64_t usage, |
| size_t user_metadata_size) { |
| int error; |
| std::shared_ptr<ProducerChannel> producer( |
| new ProducerChannel(service, channel_id, width, height, layer_count, |
| format, usage, user_metadata_size, &error)); |
| if (error < 0) |
| return ErrorStatus(-error); |
| else |
| return {std::move(producer)}; |
| } |
| |
| ProducerChannel::~ProducerChannel() { |
| ALOGD_IF(TRACE, |
| "ProducerChannel::~ProducerChannel: channel_id=%d buffer_id=%d " |
| "state=%" PRIx32 ".", |
| channel_id(), buffer_id(), |
| buffer_state_->load(std::memory_order_acquire)); |
| for (auto consumer : consumer_channels_) { |
| consumer->OnProducerClosed(); |
| } |
| Hangup(); |
| } |
| |
| BufferHubChannel::BufferInfo ProducerChannel::GetBufferInfo() const { |
| // Derive the mask of signaled buffers in this producer / consumer set. |
| uint32_t signaled_mask = signaled() ? BufferHubDefs::kFirstClientBitMask : 0; |
| for (const ConsumerChannel* consumer : consumer_channels_) { |
| signaled_mask |= consumer->signaled() ? consumer->client_state_mask() : 0; |
| } |
| |
| return BufferInfo(buffer_id(), consumer_channels_.size(), buffer_.width(), |
| buffer_.height(), buffer_.layer_count(), buffer_.format(), |
| buffer_.usage(), |
| buffer_state_->load(std::memory_order_acquire), |
| signaled_mask, metadata_header_->queueIndex); |
| } |
| |
| void ProducerChannel::HandleImpulse(Message& message) { |
| ATRACE_NAME("ProducerChannel::HandleImpulse"); |
| switch (message.GetOp()) { |
| case BufferHubRPC::ProducerGain::Opcode: |
| OnProducerGain(message); |
| break; |
| case BufferHubRPC::ProducerPost::Opcode: |
| OnProducerPost(message, {}); |
| break; |
| } |
| } |
| |
| bool ProducerChannel::HandleMessage(Message& message) { |
| ATRACE_NAME("ProducerChannel::HandleMessage"); |
| switch (message.GetOp()) { |
| case BufferHubRPC::GetBuffer::Opcode: |
| DispatchRemoteMethod<BufferHubRPC::GetBuffer>( |
| *this, &ProducerChannel::OnGetBuffer, message); |
| return true; |
| |
| case BufferHubRPC::NewConsumer::Opcode: |
| DispatchRemoteMethod<BufferHubRPC::NewConsumer>( |
| *this, &ProducerChannel::OnNewConsumer, message); |
| return true; |
| |
| case BufferHubRPC::ProducerPost::Opcode: |
| DispatchRemoteMethod<BufferHubRPC::ProducerPost>( |
| *this, &ProducerChannel::OnProducerPost, message); |
| return true; |
| |
| case BufferHubRPC::ProducerGain::Opcode: |
| DispatchRemoteMethod<BufferHubRPC::ProducerGain>( |
| *this, &ProducerChannel::OnProducerGain, message); |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| BufferDescription<BorrowedHandle> ProducerChannel::GetBuffer( |
| uint32_t client_state_mask) { |
| return {buffer_, |
| metadata_buffer_, |
| buffer_id(), |
| channel_id(), |
| client_state_mask, |
| acquire_fence_fd_.Borrow(), |
| release_fence_fd_.Borrow()}; |
| } |
| |
| Status<BufferDescription<BorrowedHandle>> ProducerChannel::OnGetBuffer( |
| Message& /*message*/) { |
| ATRACE_NAME("ProducerChannel::OnGetBuffer"); |
| ALOGD_IF(TRACE, "ProducerChannel::OnGetBuffer: buffer=%d, state=%" PRIx32 ".", |
| buffer_id(), buffer_state_->load(std::memory_order_acquire)); |
| return {GetBuffer(BufferHubDefs::kFirstClientBitMask)}; |
| } |
| |
| Status<uint32_t> ProducerChannel::CreateConsumerStateMask() { |
| // Try find the next consumer state bit which has not been claimed by any |
| // consumer yet. |
| // memory_order_acquire is chosen here because all writes in other threads |
| // that release active_clients_bit_mask_ need to be visible here. |
| uint32_t current_active_clients_bit_mask = |
| active_clients_bit_mask_->load(std::memory_order_acquire); |
| uint32_t consumer_state_mask = |
| BufferHubDefs::findNextAvailableClientStateMask( |
| current_active_clients_bit_mask | orphaned_consumer_bit_mask_); |
| if (consumer_state_mask == 0U) { |
| ALOGE("%s: reached the maximum mumber of consumers per producer: 63.", |
| __FUNCTION__); |
| return ErrorStatus(E2BIG); |
| } |
| uint32_t updated_active_clients_bit_mask = |
| current_active_clients_bit_mask | consumer_state_mask; |
| // Set the updated value only if the current value stays the same as what was |
| // read before. If the comparison succeeds, update the value without |
| // reordering anything before or after this read-modify-write in the current |
| // thread, and the modification will be visible in other threads that acquire |
| // active_clients_bit_mask_. If the comparison fails, load the result of |
| // all writes from all threads to updated_active_clients_bit_mask. |
| // Keep on finding the next available slient state mask until succeed or out |
| // of memory. |
| while (!active_clients_bit_mask_->compare_exchange_weak( |
| current_active_clients_bit_mask, updated_active_clients_bit_mask, |
| std::memory_order_acq_rel, std::memory_order_acquire)) { |
| ALOGE("%s: Current active clients bit mask is changed to %" PRIx32 |
| ", which was expected to be %" PRIx32 |
| ". Trying to generate a new client state mask to resolve race " |
| "condition.", |
| __FUNCTION__, updated_active_clients_bit_mask, |
| current_active_clients_bit_mask); |
| consumer_state_mask = BufferHubDefs::findNextAvailableClientStateMask( |
| current_active_clients_bit_mask | orphaned_consumer_bit_mask_); |
| if (consumer_state_mask == 0U) { |
| ALOGE("%s: reached the maximum mumber of consumers per producer: %d.", |
| __FUNCTION__, (BufferHubDefs::kMaxNumberOfClients - 1)); |
| return ErrorStatus(E2BIG); |
| } |
| updated_active_clients_bit_mask = |
| current_active_clients_bit_mask | consumer_state_mask; |
| } |
| |
| return {consumer_state_mask}; |
| } |
| |
| void ProducerChannel::RemoveConsumerClientMask(uint32_t consumer_state_mask) { |
| // Clear up the buffer state and fence state in case there is already |
| // something there due to possible race condition between producer post and |
| // consumer failed to create channel. |
| buffer_state_->fetch_and(~consumer_state_mask, std::memory_order_release); |
| fence_state_->fetch_and(~consumer_state_mask, std::memory_order_release); |
| |
| // Restore the consumer state bit and make it visible in other threads that |
| // acquire the active_clients_bit_mask_. |
| active_clients_bit_mask_->fetch_and(~consumer_state_mask, |
| std::memory_order_release); |
| } |
| |
| Status<RemoteChannelHandle> ProducerChannel::CreateConsumer( |
| Message& message, uint32_t consumer_state_mask) { |
| ATRACE_NAME(__FUNCTION__); |
| ALOGD("%s: buffer_id=%d", __FUNCTION__, buffer_id()); |
| |
| int channel_id; |
| auto status = message.PushChannel(0, nullptr, &channel_id); |
| if (!status) { |
| ALOGE("%s: Failed to push consumer channel: %s", __FUNCTION__, |
| status.GetErrorMessage().c_str()); |
| RemoveConsumerClientMask(consumer_state_mask); |
| return ErrorStatus(ENOMEM); |
| } |
| |
| auto consumer = std::make_shared<ConsumerChannel>( |
| service(), buffer_id(), channel_id, consumer_state_mask, |
| shared_from_this()); |
| const auto channel_status = service()->SetChannel(channel_id, consumer); |
| if (!channel_status) { |
| ALOGE("%s: failed to set new consumer channel: %s.", __FUNCTION__, |
| channel_status.GetErrorMessage().c_str()); |
| RemoveConsumerClientMask(consumer_state_mask); |
| return ErrorStatus(ENOMEM); |
| } |
| |
| uint32_t current_buffer_state = |
| buffer_state_->load(std::memory_order_acquire); |
| // Return the consumer channel handle without signal when adding the new |
| // consumer to a buffer that is available to producer (a.k.a a fully-released |
| // buffer) or a gained buffer. |
| if (current_buffer_state == 0U || |
| BufferHubDefs::isAnyClientGained(current_buffer_state)) { |
| return {status.take()}; |
| } |
| |
| // Signal the new consumer when adding it to a posted producer. |
| bool update_buffer_state = true; |
| if (!BufferHubDefs::isClientPosted(current_buffer_state, |
| consumer_state_mask)) { |
| uint32_t updated_buffer_state = |
| current_buffer_state ^ |
| (consumer_state_mask & BufferHubDefs::kHighBitsMask); |
| while (!buffer_state_->compare_exchange_weak( |
| current_buffer_state, updated_buffer_state, std::memory_order_acq_rel, |
| std::memory_order_acquire)) { |
| ALOGV( |
| "%s: Failed to post to the new consumer. " |
| "Current buffer state was changed to %" PRIx32 |
| " when trying to acquire the buffer and modify the buffer state to " |
| "%" PRIx32 |
| ". About to try again if the buffer is still not gained nor fully " |
| "released.", |
| __FUNCTION__, current_buffer_state, updated_buffer_state); |
| if (current_buffer_state == 0U || |
| BufferHubDefs::isAnyClientGained(current_buffer_state)) { |
| ALOGI("%s: buffer is gained or fully released, state=%" PRIx32 ".", |
| __FUNCTION__, current_buffer_state); |
| update_buffer_state = false; |
| break; |
| } |
| updated_buffer_state = |
| current_buffer_state ^ |
| (consumer_state_mask & BufferHubDefs::kHighBitsMask); |
| } |
| } |
| if (update_buffer_state || BufferHubDefs::isClientPosted( |
| buffer_state_->load(std::memory_order_acquire), |
| consumer_state_mask)) { |
| consumer->OnProducerPosted(); |
| } |
| |
| return {status.take()}; |
| } |
| |
| Status<RemoteChannelHandle> ProducerChannel::OnNewConsumer(Message& message) { |
| ATRACE_NAME("ProducerChannel::OnNewConsumer"); |
| ALOGD_IF(TRACE, "ProducerChannel::OnNewConsumer: buffer_id=%d", buffer_id()); |
| auto status = CreateConsumerStateMask(); |
| if (!status.ok()) { |
| return status.error_status(); |
| } |
| return CreateConsumer(message, /*consumer_state_mask=*/status.get()); |
| } |
| |
| Status<void> ProducerChannel::OnProducerPost(Message&, |
| LocalFence acquire_fence) { |
| ATRACE_NAME("ProducerChannel::OnProducerPost"); |
| ALOGD_IF(TRACE, "%s: buffer_id=%d, state=0x%x", __FUNCTION__, buffer_id(), |
| buffer_state_->load(std::memory_order_acquire)); |
| |
| epoll_event event; |
| event.events = 0; |
| event.data.u32 = 0U; |
| int ret = epoll_ctl(release_fence_fd_.Get(), EPOLL_CTL_MOD, |
| dummy_fence_fd_.Get(), &event); |
| ALOGE_IF(ret < 0, |
| "ProducerChannel::OnProducerPost: Failed to modify the shared " |
| "release fence to include the dummy fence: %s", |
| strerror(errno)); |
| |
| eventfd_t dummy_fence_count = 0U; |
| if (eventfd_read(dummy_fence_fd_.Get(), &dummy_fence_count) < 0) { |
| const int error = errno; |
| if (error != EAGAIN) { |
| ALOGE( |
| "ProducerChannel::ProducerChannel: Failed to read dummy fence, " |
| "error: %s", |
| strerror(error)); |
| return ErrorStatus(error); |
| } |
| } |
| |
| ALOGW_IF(dummy_fence_count > 0, |
| "ProducerChannel::ProducerChannel: %" PRIu64 |
| " dummy fence(s) was signaled during last release/gain cycle " |
| "buffer_id=%d.", |
| dummy_fence_count, buffer_id()); |
| |
| post_fence_ = std::move(acquire_fence); |
| |
| // Signal any interested consumers. If there are none, the buffer will stay |
| // in posted state until a consumer comes online. This behavior guarantees |
| // that no frame is silently dropped. |
| for (auto& consumer : consumer_channels_) { |
| consumer->OnProducerPosted(); |
| } |
| |
| return {}; |
| } |
| |
| Status<LocalFence> ProducerChannel::OnProducerGain(Message& /*message*/) { |
| ATRACE_NAME("ProducerChannel::OnGain"); |
| ALOGD_IF(TRACE, "%s: buffer_id=%d", __FUNCTION__, buffer_id()); |
| |
| ClearAvailable(); |
| post_fence_.close(); |
| for (auto& consumer : consumer_channels_) { |
| consumer->OnProducerGained(); |
| } |
| return {std::move(returned_fence_)}; |
| } |
| |
| // TODO(b/112338294) Keep here for reference. Remove it after new logic is |
| // written. |
| /* Status<RemoteChannelHandle> ProducerChannel::OnProducerDetach( |
| Message& message) { |
| ATRACE_NAME("ProducerChannel::OnProducerDetach"); |
| ALOGD_IF(TRACE, "ProducerChannel::OnProducerDetach: buffer_id=%d", |
| buffer_id()); |
| |
| uint32_t buffer_state = buffer_state_->load(std::memory_order_acquire); |
| if (!BufferHubDefs::isClientGained( |
| buffer_state, BufferHubDefs::kFirstClientStateMask)) { |
| // Can only detach a ProducerBuffer when it's in gained state. |
| ALOGW( |
| "ProducerChannel::OnProducerDetach: The buffer (id=%d, state=%" |
| PRIx32 |
| ") is not in gained state.", |
| buffer_id(), buffer_state); |
| return {}; |
| } |
| |
| int channel_id; |
| auto status = message.PushChannel(0, nullptr, &channel_id); |
| if (!status) { |
| ALOGE( |
| "ProducerChannel::OnProducerDetach: Failed to push detached buffer " |
| "channel: %s", |
| status.GetErrorMessage().c_str()); |
| return ErrorStatus(ENOMEM); |
| } |
| |
| // Make sure we unlock the buffer. |
| if (int ret = metadata_buffer_.Unlock()) { |
| ALOGE("ProducerChannel::OnProducerDetach: Failed to unlock metadata."); |
| return ErrorStatus(-ret); |
| }; |
| |
| std::unique_ptr<BufferChannel> channel = |
| BufferChannel::Create(service(), buffer_id(), channel_id, |
| std::move(buffer_), user_metadata_size_); |
| if (!channel) { |
| ALOGE("ProducerChannel::OnProducerDetach: Invalid buffer."); |
| return ErrorStatus(EINVAL); |
| } |
| |
| const auto channel_status = |
| service()->SetChannel(channel_id, std::move(channel)); |
| if (!channel_status) { |
| // Technically, this should never fail, as we just pushed the channel. |
| // Note that LOG_FATAL will be stripped out in non-debug build. |
| LOG_FATAL( |
| "ProducerChannel::OnProducerDetach: Failed to set new detached " |
| "buffer channel: %s.", channel_status.GetErrorMessage().c_str()); |
| } |
| |
| return status; |
| } */ |
| |
| Status<LocalFence> ProducerChannel::OnConsumerAcquire(Message& /*message*/) { |
| ATRACE_NAME("ProducerChannel::OnConsumerAcquire"); |
| ALOGD_IF(TRACE, "ProducerChannel::OnConsumerAcquire: buffer_id=%d", |
| buffer_id()); |
| |
| // Return a borrowed fd to avoid unnecessary duplication of the underlying |
| // fd. Serialization just needs to read the handle. |
| return {std::move(post_fence_)}; |
| } |
| |
| Status<void> ProducerChannel::OnConsumerRelease(Message&, |
| LocalFence release_fence) { |
| ATRACE_NAME("ProducerChannel::OnConsumerRelease"); |
| ALOGD_IF(TRACE, "ProducerChannel::OnConsumerRelease: buffer_id=%d", |
| buffer_id()); |
| |
| // Attempt to merge the fences if necessary. |
| if (release_fence) { |
| if (returned_fence_) { |
| LocalFence merged_fence(sync_merge("bufferhub_merged", |
| returned_fence_.get_fd(), |
| release_fence.get_fd())); |
| const int error = errno; |
| if (!merged_fence) { |
| ALOGE("ProducerChannel::OnConsumerRelease: Failed to merge fences: %s", |
| strerror(error)); |
| return ErrorStatus(error); |
| } |
| returned_fence_ = std::move(merged_fence); |
| } else { |
| returned_fence_ = std::move(release_fence); |
| } |
| } |
| |
| if (IsBufferReleasedByAllActiveClientsExceptForOrphans()) { |
| buffer_state_->store(0U); |
| SignalAvailable(); |
| if (orphaned_consumer_bit_mask_) { |
| ALOGW( |
| "%s: orphaned buffer detected during the this acquire/release cycle: " |
| "id=%d orphaned=0x%" PRIx32 " queue_index=%" PRId64 ".", |
| __FUNCTION__, buffer_id(), orphaned_consumer_bit_mask_, |
| metadata_header_->queueIndex); |
| orphaned_consumer_bit_mask_ = 0; |
| } |
| } |
| |
| return {}; |
| } |
| |
| void ProducerChannel::OnConsumerOrphaned(const uint32_t& consumer_state_mask) { |
| // Remember the ignored consumer so that newly added consumer won't be |
| // taking the same state mask as this orphaned consumer. |
| ALOGE_IF(orphaned_consumer_bit_mask_ & consumer_state_mask, |
| "%s: Consumer (consumer_state_mask=%" PRIx32 |
| ") is already orphaned.", |
| __FUNCTION__, consumer_state_mask); |
| orphaned_consumer_bit_mask_ |= consumer_state_mask; |
| |
| if (IsBufferReleasedByAllActiveClientsExceptForOrphans()) { |
| buffer_state_->store(0U); |
| SignalAvailable(); |
| } |
| |
| // Atomically clear the fence state bit as an orphaned consumer will never |
| // signal a release fence. |
| fence_state_->fetch_and(~consumer_state_mask, std::memory_order_release); |
| |
| // Atomically set the buffer state of this consumer to released state. |
| buffer_state_->fetch_and(~consumer_state_mask, std::memory_order_release); |
| |
| ALOGW( |
| "%s: detected new orphaned consumer buffer_id=%d " |
| "consumer_state_mask=%" PRIx32 " queue_index=%" PRId64 |
| " buffer_state=%" PRIx32 " fence_state=%" PRIx32 ".", |
| __FUNCTION__, buffer_id(), consumer_state_mask, |
| metadata_header_->queueIndex, |
| buffer_state_->load(std::memory_order_acquire), |
| fence_state_->load(std::memory_order_acquire)); |
| } |
| |
| void ProducerChannel::AddConsumer(ConsumerChannel* channel) { |
| consumer_channels_.push_back(channel); |
| } |
| |
| void ProducerChannel::RemoveConsumer(ConsumerChannel* channel) { |
| consumer_channels_.erase( |
| std::find(consumer_channels_.begin(), consumer_channels_.end(), channel)); |
| // Restore the consumer state bit and make it visible in other threads that |
| // acquire the active_clients_bit_mask_. |
| uint32_t consumer_state_mask = channel->client_state_mask(); |
| uint32_t current_active_clients_bit_mask = |
| active_clients_bit_mask_->load(std::memory_order_acquire); |
| uint32_t updated_active_clients_bit_mask = |
| current_active_clients_bit_mask & (~consumer_state_mask); |
| while (!active_clients_bit_mask_->compare_exchange_weak( |
| current_active_clients_bit_mask, updated_active_clients_bit_mask, |
| std::memory_order_acq_rel, std::memory_order_acquire)) { |
| ALOGI( |
| "%s: Failed to remove consumer state mask. Current active clients bit " |
| "mask is changed to %" PRIx32 |
| " when trying to acquire and modify it to %" PRIx32 |
| ". About to try again.", |
| __FUNCTION__, current_active_clients_bit_mask, |
| updated_active_clients_bit_mask); |
| updated_active_clients_bit_mask = |
| current_active_clients_bit_mask & (~consumer_state_mask); |
| } |
| |
| const uint32_t current_buffer_state = |
| buffer_state_->load(std::memory_order_acquire); |
| if (BufferHubDefs::isClientPosted(current_buffer_state, |
| consumer_state_mask) || |
| BufferHubDefs::isClientAcquired(current_buffer_state, |
| consumer_state_mask)) { |
| // The consumer client is being destoryed without releasing. This could |
| // happen in corner cases when the consumer crashes. Here we mark it |
| // orphaned before remove it from producer. |
| OnConsumerOrphaned(consumer_state_mask); |
| return; |
| } |
| |
| if (BufferHubDefs::isClientReleased(current_buffer_state, |
| consumer_state_mask) || |
| BufferHubDefs::isAnyClientGained(current_buffer_state)) { |
| // The consumer is being close while it is suppose to signal a release |
| // fence. Signal the dummy fence here. |
| if (fence_state_->load(std::memory_order_acquire) & consumer_state_mask) { |
| epoll_event event; |
| event.events = EPOLLIN; |
| event.data.u32 = consumer_state_mask; |
| if (epoll_ctl(release_fence_fd_.Get(), EPOLL_CTL_MOD, |
| dummy_fence_fd_.Get(), &event) < 0) { |
| ALOGE( |
| "%s: Failed to modify the shared release fence to include the " |
| "dummy fence: %s", |
| __FUNCTION__, strerror(errno)); |
| return; |
| } |
| ALOGW("%s: signal dummy release fence buffer_id=%d", __FUNCTION__, |
| buffer_id()); |
| eventfd_write(dummy_fence_fd_.Get(), 1); |
| } |
| } |
| } |
| |
| // Returns true if the given parameters match the underlying buffer |
| // parameters. |
| bool ProducerChannel::CheckParameters(uint32_t width, uint32_t height, |
| uint32_t layer_count, uint32_t format, |
| uint64_t usage, |
| size_t user_metadata_size) const { |
| return user_metadata_size == user_metadata_size_ && |
| buffer_.width() == width && buffer_.height() == height && |
| buffer_.layer_count() == layer_count && buffer_.format() == format && |
| buffer_.usage() == usage; |
| } |
| |
| bool ProducerChannel::IsBufferReleasedByAllActiveClientsExceptForOrphans() |
| const { |
| return (buffer_state_->load(std::memory_order_acquire) & |
| ~orphaned_consumer_bit_mask_ & |
| active_clients_bit_mask_->load(std::memory_order_acquire)) == 0U; |
| } |
| |
| } // namespace dvr |
| } // namespace android |
