You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
263 lines
10 KiB
263 lines
10 KiB
/*
|
|
* 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 {
|
|
return mGrantors[hardware::details::DATAPTRPOS].extent;
|
|
}
|
|
|
|
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
|