Snap for 9550355 from 62b0bcc1a2b3c84ebdef1d8d483c3241e840b77f to sdk-release
Change-Id: I90b1004e48020a88898cfe49c6d5ea628ae0b8b4
diff --git a/Android.bp b/Android.bp
index 5889a9c..c42772b 100644
--- a/Android.bp
+++ b/Android.bp
@@ -30,7 +30,10 @@
],
apex_available: [
"//apex_available:platform",
+ "com.android.btservices",
+ "com.android.media.swcodec",
"com.android.neuralnetworks",
+ "test_com.android.media.swcodec",
"test_com.android.neuralnetworks",
],
export_include_dirs: ["include"],
diff --git a/fuzzer/Android.bp b/fuzzer/Android.bp
index 8b33d83..0926c09 100644
--- a/fuzzer/Android.bp
+++ b/fuzzer/Android.bp
@@ -56,9 +56,9 @@
host_supported: true,
sanitize: {
- hwaddress: true,
scs: true,
cfi: true,
+ address: true,
memtag_heap: true,
// undefined behavior is expected
all_undefined: false,
diff --git a/fuzzer/fmq_fuzzer.cpp b/fuzzer/fmq_fuzzer.cpp
index 844188f..8c8a78e 100644
--- a/fuzzer/fmq_fuzzer.cpp
+++ b/fuzzer/fmq_fuzzer.cpp
@@ -21,6 +21,7 @@
#include <thread>
#include <android-base/logging.h>
+#include <android-base/scopeguard.h>
#include <fmq/AidlMessageQueue.h>
#include <fmq/ConvertMQDescriptors.h>
#include <fmq/EventFlag.h>
@@ -35,6 +36,9 @@
typedef int32_t payload_t;
+// The reader will wait for 10 ms
+static constexpr int kBlockingTimeoutNs = 10000000;
+
/*
* MessageQueueBase.h contains asserts when memory allocation fails. So we need
* to set a reasonable limit if we want to avoid those asserts.
@@ -55,6 +59,7 @@
static constexpr int kMaxNumSyncReaders = 1;
static constexpr int kMaxNumUnsyncReaders = 5;
+static constexpr int kMaxDataPerReader = 1000;
typedef android::AidlMessageQueue<payload_t, SynchronizedReadWrite> AidlMessageQueueSync;
typedef android::AidlMessageQueue<payload_t, UnsynchronizedWrite> AidlMessageQueueUnsync;
@@ -67,14 +72,19 @@
typedef android::hardware::MQDescriptorSync<payload_t> MQDescSync;
typedef android::hardware::MQDescriptorUnsync<payload_t> MQDescUnsync;
+static inline uint64_t* getCounterPtr(payload_t* start, int byteOffset) {
+ return reinterpret_cast<uint64_t*>(reinterpret_cast<uint8_t*>(start) - byteOffset);
+}
+
template <typename Queue, typename Desc>
-void reader(const Desc& desc, std::vector<uint8_t> readerData) {
+void reader(const Desc& desc, std::vector<uint8_t> readerData, bool userFd) {
Queue readMq(desc);
if (!readMq.isValid()) {
LOG(ERROR) << "read mq invalid";
return;
}
FuzzedDataProvider fdp(&readerData[0], readerData.size());
+ payload_t* ring = nullptr;
while (fdp.remaining_bytes()) {
typename Queue::MemTransaction tx;
size_t numElements = fdp.ConsumeIntegralInRange<size_t>(0, kMaxNumElements);
@@ -84,19 +94,57 @@
const auto& region = tx.getFirstRegion();
payload_t* firstStart = region.getAddress();
- // TODO add the debug function to get pointer to the ring buffer
- uint64_t* writeCounter = reinterpret_cast<uint64_t*>(
- reinterpret_cast<uint8_t*>(firstStart) - kWriteCounterOffsetBytes);
- *writeCounter = fdp.ConsumeIntegral<uint64_t>();
-
+ // the ring buffer is only next to the read/write counters when there is
+ // no user supplied fd
+ if (!userFd) {
+ if (ring == nullptr) {
+ ring = firstStart;
+ }
+ if (fdp.ConsumeIntegral<uint8_t>() == 1) {
+ uint64_t* writeCounter = getCounterPtr(ring, kWriteCounterOffsetBytes);
+ *writeCounter = fdp.ConsumeIntegral<uint64_t>();
+ }
+ }
(void)std::to_string(*firstStart);
readMq.commitRead(numElements);
}
}
+template <typename Queue, typename Desc>
+void readerBlocking(const Desc& desc, std::vector<uint8_t>& readerData,
+ std::atomic<size_t>& readersNotFinished,
+ std::atomic<size_t>& writersNotFinished) {
+ android::base::ScopeGuard guard([&readersNotFinished]() { readersNotFinished--; });
+ Queue readMq(desc);
+ if (!readMq.isValid()) {
+ LOG(ERROR) << "read mq invalid";
+ return;
+ }
+ FuzzedDataProvider fdp(&readerData[0], readerData.size());
+ do {
+ size_t count = fdp.remaining_bytes()
+ ? fdp.ConsumeIntegralInRange<size_t>(1, readMq.getQuantumCount())
+ : 1;
+ std::vector<payload_t> data;
+ data.resize(count);
+ readMq.readBlocking(data.data(), count, kBlockingTimeoutNs);
+ } while (fdp.remaining_bytes() > sizeof(size_t) && writersNotFinished > 0);
+}
+
+// Can't use blocking calls with Unsync queues(there is a static_assert)
+template <>
+void readerBlocking<AidlMessageQueueUnsync, AidlMQDescUnsync>(const AidlMQDescUnsync&,
+ std::vector<uint8_t>&,
+ std::atomic<size_t>&,
+ std::atomic<size_t>&) {}
+template <>
+void readerBlocking<MessageQueueUnsync, MQDescUnsync>(const MQDescUnsync&, std::vector<uint8_t>&,
+ std::atomic<size_t>&, std::atomic<size_t>&) {}
+
template <typename Queue>
-void writer(Queue& writeMq, FuzzedDataProvider& fdp) {
+void writer(Queue& writeMq, FuzzedDataProvider& fdp, bool userFd) {
+ payload_t* ring = nullptr;
while (fdp.remaining_bytes()) {
typename Queue::MemTransaction tx;
size_t numElements = 1;
@@ -108,23 +156,61 @@
const auto& region = tx.getFirstRegion();
payload_t* firstStart = region.getAddress();
-
- // TODO add the debug function to get pointer to the ring buffer
- uint64_t* readCounter = reinterpret_cast<uint64_t*>(reinterpret_cast<uint8_t*>(firstStart) -
- kReadCounterOffsetBytes);
- *readCounter = fdp.ConsumeIntegral<uint64_t>();
-
+ // the ring buffer is only next to the read/write counters when there is
+ // no user supplied fd
+ if (!userFd) {
+ if (ring == nullptr) {
+ ring = firstStart;
+ }
+ if (fdp.ConsumeIntegral<uint8_t>() == 1) {
+ uint64_t* readCounter = getCounterPtr(ring, kReadCounterOffsetBytes);
+ *readCounter = fdp.ConsumeIntegral<uint64_t>();
+ }
+ }
*firstStart = fdp.ConsumeIntegral<payload_t>();
writeMq.commitWrite(numElements);
}
}
+template <typename Queue>
+void writerBlocking(Queue& writeMq, FuzzedDataProvider& fdp,
+ std::atomic<size_t>& writersNotFinished,
+ std::atomic<size_t>& readersNotFinished) {
+ android::base::ScopeGuard guard([&writersNotFinished]() { writersNotFinished--; });
+ while (fdp.remaining_bytes() > sizeof(size_t) && readersNotFinished > 0) {
+ size_t count = fdp.ConsumeIntegralInRange<size_t>(1, writeMq.getQuantumCount());
+ std::vector<payload_t> data;
+ for (int i = 0; i < count; i++) {
+ data.push_back(fdp.ConsumeIntegral<payload_t>());
+ }
+ writeMq.writeBlocking(data.data(), count, kBlockingTimeoutNs);
+ }
+}
+
+// Can't use blocking calls with Unsync queues(there is a static_assert)
+template <>
+void writerBlocking<AidlMessageQueueUnsync>(AidlMessageQueueUnsync&, FuzzedDataProvider&,
+ std::atomic<size_t>&, std::atomic<size_t>&) {}
+template <>
+void writerBlocking<MessageQueueUnsync>(MessageQueueUnsync&, FuzzedDataProvider&,
+ std::atomic<size_t>&, std::atomic<size_t>&) {}
+
template <typename Queue, typename Desc>
void fuzzAidlWithReaders(std::vector<uint8_t>& writerData,
- std::vector<std::vector<uint8_t>>& readerData) {
+ std::vector<std::vector<uint8_t>>& readerData, bool blocking) {
FuzzedDataProvider fdp(&writerData[0], writerData.size());
- Queue writeMq(fdp.ConsumeIntegralInRange<size_t>(1, kMaxNumElements), fdp.ConsumeBool());
+ bool evFlag = blocking || fdp.ConsumeBool();
+ android::base::unique_fd dataFd;
+ size_t bufferSize = 0;
+ size_t numElements = fdp.ConsumeIntegralInRange<size_t>(1, kMaxNumElements);
+ bool userFd = fdp.ConsumeBool();
+ if (userFd) {
+ // run test with our own data region
+ bufferSize = numElements * sizeof(payload_t);
+ dataFd.reset(::ashmem_create_region("SyncReadWrite", bufferSize));
+ }
+ Queue writeMq(numElements, evFlag, std::move(dataFd), bufferSize);
if (!writeMq.isValid()) {
LOG(ERROR) << "AIDL write mq invalid";
return;
@@ -132,23 +218,47 @@
const auto desc = writeMq.dupeDesc();
CHECK(desc.handle.fds[0].get() != -1);
- std::vector<std::thread> clients;
+ std::atomic<size_t> readersNotFinished = readerData.size();
+ std::atomic<size_t> writersNotFinished = 1;
+ std::vector<std::thread> readers;
for (int i = 0; i < readerData.size(); i++) {
- clients.emplace_back(reader<Queue, Desc>, std::ref(desc), std::ref(readerData[i]));
+ if (blocking) {
+ readers.emplace_back(readerBlocking<Queue, Desc>, std::ref(desc),
+ std::ref(readerData[i]), std::ref(readersNotFinished),
+ std::ref(writersNotFinished));
+
+ } else {
+ readers.emplace_back(reader<Queue, Desc>, std::ref(desc), std::ref(readerData[i]),
+ userFd);
+ }
}
- writer<Queue>(writeMq, fdp);
+ if (blocking) {
+ writerBlocking<Queue>(writeMq, fdp, writersNotFinished, readersNotFinished);
+ } else {
+ writer<Queue>(writeMq, fdp, userFd);
+ }
- for (auto& client : clients) {
- client.join();
+ for (auto& reader : readers) {
+ reader.join();
}
}
template <typename Queue, typename Desc>
void fuzzHidlWithReaders(std::vector<uint8_t>& writerData,
- std::vector<std::vector<uint8_t>>& readerData) {
+ std::vector<std::vector<uint8_t>>& readerData, bool blocking) {
FuzzedDataProvider fdp(&writerData[0], writerData.size());
- Queue writeMq(fdp.ConsumeIntegralInRange<size_t>(1, kMaxNumElements), fdp.ConsumeBool());
+ bool evFlag = blocking || fdp.ConsumeBool();
+ android::base::unique_fd dataFd;
+ size_t bufferSize = 0;
+ size_t numElements = fdp.ConsumeIntegralInRange<size_t>(1, kMaxNumElements);
+ bool userFd = fdp.ConsumeBool();
+ if (userFd) {
+ // run test with our own data region
+ bufferSize = numElements * sizeof(payload_t);
+ dataFd.reset(::ashmem_create_region("SyncReadWrite", bufferSize));
+ }
+ Queue writeMq(numElements, evFlag, std::move(dataFd), bufferSize);
if (!writeMq.isValid()) {
LOG(ERROR) << "HIDL write mq invalid";
return;
@@ -156,15 +266,28 @@
const auto desc = writeMq.getDesc();
CHECK(desc->isHandleValid());
- std::vector<std::thread> clients;
+ std::atomic<size_t> readersNotFinished = readerData.size();
+ std::atomic<size_t> writersNotFinished = 1;
+ std::vector<std::thread> readers;
for (int i = 0; i < readerData.size(); i++) {
- clients.emplace_back(reader<Queue, Desc>, std::ref(*desc), std::ref(readerData[i]));
+ if (blocking) {
+ readers.emplace_back(readerBlocking<Queue, Desc>, std::ref(*desc),
+ std::ref(readerData[i]), std::ref(readersNotFinished),
+ std::ref(writersNotFinished));
+ } else {
+ readers.emplace_back(reader<Queue, Desc>, std::ref(*desc), std::ref(readerData[i]),
+ userFd);
+ }
}
- writer<Queue>(writeMq, fdp);
+ if (blocking) {
+ writerBlocking<Queue>(writeMq, fdp, writersNotFinished, readersNotFinished);
+ } else {
+ writer<Queue>(writeMq, fdp, userFd);
+ }
- for (auto& client : clients) {
- client.join();
+ for (auto& reader : readers) {
+ reader.join();
}
}
@@ -179,16 +302,18 @@
uint8_t numReaders = fuzzSync ? fdp.ConsumeIntegralInRange<uint8_t>(0, kMaxNumSyncReaders)
: fdp.ConsumeIntegralInRange<uint8_t>(0, kMaxNumUnsyncReaders);
for (int i = 0; i < numReaders; i++) {
- readerData.emplace_back(fdp.ConsumeBytes<uint8_t>(5));
+ readerData.emplace_back(fdp.ConsumeBytes<uint8_t>(kMaxDataPerReader));
}
+ bool fuzzBlocking = fdp.ConsumeBool();
std::vector<uint8_t> writerData = fdp.ConsumeRemainingBytes<uint8_t>();
-
if (fuzzSync) {
- fuzzHidlWithReaders<MessageQueueSync, MQDescSync>(writerData, readerData);
- fuzzAidlWithReaders<AidlMessageQueueSync, AidlMQDescSync>(writerData, readerData);
+ fuzzHidlWithReaders<MessageQueueSync, MQDescSync>(writerData, readerData, fuzzBlocking);
+ fuzzAidlWithReaders<AidlMessageQueueSync, AidlMQDescSync>(writerData, readerData,
+ fuzzBlocking);
} else {
- fuzzHidlWithReaders<MessageQueueUnsync, MQDescUnsync>(writerData, readerData);
- fuzzAidlWithReaders<AidlMessageQueueUnsync, AidlMQDescUnsync>(writerData, readerData);
+ fuzzHidlWithReaders<MessageQueueUnsync, MQDescUnsync>(writerData, readerData, false);
+ fuzzAidlWithReaders<AidlMessageQueueUnsync, AidlMQDescUnsync>(writerData, readerData,
+ false);
}
return 0;
diff --git a/include/fmq/MessageQueueBase.h b/include/fmq/MessageQueueBase.h
index c34a4ff..f4bf7e2 100644
--- a/include/fmq/MessageQueueBase.h
+++ b/include/fmq/MessageQueueBase.h
@@ -586,12 +586,6 @@
return;
}
- const auto& grantors = mDesc->grantors();
- for (const auto& grantor : grantors) {
- hardware::details::check(hardware::details::isAlignedToWordBoundary(grantor.offset) == true,
- "Grantor offsets need to be aligned");
- }
-
if (flavor == kSynchronizedReadWrite) {
mReadPtr = reinterpret_cast<std::atomic<uint64_t>*>(
mapGrantorDescr(hardware::details::READPTRPOS));
@@ -602,11 +596,11 @@
*/
mReadPtr = new (std::nothrow) std::atomic<uint64_t>;
}
- hardware::details::check(mReadPtr != nullptr, "mReadPtr is null");
+ if (mReadPtr == nullptr) goto error;
mWritePtr = reinterpret_cast<std::atomic<uint64_t>*>(
mapGrantorDescr(hardware::details::WRITEPTRPOS));
- hardware::details::check(mWritePtr != nullptr, "mWritePtr is null");
+ if (mWritePtr == nullptr) goto error;
if (resetPointers) {
mReadPtr->store(0, std::memory_order_release);
@@ -617,14 +611,32 @@
}
mRing = reinterpret_cast<uint8_t*>(mapGrantorDescr(hardware::details::DATAPTRPOS));
- hardware::details::check(mRing != nullptr, "mRing is null");
+ if (mRing == nullptr) goto error;
if (mDesc->countGrantors() > hardware::details::EVFLAGWORDPOS) {
mEvFlagWord = static_cast<std::atomic<uint32_t>*>(
mapGrantorDescr(hardware::details::EVFLAGWORDPOS));
- hardware::details::check(mEvFlagWord != nullptr, "mEvFlagWord is null");
+ if (mEvFlagWord == nullptr) goto error;
android::hardware::EventFlag::createEventFlag(mEvFlagWord, &mEventFlag);
}
+ return;
+error:
+ if (mReadPtr) {
+ if (flavor == kSynchronizedReadWrite) {
+ unmapGrantorDescr(mReadPtr, hardware::details::READPTRPOS);
+ } else {
+ delete mReadPtr;
+ }
+ mReadPtr = nullptr;
+ }
+ if (mWritePtr) {
+ unmapGrantorDescr(mWritePtr, hardware::details::WRITEPTRPOS);
+ mWritePtr = nullptr;
+ }
+ if (mRing) {
+ unmapGrantorDescr(mRing, hardware::details::EVFLAGWORDPOS);
+ mRing = nullptr;
+ }
}
template <template <typename, MQFlavor> typename MQDescriptorType, typename T, MQFlavor flavor>
@@ -1234,7 +1246,7 @@
template <template <typename, MQFlavor> typename MQDescriptorType, typename T, MQFlavor flavor>
void* MessageQueueBase<MQDescriptorType, T, flavor>::mapGrantorDescr(uint32_t grantorIdx) {
const native_handle_t* handle = mDesc->handle();
- auto grantors = mDesc->grantors();
+ const std::vector<android::hardware::GrantorDescriptor> grantors = mDesc->grantors();
if (handle == nullptr) {
hardware::details::logError("mDesc->handle is null");
return nullptr;
@@ -1247,10 +1259,32 @@
}
int fdIndex = grantors[grantorIdx].fdIndex;
+ if (fdIndex < 0 || fdIndex >= handle->numFds) {
+ hardware::details::logError(
+ std::string("fdIndex (" + std::to_string(fdIndex) + ") from grantor (index " +
+ std::to_string(grantorIdx) +
+ ") must be smaller than the number of fds in the handle: " +
+ std::to_string(handle->numFds)));
+ return nullptr;
+ }
+
/*
* Offset for mmap must be a multiple of PAGE_SIZE.
*/
+ if (!hardware::details::isAlignedToWordBoundary(grantors[grantorIdx].offset)) {
+ hardware::details::logError("Grantor (index " + std::to_string(grantorIdx) +
+ ") offset needs to be aligned to word boundary but is: " +
+ std::to_string(grantors[grantorIdx].offset));
+ return nullptr;
+ }
+
int mapOffset = (grantors[grantorIdx].offset / PAGE_SIZE) * PAGE_SIZE;
+ if (grantors[grantorIdx].extent < 0 || grantors[grantorIdx].extent > INT_MAX - PAGE_SIZE) {
+ hardware::details::logError(std::string("Grantor (index " + std::to_string(grantorIdx) +
+ ") extent value is too large or negative: " +
+ std::to_string(grantors[grantorIdx].extent)));
+ return nullptr;
+ }
int mapLength = grantors[grantorIdx].offset - mapOffset + grantors[grantorIdx].extent;
void* address = mmap(0, mapLength, PROT_READ | PROT_WRITE, MAP_SHARED, handle->data[fdIndex],
diff --git a/tests/fmq_unit_tests.cpp b/tests/fmq_unit_tests.cpp
index d3fdfbc..03db6ec 100644
--- a/tests/fmq_unit_tests.cpp
+++ b/tests/fmq_unit_tests.cpp
@@ -230,6 +230,7 @@
class BadQueueConfig : public TestBase<T> {};
class AidlOnlyBadQueueConfig : public ::testing::Test {};
+class HidlOnlyBadQueueConfig : public ::testing::Test {};
class Hidl2AidlOperation : public ::testing::Test {};
class DoubleFdFailures : public ::testing::Test {};
@@ -301,13 +302,76 @@
TYPED_TEST(BadQueueConfig, QueueSizeTooLarge) {
size_t numElementsInQueue = SIZE_MAX / sizeof(uint16_t) + 1;
- typename TypeParam::MQType* fmq =
- new (std::nothrow) typename TypeParam::MQType(numElementsInQueue);
- ASSERT_NE(nullptr, fmq);
+ typename TypeParam::MQType fmq(numElementsInQueue);
/*
* Should fail due to size being too large to fit into size_t.
*/
- ASSERT_FALSE(fmq->isValid());
+ ASSERT_FALSE(fmq.isValid());
+}
+
+// {flags, fdIndex, offset, extent}
+static const std::vector<android::hardware::GrantorDescriptor> kGrantors = {
+ {0, 0, 0, 4096},
+ {0, 0, 0, 4096},
+ {0, 0, 0, 4096},
+};
+
+// Make sure this passes without invalid index/extent for the next two test
+// cases
+TEST_F(HidlOnlyBadQueueConfig, SanityCheck) {
+ std::vector<android::hardware::GrantorDescriptor> grantors = kGrantors;
+
+ native_handle_t* handle = native_handle_create(1, 0);
+ int ashmemFd = ashmem_create_region("QueueHidlOnlyBad", 4096);
+ ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);
+ handle->data[0] = ashmemFd;
+
+ android::hardware::MQDescriptor<uint16_t, kSynchronizedReadWrite> desc(grantors, handle,
+ sizeof(uint16_t));
+ android::hardware::MessageQueue<uint16_t, kSynchronizedReadWrite> fmq(desc);
+ EXPECT_TRUE(fmq.isValid());
+
+ close(ashmemFd);
+}
+
+TEST_F(HidlOnlyBadQueueConfig, BadFdIndex) {
+ std::vector<android::hardware::GrantorDescriptor> grantors = kGrantors;
+ grantors[0].fdIndex = 5;
+
+ native_handle_t* handle = native_handle_create(1, 0);
+ int ashmemFd = ashmem_create_region("QueueHidlOnlyBad", 4096);
+ ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);
+ handle->data[0] = ashmemFd;
+
+ android::hardware::MQDescriptor<uint16_t, kSynchronizedReadWrite> desc(grantors, handle,
+ sizeof(uint16_t));
+ android::hardware::MessageQueue<uint16_t, kSynchronizedReadWrite> fmq(desc);
+ /*
+ * Should fail due fdIndex being out of range of the native_handle.
+ */
+ EXPECT_FALSE(fmq.isValid());
+
+ close(ashmemFd);
+}
+
+TEST_F(HidlOnlyBadQueueConfig, ExtentTooLarge) {
+ std::vector<android::hardware::GrantorDescriptor> grantors = kGrantors;
+ grantors[0].extent = 0xfffff041;
+
+ native_handle_t* handle = native_handle_create(1, 0);
+ int ashmemFd = ashmem_create_region("QueueHidlOnlyBad", 4096);
+ ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);
+ handle->data[0] = ashmemFd;
+
+ android::hardware::MQDescriptor<uint16_t, kSynchronizedReadWrite> desc(grantors, handle,
+ sizeof(uint16_t));
+ android::hardware::MessageQueue<uint16_t, kSynchronizedReadWrite> fmq(desc);
+ /*
+ * Should fail due to extent being too large.
+ */
+ EXPECT_FALSE(fmq.isValid());
+
+ close(ashmemFd);
}
// If this test fails and we do leak FDs, the next test will cause a crash
@@ -329,10 +393,9 @@
size_t numElementsInQueue = 64;
// Create HIDL side and get MQDescriptor
- MessageQueueSync8* fmq = new (std::nothrow) MessageQueueSync8(numElementsInQueue);
- ASSERT_NE(nullptr, fmq);
- ASSERT_TRUE(fmq->isValid());
- const HidlMQDescSync8* hidlDesc = fmq->getDesc();
+ MessageQueueSync8 fmq(numElementsInQueue);
+ ASSERT_TRUE(fmq.isValid());
+ const HidlMQDescSync8* hidlDesc = fmq.getDesc();
ASSERT_NE(nullptr, hidlDesc);
// Create AIDL MQDescriptor to send to another process based off the HIDL MQDescriptor
@@ -341,17 +404,16 @@
&aidlDesc);
// Other process will create the other side of the queue using the AIDL MQDescriptor
- AidlMessageQueueSync8* aidlFmq = new (std::nothrow) AidlMessageQueueSync8(aidlDesc);
- ASSERT_NE(nullptr, aidlFmq);
- ASSERT_TRUE(aidlFmq->isValid());
+ AidlMessageQueueSync8 aidlFmq(aidlDesc);
+ ASSERT_TRUE(aidlFmq.isValid());
// Make sure a write to the HIDL side, will show up for the AIDL side
constexpr size_t dataLen = 4;
uint8_t data[dataLen] = {12, 11, 10, 9};
- fmq->write(data, dataLen);
+ fmq.write(data, dataLen);
int8_t readData[dataLen];
- ASSERT_TRUE(aidlFmq->read(readData, dataLen));
+ ASSERT_TRUE(aidlFmq.read(readData, dataLen));
ASSERT_EQ(data[0], readData[0]);
ASSERT_EQ(data[1], readData[1]);
@@ -363,10 +425,9 @@
size_t numElementsInQueue = 64;
// Create HIDL side and get MQDescriptor
- MessageQueueUnsync8* fmq = new (std::nothrow) MessageQueueUnsync8(numElementsInQueue);
- ASSERT_NE(nullptr, fmq);
- ASSERT_TRUE(fmq->isValid());
- const HidlMQDescUnsync8* hidlDesc = fmq->getDesc();
+ MessageQueueUnsync8 fmq(numElementsInQueue);
+ ASSERT_TRUE(fmq.isValid());
+ const HidlMQDescUnsync8* hidlDesc = fmq.getDesc();
ASSERT_NE(nullptr, hidlDesc);
// Create AIDL MQDescriptor to send to another process based off the HIDL MQDescriptor
@@ -375,24 +436,22 @@
&aidlDesc);
// Other process will create the other side of the queue using the AIDL MQDescriptor
- AidlMessageQueueUnsync8* aidlFmq = new (std::nothrow) AidlMessageQueueUnsync8(aidlDesc);
- ASSERT_NE(nullptr, aidlFmq);
- ASSERT_TRUE(aidlFmq->isValid());
+ AidlMessageQueueUnsync8 aidlFmq(aidlDesc);
+ ASSERT_TRUE(aidlFmq.isValid());
// Can have multiple readers with unsync flavor
- AidlMessageQueueUnsync8* aidlFmq2 = new (std::nothrow) AidlMessageQueueUnsync8(aidlDesc);
- ASSERT_NE(nullptr, aidlFmq2);
- ASSERT_TRUE(aidlFmq2->isValid());
+ AidlMessageQueueUnsync8 aidlFmq2(aidlDesc);
+ ASSERT_TRUE(aidlFmq2.isValid());
// Make sure a write to the HIDL side, will show up for the AIDL side
constexpr size_t dataLen = 4;
uint8_t data[dataLen] = {12, 11, 10, 9};
- fmq->write(data, dataLen);
+ fmq.write(data, dataLen);
int8_t readData[dataLen];
- ASSERT_TRUE(aidlFmq->read(readData, dataLen));
+ ASSERT_TRUE(aidlFmq.read(readData, dataLen));
int8_t readData2[dataLen];
- ASSERT_TRUE(aidlFmq2->read(readData2, dataLen));
+ ASSERT_TRUE(aidlFmq2.read(readData2, dataLen));
ASSERT_EQ(data[0], readData[0]);
ASSERT_EQ(data[1], readData[1]);
@@ -417,12 +476,12 @@
grantors[1] = {0, 1 /* fdIndex */, 16, 16};
grantors[2] = {0, 1 /* fdIndex */, 16, 16};
- HidlMQDescUnsync8* hidlDesc = new (std::nothrow) HidlMQDescUnsync8(grantors, mqHandle, 10);
- ASSERT_TRUE(hidlDesc->isHandleValid());
+ HidlMQDescUnsync8 hidlDesc(grantors, mqHandle, 10);
+ ASSERT_TRUE(hidlDesc.isHandleValid());
AidlMQDescUnsync8 aidlDesc;
bool ret = android::unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, UnsynchronizedWrite>(
- *hidlDesc, &aidlDesc);
+ hidlDesc, &aidlDesc);
ASSERT_TRUE(ret);
}
@@ -439,16 +498,14 @@
grantors[1] = {0, 1 /* fdIndex */, 16, 16};
grantors[2] = {0, 0 /* fdIndex */, 16, 16};
- HidlMQDescUnsync8* hidlDesc = new (std::nothrow) HidlMQDescUnsync8(grantors, mqHandle, 10);
- ASSERT_TRUE(hidlDesc->isHandleValid());
+ HidlMQDescUnsync8 hidlDesc(grantors, mqHandle, 10);
+ ASSERT_TRUE(hidlDesc.isHandleValid());
AidlMQDescUnsync8 aidlDesc;
bool ret = android::unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, UnsynchronizedWrite>(
- *hidlDesc, &aidlDesc);
+ hidlDesc, &aidlDesc);
ASSERT_TRUE(ret);
EXPECT_EQ(aidlDesc.handle.fds.size(), 2);
- native_handle_close(mqHandle);
- native_handle_delete(mqHandle);
}
// TODO(b/165674950) Since AIDL does not support unsigned integers, it can only support
@@ -456,23 +513,21 @@
// lifted. Until then, check against SSIZE_MAX instead of SIZE_MAX.
TEST_F(AidlOnlyBadQueueConfig, QueueSizeTooLargeForAidl) {
size_t numElementsInQueue = SSIZE_MAX / sizeof(uint16_t) + 1;
- AidlMessageQueueSync16* fmq = new (std::nothrow) AidlMessageQueueSync16(numElementsInQueue);
- ASSERT_NE(nullptr, fmq);
+ AidlMessageQueueSync16 fmq(numElementsInQueue);
/*
* Should fail due to size being too large to fit into size_t.
*/
- ASSERT_FALSE(fmq->isValid());
+ ASSERT_FALSE(fmq.isValid());
}
TEST_F(AidlOnlyBadQueueConfig, NegativeAidlDescriptor) {
aidl::android::hardware::common::fmq::MQDescriptor<uint16_t, SynchronizedReadWrite> desc;
desc.quantum = -10;
- AidlMessageQueueSync16* fmq = new (std::nothrow) AidlMessageQueueSync16(desc);
- ASSERT_NE(nullptr, fmq);
+ AidlMessageQueueSync16 fmq(desc);
/*
* Should fail due to quantum being negative.
*/
- ASSERT_FALSE(fmq->isValid());
+ ASSERT_FALSE(fmq.isValid());
}
TEST_F(AidlOnlyBadQueueConfig, NegativeAidlDescriptorGrantor) {
@@ -481,12 +536,11 @@
desc.flags = 0;
desc.grantors.push_back(
aidl::android::hardware::common::fmq::GrantorDescriptor{.offset = 12, .extent = -10});
- AidlMessageQueueSync16* fmq = new (std::nothrow) AidlMessageQueueSync16(desc);
- ASSERT_NE(nullptr, fmq);
+ AidlMessageQueueSync16 fmq(desc);
/*
* Should fail due to grantor having negative extent.
*/
- ASSERT_FALSE(fmq->isValid());
+ ASSERT_FALSE(fmq.isValid());
}
/*
@@ -516,8 +570,8 @@
*/
TEST_F(DoubleFdFailures, InvalidFd) {
android::base::SetLogger(android::base::StdioLogger);
- EXPECT_DEATH_IF_SUPPORTED(AidlMessageQueueSync(64, false, android::base::unique_fd(3000), 64),
- "Check failed: exp mRing is null");
+ auto queue = AidlMessageQueueSync(64, false, android::base::unique_fd(3000), 64);
+ EXPECT_FALSE(queue.isValid());
}
/*
