From 0a10d6918c6279bacd01aa66350bb8d7b99d21ee Mon Sep 17 00:00:00 2001 From: Devin Moore Date: Wed, 16 Sep 2020 11:13:25 -0700 Subject: [PATCH 1/2] Change HIDL fmq tests to use int32_t for payload This is in preperation for more AIDL fmq testing. The types need to be the same and AIDL does not support unit16_t. Test: atest fmq_test fmq_unit_tests Bug: 142326204 Change-Id: Ice9c28c3d0df064ea43c31950b3438d2e0d19063 --- tests/msgq/1.0/ITestMsgQ.hal | 4 ++-- tests/msgq/1.0/default/TestMsgQ.cpp | 16 ++++++++-------- tests/msgq/1.0/default/TestMsgQ.h | 8 ++++---- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/tests/msgq/1.0/ITestMsgQ.hal b/tests/msgq/1.0/ITestMsgQ.hal index 112270a9e8..bd10237c90 100644 --- a/tests/msgq/1.0/ITestMsgQ.hal +++ b/tests/msgq/1.0/ITestMsgQ.hal @@ -31,7 +31,7 @@ interface ITestMsgQ { * * @return ret True if the setup is successful. */ - configureFmqSyncReadWrite(fmq_sync mqDesc) generates(bool ret); + configureFmqSyncReadWrite(fmq_sync mqDesc) generates(bool ret); /** * This method requests the service to return an MQDescriptor to @@ -46,7 +46,7 @@ interface ITestMsgQ { * @return mqDesc This structure describes the unsynchronized FMQ that was * set up by the service. Client can use it to set up the FMQ at its end. */ - getFmqUnsyncWrite(bool configureFmq) generates(bool ret, fmq_unsync mqDesc); + getFmqUnsyncWrite(bool configureFmq) generates(bool ret, fmq_unsync mqDesc); /** * This method request the service to write into the synchronized read/write diff --git a/tests/msgq/1.0/default/TestMsgQ.cpp b/tests/msgq/1.0/default/TestMsgQ.cpp index ba665c9204..44737378b3 100644 --- a/tests/msgq/1.0/default/TestMsgQ.cpp +++ b/tests/msgq/1.0/default/TestMsgQ.cpp @@ -25,7 +25,7 @@ namespace implementation { // Methods from ::android::hardware::tests::msgq::V1_0::ITestMsgQ follow. Return TestMsgQ::configureFmqSyncReadWrite( - const android::hardware::MQDescriptorSync& mqDesc) { + const android::hardware::MQDescriptorSync& mqDesc) { mFmqSynchronized.reset(new (std::nothrow) MessageQueueSync(mqDesc)); if ((mFmqSynchronized == nullptr) || (mFmqSynchronized->isValid() == false)) { return false; @@ -56,7 +56,7 @@ Return TestMsgQ::getFmqUnsyncWrite(bool configureFmq, getFmqUnsyncWrite_cb } Return TestMsgQ::requestWriteFmqSync(int32_t count) { - std::vector data(count); + std::vector data(count); for (int i = 0; i < count; i++) { data[i] = i; } @@ -65,14 +65,14 @@ Return TestMsgQ::requestWriteFmqSync(int32_t count) { } Return TestMsgQ::requestReadFmqSync(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqSynchronized->read(&data[0], count) && verifyData(&data[0], count); return result; } Return TestMsgQ::requestWriteFmqUnsync(int32_t count) { - std::vector data(count); + std::vector data(count); for (int i = 0; i < count; i++) { data[i] = i; } @@ -81,14 +81,14 @@ Return TestMsgQ::requestWriteFmqUnsync(int32_t count) { } Return TestMsgQ::requestReadFmqUnsync(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqUnsynchronized->read(&data[0], count) && verifyData(&data[0], count); return result; } Return TestMsgQ::requestBlockingRead(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqSynchronized->readBlocking( &data[0], count, @@ -103,7 +103,7 @@ Return TestMsgQ::requestBlockingRead(int32_t count) { } Return TestMsgQ::requestBlockingReadDefaultEventFlagBits(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqSynchronized->readBlocking( &data[0], count); @@ -116,7 +116,7 @@ Return TestMsgQ::requestBlockingReadDefaultEventFlagBits(int32_t count) { } Return TestMsgQ::requestBlockingReadRepeat(int32_t count, int32_t numIter) { - std::vector data(count); + std::vector data(count); for (int i = 0; i < numIter; i++) { bool result = mFmqSynchronized->readBlocking( &data[0], diff --git a/tests/msgq/1.0/default/TestMsgQ.h b/tests/msgq/1.0/default/TestMsgQ.h index f9fcddd4bc..8a204b725d 100644 --- a/tests/msgq/1.0/default/TestMsgQ.h +++ b/tests/msgq/1.0/default/TestMsgQ.h @@ -49,13 +49,13 @@ using android::hardware::MQDescriptorUnsync; using android::hardware::MessageQueue; struct TestMsgQ : public ITestMsgQ { - typedef MessageQueue MessageQueueSync; - typedef MessageQueue MessageQueueUnsync; + typedef MessageQueue MessageQueueSync; + typedef MessageQueue MessageQueueUnsync; TestMsgQ() : mFmqSynchronized(nullptr), mFmqUnsynchronized(nullptr) {} // Methods from ::android::hardware::tests::msgq::V1_0::ITestMsgQ follow. - Return configureFmqSyncReadWrite(const MQDescriptorSync& mqDesc) override; + Return configureFmqSyncReadWrite(const MQDescriptorSync& mqDesc) override; Return getFmqUnsyncWrite(bool configureFmq, getFmqUnsyncWrite_cb _hidl_cb) override; Return requestWriteFmqSync(int32_t count) override; Return requestReadFmqSync(int32_t count) override; @@ -73,7 +73,7 @@ private: /* * Utility function to verify data read from the fast message queue. */ - bool verifyData(uint16_t* data, int count) { + bool verifyData(int32_t* data, int count) { for (int i = 0; i < count; i++) { if (data[i] != i) return false; } From 340f895d30f1b6b1a555ecc2ffdb639dbd67606c Mon Sep 17 00:00:00 2001 From: Devin Moore Date: Wed, 9 Sep 2020 13:38:52 -0700 Subject: [PATCH 2/2] Add template parameters to MQDescriptor First parameter is used to determine the type of the payload, and the second parameter is used to determine the type of queue. Added two types to be use in that second parameter. SynchronizedReadWrite and UnsynchronizedWrite. Test: atest fmq_unit_tests fmq_test Bug: 142326204 Change-Id: If736389ebecd02b87879850714606523e5145579 --- .../common/SynchronizedReadWrite.aidl | 22 +++++++++++++++ .../hardware/common/UnsynchronizedWrite.aidl | 22 +++++++++++++++ .../android/hardware/common/MQDescriptor.aidl | 5 +++- .../common/SynchronizedReadWrite.aidl | 27 +++++++++++++++++++ .../hardware/common/UnsynchronizedWrite.aidl | 27 +++++++++++++++++++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl create mode 100644 common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl create mode 100644 common/aidl/android/hardware/common/SynchronizedReadWrite.aidl create mode 100644 common/aidl/android/hardware/common/UnsynchronizedWrite.aidl diff --git a/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl new file mode 100644 index 0000000000..aec3d6dfd3 --- /dev/null +++ b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl @@ -0,0 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL interface (or parcelable). Do not try to +// edit this file. It looks like you are doing that because you have modified +// an AIDL interface in a backward-incompatible way, e.g., deleting a function +// from an interface or a field from a parcelable and it broke the build. That +// breakage is intended. +// +// You must not make a backward incompatible changes to the AIDL files built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.common; +@VintfStability +enum SynchronizedReadWrite { + EMPTY = 0, +} diff --git a/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl new file mode 100644 index 0000000000..e390d20bce --- /dev/null +++ b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl @@ -0,0 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL interface (or parcelable). Do not try to +// edit this file. It looks like you are doing that because you have modified +// an AIDL interface in a backward-incompatible way, e.g., deleting a function +// from an interface or a field from a parcelable and it broke the build. That +// breakage is intended. +// +// You must not make a backward incompatible changes to the AIDL files built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.common; +@VintfStability +enum UnsynchronizedWrite { + EMPTY = 0, +} diff --git a/common/aidl/android/hardware/common/MQDescriptor.aidl b/common/aidl/android/hardware/common/MQDescriptor.aidl index 899768890e..7e89b15f56 100644 --- a/common/aidl/android/hardware/common/MQDescriptor.aidl +++ b/common/aidl/android/hardware/common/MQDescriptor.aidl @@ -22,9 +22,12 @@ import android.hardware.common.GrantorDescriptor; * For use with libfmq. This is created from an instance of AidlMessageQueue, * and is used to pass information required to create another instance of that * queue for fast communication. + * T - is used to specify the type of the payload + * Flavor - is used to specify the type of the queue using + * android.hardware.common.SynchronizedReadWrite or UnsynchronizedWrite */ @VintfStability -parcelable MQDescriptor { +parcelable MQDescriptor { /* * Describes each of the grantors for the message queue. They are used to * get the readptr, writeptr, dataptr, and the optional EventFlag word diff --git a/common/aidl/android/hardware/common/SynchronizedReadWrite.aidl b/common/aidl/android/hardware/common/SynchronizedReadWrite.aidl new file mode 100644 index 0000000000..ef93bf2aba --- /dev/null +++ b/common/aidl/android/hardware/common/SynchronizedReadWrite.aidl @@ -0,0 +1,27 @@ +/* + * Copyright 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. + */ + +package android.hardware.common; + +/* + * For use with android.hardware.common.MQDescriptor to specify which type of + * queue to use. SynchronizedReadWrite is single reader, single writer, with no + * overflow. All messages written need to be read. + */ +@VintfStability +enum SynchronizedReadWrite { + EMPTY, +} diff --git a/common/aidl/android/hardware/common/UnsynchronizedWrite.aidl b/common/aidl/android/hardware/common/UnsynchronizedWrite.aidl new file mode 100644 index 0000000000..aa27c8d029 --- /dev/null +++ b/common/aidl/android/hardware/common/UnsynchronizedWrite.aidl @@ -0,0 +1,27 @@ +/* + * Copyright 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. + */ + +package android.hardware.common; + +/* + * For use with android.hardware.common.MQDescriptor to specify which type of + * queue to use. UnsynchronizedWrite is single writer, multiple reader, with + * overflow. If messages are not read fast enough, they can be overwritten. + */ +@VintfStability +enum UnsynchronizedWrite { + EMPTY, +}