blob: 0536d6abe684ef048c46e9f73fe77507793d01ab [file] [log] [blame]
* Copyright (C) 2020 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
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#pragma once
#include <aidl/android/hardware/common/fmq/MQDescriptor.h>
#include <aidl/android/hardware/common/fmq/SynchronizedReadWrite.h>
#include <aidl/android/hardware/common/fmq/UnsynchronizedWrite.h>
#include <cutils/native_handle.h>
#include <fmq/AidlMQDescriptorShim.h>
#include <fmq/MessageQueueBase.h>
#include <utils/Log.h>
#include <type_traits>
namespace android {
using aidl::android::hardware::common::fmq::MQDescriptor;
using aidl::android::hardware::common::fmq::SynchronizedReadWrite;
using aidl::android::hardware::common::fmq::UnsynchronizedWrite;
using android::details::AidlMQDescriptorShim;
using android::hardware::MQFlavor;
template <typename T>
struct FlavorTypeToValue;
template <>
struct FlavorTypeToValue<SynchronizedReadWrite> {
static constexpr MQFlavor value = hardware::kSynchronizedReadWrite;
template <>
struct FlavorTypeToValue<UnsynchronizedWrite> {
static constexpr MQFlavor value = hardware::kUnsynchronizedWrite;
typedef uint64_t RingBufferPosition;
* AIDL parcelables will have the typedef fixed_size. It is std::true_type when the
* parcelable is annotated with @FixedSize, and std::false_type when not. Other types
* should not have the fixed_size typedef, so they will always resolve to std::false_type.
template <typename T, typename = void>
struct has_typedef_fixed_size : std::false_type {};
template <typename T>
struct has_typedef_fixed_size<T, std::void_t<typename T::fixed_size>> : T::fixed_size {};
static_assert(has_typedef_fixed_size<T>::value == true || std::is_fundamental<T>::value || \
std::is_enum<T>::value, \
"Only fundamental types, enums, and AIDL parcelables annotated with @FixedSize " \
"and built for the NDK backend are supported as payload types(T).");
template <typename T, typename U>
struct AidlMessageQueue final
: public MessageQueueBase<AidlMQDescriptorShim, T, FlavorTypeToValue<U>::value> {
typedef AidlMQDescriptorShim<T, FlavorTypeToValue<U>::value> Descriptor;
* This constructor uses the external descriptor used with AIDL interfaces.
* It will create an FMQ based on the descriptor that was obtained from
* another FMQ instance for communication.
* @param desc Descriptor from another FMQ that contains all of the
* information required to create a new instance of that queue.
* @param resetPointers Boolean indicating whether the read/write pointers
* should be reset or not.
AidlMessageQueue(const MQDescriptor<T, U>& desc, bool resetPointers = true);
~AidlMessageQueue() = default;
* This constructor uses Ashmem shared memory to create an FMQ
* that can contain a maximum of 'numElementsInQueue' elements of type T.
* @param numElementsInQueue Capacity of the AidlMessageQueue in terms of T.
* @param configureEventFlagWord Boolean that specifies if memory should
* also be allocated and mapped for an EventFlag word.
* @param bufferFd User-supplied file descriptor to map the memory for the ringbuffer
* By default, bufferFd=-1 means library will allocate ashmem region for ringbuffer.
* MessageQueue takes ownership of the file descriptor.
* @param bufferSize size of buffer in bytes that bufferFd represents. This
* size must be larger than or equal to (numElementsInQueue * sizeof(T)).
* Otherwise, operations will cause out-of-bounds memory access.
AidlMessageQueue(size_t numElementsInQueue, bool configureEventFlagWord,
android::base::unique_fd bufferFd, size_t bufferSize);
AidlMessageQueue(size_t numElementsInQueue, bool configureEventFlagWord = false)
: AidlMessageQueue(numElementsInQueue, configureEventFlagWord, android::base::unique_fd(),
0) {}
MQDescriptor<T, U> dupeDesc();
AidlMessageQueue(const AidlMessageQueue& other) = delete;
AidlMessageQueue& operator=(const AidlMessageQueue& other) = delete;
AidlMessageQueue() = delete;
template <typename T, typename U>
AidlMessageQueue<T, U>::AidlMessageQueue(const MQDescriptor<T, U>& desc, bool resetPointers)
: MessageQueueBase<AidlMQDescriptorShim, T, FlavorTypeToValue<U>::value>(Descriptor(desc),
resetPointers) {}
template <typename T, typename U>
AidlMessageQueue<T, U>::AidlMessageQueue(size_t numElementsInQueue, bool configureEventFlagWord,
android::base::unique_fd bufferFd, size_t bufferSize)
: MessageQueueBase<AidlMQDescriptorShim, T, FlavorTypeToValue<U>::value>(
numElementsInQueue, configureEventFlagWord, std::move(bufferFd), bufferSize) {}
template <typename T, typename U>
MQDescriptor<T, U> AidlMessageQueue<T, U>::dupeDesc() {
auto* shim = MessageQueueBase<AidlMQDescriptorShim, T, FlavorTypeToValue<U>::value>::getDesc();
if (shim) {
std::vector<aidl::android::hardware::common::fmq::GrantorDescriptor> grantors;
for (const auto& grantor : shim->grantors()) {
.fdIndex = static_cast<int32_t>(grantor.fdIndex),
.offset = static_cast<int32_t>(grantor.offset),
.extent = static_cast<int64_t>(grantor.extent)});
std::vector<ndk::ScopedFileDescriptor> fds;
std::vector<int> ints;
int data_index = 0;
for (; data_index < shim->handle()->numFds; data_index++) {
for (; data_index < shim->handle()->numFds + shim->handle()->numInts; data_index++) {
return MQDescriptor<T, U>{
.quantum = static_cast<int32_t>(shim->getQuantum()),
.grantors = grantors,
.flags = static_cast<int32_t>(shim->getFlags()),
.handle = {std::move(fds), std::move(ints)},
} else {
return MQDescriptor<T, U>();
} // namespace android