| /* |
| * 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 |
| * |
| * 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 <aidl/android/hardware/common/fmq/MQDescriptor.h> |
| #include <cutils/native_handle.h> |
| #include <fmq/MQDescriptorBase.h> |
| #include <limits> |
| #include <type_traits> |
| |
| namespace android { |
| namespace details { |
| |
| using aidl::android::hardware::common::fmq::GrantorDescriptor; |
| using aidl::android::hardware::common::fmq::MQDescriptor; |
| using aidl::android::hardware::common::fmq::SynchronizedReadWrite; |
| using aidl::android::hardware::common::fmq::UnsynchronizedWrite; |
| using android::hardware::MQFlavor; |
| |
| template <typename T, MQFlavor flavor> |
| struct AidlMQDescriptorShim { |
| // Takes ownership of handle |
| AidlMQDescriptorShim(const std::vector<android::hardware::GrantorDescriptor>& grantors, |
| native_handle_t* nHandle, size_t size); |
| |
| // Takes ownership of handle |
| AidlMQDescriptorShim( |
| const MQDescriptor< |
| T, typename std::conditional<flavor == hardware::kSynchronizedReadWrite, |
| SynchronizedReadWrite, UnsynchronizedWrite>::type>& |
| desc); |
| |
| // Takes ownership of handle |
| AidlMQDescriptorShim(size_t bufferSize, native_handle_t* nHandle, size_t messageSize, |
| bool configureEventFlag = false); |
| |
| explicit AidlMQDescriptorShim(const AidlMQDescriptorShim& other) |
| : AidlMQDescriptorShim(0, nullptr, 0) { |
| *this = other; |
| } |
| AidlMQDescriptorShim& operator=(const AidlMQDescriptorShim& other); |
| |
| ~AidlMQDescriptorShim(); |
| |
| size_t getSize() const; |
| |
| size_t getQuantum() const; |
| |
| uint32_t getFlags() const; |
| |
| bool isHandleValid() const { return mHandle != nullptr; } |
| size_t countGrantors() const { return mGrantors.size(); } |
| |
| inline const std::vector<android::hardware::GrantorDescriptor>& grantors() const { |
| return mGrantors; |
| } |
| |
| inline const ::native_handle_t* handle() const { return mHandle; } |
| |
| inline ::native_handle_t* handle() { return mHandle; } |
| |
| static const size_t kOffsetOfGrantors; |
| static const size_t kOffsetOfHandle; |
| |
| private: |
| std::vector<android::hardware::GrantorDescriptor> mGrantors; |
| native_handle_t* mHandle = nullptr; |
| uint32_t mQuantum = 0; |
| uint32_t mFlags = 0; |
| }; |
| |
| template <typename T, MQFlavor flavor> |
| AidlMQDescriptorShim<T, flavor>::AidlMQDescriptorShim( |
| const MQDescriptor<T, typename std::conditional<flavor == hardware::kSynchronizedReadWrite, |
| SynchronizedReadWrite, |
| UnsynchronizedWrite>::type>& desc) |
| : mQuantum(desc.quantum), mFlags(desc.flags) { |
| if (desc.quantum < 0 || desc.flags < 0) { |
| // MQDescriptor uses signed integers, but the values must be positive. |
| hardware::details::logError("Invalid MQDescriptor. Values must be positive. quantum: " + |
| std::to_string(desc.quantum) + |
| ". flags: " + std::to_string(desc.flags)); |
| return; |
| } |
| |
| mGrantors.resize(desc.grantors.size()); |
| for (size_t i = 0; i < desc.grantors.size(); ++i) { |
| if (desc.grantors[i].offset < 0 || desc.grantors[i].extent < 0 || |
| desc.grantors[i].fdIndex < 0) { |
| // GrantorDescriptor uses signed integers, but the values must be positive. |
| // Return before setting up the native_handle to make this invalid. |
| hardware::details::logError( |
| "Invalid MQDescriptor grantors. Values must be positive. Grantor index: " + |
| std::to_string(i) + ". offset: " + std::to_string(desc.grantors[i].offset) + |
| ". extent: " + std::to_string(desc.grantors[i].extent)); |
| return; |
| } |
| mGrantors[i].flags = 0; |
| mGrantors[i].fdIndex = desc.grantors[i].fdIndex; |
| mGrantors[i].offset = desc.grantors[i].offset; |
| mGrantors[i].extent = desc.grantors[i].extent; |
| } |
| |
| mHandle = native_handle_create(desc.handle.fds.size() /* num fds */, |
| desc.handle.ints.size() /* num ints */); |
| if (mHandle == nullptr) { |
| hardware::details::logError("Null native_handle_t"); |
| return; |
| } |
| int data_index = 0; |
| for (const auto& fd : desc.handle.fds) { |
| mHandle->data[data_index] = dup(fd.get()); |
| data_index++; |
| } |
| for (const auto& data_int : desc.handle.ints) { |
| mHandle->data[data_index] = data_int; |
| data_index++; |
| } |
| } |
| |
| template <typename T, MQFlavor flavor> |
| AidlMQDescriptorShim<T, flavor>::AidlMQDescriptorShim( |
| const std::vector<android::hardware::GrantorDescriptor>& grantors, native_handle_t* nhandle, |
| size_t size) |
| : mGrantors(grantors), |
| mHandle(nhandle), |
| mQuantum(static_cast<uint32_t>(size)), |
| mFlags(flavor) {} |
| |
| template <typename T, MQFlavor flavor> |
| AidlMQDescriptorShim<T, flavor>& AidlMQDescriptorShim<T, flavor>::operator=( |
| const AidlMQDescriptorShim& other) { |
| mGrantors = other.mGrantors; |
| if (mHandle != nullptr) { |
| native_handle_close(mHandle); |
| native_handle_delete(mHandle); |
| mHandle = nullptr; |
| } |
| mQuantum = other.mQuantum; |
| mFlags = other.mFlags; |
| |
| if (other.mHandle != nullptr) { |
| mHandle = native_handle_create(other.mHandle->numFds, other.mHandle->numInts); |
| |
| for (int i = 0; i < other.mHandle->numFds; ++i) { |
| mHandle->data[i] = dup(other.mHandle->data[i]); |
| } |
| |
| memcpy(&mHandle->data[other.mHandle->numFds], &other.mHandle->data[other.mHandle->numFds], |
| static_cast<size_t>(other.mHandle->numInts) * sizeof(int)); |
| } |
| |
| return *this; |
| } |
| |
| template <typename T, MQFlavor flavor> |
| AidlMQDescriptorShim<T, flavor>::AidlMQDescriptorShim(size_t bufferSize, native_handle_t* nHandle, |
| size_t messageSize, bool configureEventFlag) |
| : mHandle(nHandle), mQuantum(messageSize), mFlags(flavor) { |
| /* |
| * TODO(b/165674950) Since AIDL does not support unsigned integers, it can only support |
| * The offset of EventFlag word needs to fit into an int32_t in MQDescriptor. This word comes |
| * after the readPtr, writePtr, and dataBuffer. |
| */ |
| bool overflow = bufferSize > std::numeric_limits<uint64_t>::max() - |
| (sizeof(hardware::details::RingBufferPosition) + |
| sizeof(hardware::details::RingBufferPosition)); |
| uint64_t largestOffset = hardware::details::alignToWordBoundary( |
| sizeof(hardware::details::RingBufferPosition) + |
| sizeof(hardware::details::RingBufferPosition) + bufferSize); |
| if (overflow || largestOffset > std::numeric_limits<int32_t>::max() || |
| messageSize > std::numeric_limits<int32_t>::max()) { |
| hardware::details::logError( |
| "Queue size is too large. Message size: " + std::to_string(messageSize) + |
| " bytes. Data buffer size: " + std::to_string(bufferSize) + " bytes. Max size: " + |
| std::to_string(std::numeric_limits<int32_t>::max()) + " bytes."); |
| return; |
| } |
| |
| /* |
| * If configureEventFlag is true, allocate an additional spot in mGrantor |
| * for containing the fd and offset for mmapping the EventFlag word. |
| */ |
| mGrantors.resize(configureEventFlag ? hardware::details::kMinGrantorCountForEvFlagSupport |
| : hardware::details::kMinGrantorCount); |
| |
| size_t memSize[] = { |
| sizeof(hardware::details::RingBufferPosition), /* memory to be allocated for read |
| * pointer counter |
| */ |
| sizeof(hardware::details::RingBufferPosition), /* memory to be allocated for write |
| pointer counter */ |
| bufferSize, /* memory to be allocated for data buffer */ |
| sizeof(std::atomic<uint32_t>) /* memory to be allocated for EventFlag word */ |
| }; |
| |
| /* |
| * Create a default grantor descriptor for read, write pointers and |
| * the data buffer. fdIndex parameter is set to 0 by default and |
| * the offset for each grantor is contiguous. |
| */ |
| for (size_t grantorPos = 0, offset = 0; grantorPos < mGrantors.size(); |
| offset += memSize[grantorPos++]) { |
| mGrantors[grantorPos] = { |
| 0 /* grantor flags */, 0 /* fdIndex */, |
| static_cast<uint32_t>(hardware::details::alignToWordBoundary(offset)), |
| memSize[grantorPos]}; |
| } |
| } |
| |
| template <typename T, MQFlavor flavor> |
| AidlMQDescriptorShim<T, flavor>::~AidlMQDescriptorShim() { |
| if (mHandle != nullptr) { |
| native_handle_close(mHandle); |
| native_handle_delete(mHandle); |
| } |
| } |
| |
| template <typename T, MQFlavor flavor> |
| size_t AidlMQDescriptorShim<T, flavor>::getSize() const { |
| if (mGrantors.size() > hardware::details::DATAPTRPOS) { |
| return mGrantors[hardware::details::DATAPTRPOS].extent; |
| } else { |
| return 0; |
| } |
| } |
| |
| template <typename T, MQFlavor flavor> |
| size_t AidlMQDescriptorShim<T, flavor>::getQuantum() const { |
| return mQuantum; |
| } |
| |
| template <typename T, MQFlavor flavor> |
| uint32_t AidlMQDescriptorShim<T, flavor>::getFlags() const { |
| return mFlags; |
| } |
| |
| template <typename T, MQFlavor flavor> |
| std::string toString(const AidlMQDescriptorShim<T, flavor>& q) { |
| std::string os; |
| if (flavor & hardware::kSynchronizedReadWrite) { |
| os += "fmq_sync"; |
| } |
| if (flavor & hardware::kUnsynchronizedWrite) { |
| os += "fmq_unsync"; |
| } |
| os += " {" + toString(q.grantors().size()) + " grantor(s), " + |
| "size = " + toString(q.getSize()) + ", .handle = " + toString(q.handle()) + |
| ", .quantum = " + toString(q.getQuantum()) + "}"; |
| return os; |
| } |
| |
| } // namespace details |
| } // namespace android |