1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "TestAidlMsgQ.h"
18
19 namespace aidl {
20 namespace android {
21 namespace fmq {
22 namespace test {
23
24 // Methods from ::aidl::android::fmq::test::ITestAidlMsgQ follow.
configureFmqSyncReadWrite(const MQDescriptor<int32_t,SynchronizedReadWrite> & mqDesc,bool * _aidl_return)25 ndk::ScopedAStatus TestAidlMsgQ::configureFmqSyncReadWrite(
26 const MQDescriptor<int32_t, SynchronizedReadWrite>& mqDesc, bool* _aidl_return) {
27 mFmqSynchronized.reset(new (std::nothrow) TestAidlMsgQ::MessageQueueSync(mqDesc));
28 if ((mFmqSynchronized == nullptr) || (mFmqSynchronized->isValid() == false)) {
29 return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
30 }
31 /*
32 * Initialize the EventFlag word with bit FMQ_NOT_FULL.
33 */
34 auto evFlagWordPtr = mFmqSynchronized->getEventFlagWord();
35 if (evFlagWordPtr != nullptr) {
36 std::atomic_init(evFlagWordPtr, static_cast<uint32_t>(EventFlagBits::FMQ_NOT_FULL));
37 }
38 *_aidl_return = true;
39 return ndk::ScopedAStatus::ok();
40 }
41
getFmqUnsyncWrite(bool configureFmq,bool userFd,MQDescriptor<int32_t,UnsynchronizedWrite> * mqDesc,bool * _aidl_return)42 ndk::ScopedAStatus TestAidlMsgQ::getFmqUnsyncWrite(
43 bool configureFmq, bool userFd, MQDescriptor<int32_t, UnsynchronizedWrite>* mqDesc,
44 bool* _aidl_return) {
45 if (configureFmq) {
46 static constexpr size_t kNumElementsInQueue = 1024;
47 static constexpr size_t kElementSizeBytes = sizeof(int32_t);
48 ::android::base::unique_fd ringbufferFd;
49 if (userFd) {
50 ringbufferFd.reset(
51 ::ashmem_create_region("UnsyncWrite", kNumElementsInQueue * kElementSizeBytes));
52 }
53 mFmqUnsynchronized.reset(new (std::nothrow) TestAidlMsgQ::MessageQueueUnsync(
54 kNumElementsInQueue, false, std::move(ringbufferFd),
55 kNumElementsInQueue * kElementSizeBytes));
56 }
57
58 if ((mFmqUnsynchronized == nullptr) || (mFmqUnsynchronized->isValid() == false) ||
59 (mqDesc == nullptr)) {
60 *_aidl_return = false;
61 } else {
62 *mqDesc = std::move(mFmqUnsynchronized->dupeDesc());
63 // set write-protection so readers can't mmap and write
64 int res = ashmem_set_prot_region(mqDesc->handle.fds[0].get(), PROT_READ);
65 if (res == -1) {
66 ALOGE("Failed to set write protection: %s", strerror(errno));
67 *_aidl_return = false;
68 } else {
69 *_aidl_return = true;
70 }
71 }
72
73 return ndk::ScopedAStatus::ok();
74 }
75
requestBlockingRead(int32_t count)76 ndk::ScopedAStatus TestAidlMsgQ::requestBlockingRead(int32_t count) {
77 std::vector<int32_t> data(count);
78 bool result = mFmqSynchronized->readBlocking(
79 &data[0], count, static_cast<uint32_t>(EventFlagBits::FMQ_NOT_FULL),
80 static_cast<uint32_t>(EventFlagBits::FMQ_NOT_EMPTY), 5000000000 /* timeOutNanos */);
81
82 if (result == false) {
83 ALOGE("Blocking read fails");
84 }
85 return ndk::ScopedAStatus::ok();
86 }
87
requestBlockingReadDefaultEventFlagBits(int32_t count)88 ndk::ScopedAStatus TestAidlMsgQ::requestBlockingReadDefaultEventFlagBits(int32_t count) {
89 std::vector<int32_t> data(count);
90 bool result = mFmqSynchronized->readBlocking(&data[0], count);
91
92 if (result == false) {
93 ALOGE("Blocking read fails");
94 }
95
96 return ndk::ScopedAStatus::ok();
97 }
98
requestBlockingReadRepeat(int32_t count,int32_t numIter)99 ndk::ScopedAStatus TestAidlMsgQ::requestBlockingReadRepeat(int32_t count, int32_t numIter) {
100 std::vector<int32_t> data(count);
101 for (int i = 0; i < numIter; i++) {
102 bool result = mFmqSynchronized->readBlocking(
103 &data[0], count, static_cast<uint32_t>(EventFlagBits::FMQ_NOT_FULL),
104 static_cast<uint32_t>(EventFlagBits::FMQ_NOT_EMPTY), 5000000000 /* timeOutNanos */);
105
106 if (result == false) {
107 ALOGE("Blocking read fails");
108 break;
109 }
110 }
111
112 return ndk::ScopedAStatus::ok();
113 }
114
requestReadFmqSync(int32_t count,bool * _aidl_return)115 ndk::ScopedAStatus TestAidlMsgQ::requestReadFmqSync(int32_t count, bool* _aidl_return) {
116 std::vector<int32_t> data(count);
117 bool result = mFmqSynchronized->read(&data[0], count) && verifyData(&data[0], count);
118 *_aidl_return = result;
119 return ndk::ScopedAStatus::ok();
120 }
121
requestReadFmqUnsync(int32_t count,bool * _aidl_return)122 ndk::ScopedAStatus TestAidlMsgQ::requestReadFmqUnsync(int32_t count, bool* _aidl_return) {
123 std::vector<int32_t> data(count);
124 bool result = mFmqUnsynchronized->read(&data[0], count) && verifyData(&data[0], count);
125 *_aidl_return = result;
126 return ndk::ScopedAStatus::ok();
127 }
128
requestWriteFmqSync(int32_t count,bool * _aidl_return)129 ndk::ScopedAStatus TestAidlMsgQ::requestWriteFmqSync(int32_t count, bool* _aidl_return) {
130 std::vector<int32_t> data(count);
131 for (int i = 0; i < count; i++) {
132 data[i] = i;
133 }
134 bool result = mFmqSynchronized->write(&data[0], count);
135 *_aidl_return = result;
136 return ndk::ScopedAStatus::ok();
137 }
138
requestWriteFmqUnsync(int32_t count,bool * _aidl_return)139 ndk::ScopedAStatus TestAidlMsgQ::requestWriteFmqUnsync(int32_t count, bool* _aidl_return) {
140 std::vector<int32_t> data(count);
141 for (int i = 0; i < count; i++) {
142 data[i] = i;
143 }
144 if (!mFmqUnsynchronized) {
145 ALOGE("Unsynchronized queue is not configured.");
146 *_aidl_return = false;
147 return ndk::ScopedAStatus::ok();
148 }
149 bool result = mFmqUnsynchronized->write(&data[0], count);
150 *_aidl_return = result;
151 return ndk::ScopedAStatus::ok();
152 }
153
154 } // namespace test
155 } // namespace fmq
156 } // namespace android
157 } // namespace aidl
158