1 /*
2 * Copyright (C) 2016 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 #ifndef _FMSGQ_DESCRIPTOR_H
18 #define _FMSGQ_DESCRIPTOR_H
19
20 #include <unistd.h>
21
22 #include <cutils/native_handle.h>
23 #include <hidl/HidlInternal.h>
24 #include <hidl/HidlSupport.h>
25
26 namespace android {
27 namespace hardware {
28
29 typedef uint64_t RingBufferPosition;
30
31 struct GrantorDescriptor {
32 uint32_t flags __attribute__ ((aligned(4)));
33 uint32_t fdIndex __attribute__ ((aligned(4)));
34 uint32_t offset __attribute__ ((aligned(4)));
35 uint64_t extent __attribute__ ((aligned(8)));
36 };
37
38 static_assert(offsetof(GrantorDescriptor, flags) == 0, "wrong offset");
39 static_assert(offsetof(GrantorDescriptor, fdIndex) == 4, "wrong offset");
40 static_assert(offsetof(GrantorDescriptor, offset) == 8, "wrong offset");
41 static_assert(offsetof(GrantorDescriptor, extent) == 16, "wrong offset");
42 static_assert(sizeof(GrantorDescriptor) == 24, "wrong size");
43 static_assert(__alignof(GrantorDescriptor) == 8, "wrong alignment");
44
45 enum MQFlavor : uint32_t {
46 /*
47 * kSynchronizedReadWrite represents the wait-free synchronized flavor of the
48 * FMQ. It is intended to be have a single reader and single writer.
49 * Attempts to overflow/underflow returns a failure.
50 */
51 kSynchronizedReadWrite = 0x01,
52 /*
53 * kUnsynchronizedWrite represents the flavor of FMQ where writes always
54 * succeed. This flavor allows one writer and many readers. A read operation
55 * can detect an overwrite and reset the read counter.
56 */
57 kUnsynchronizedWrite = 0x02
58 };
59
60 template <typename T, MQFlavor flavor>
61 struct MQDescriptor {
62 // Takes ownership of handle
63 MQDescriptor(
64 const std::vector<GrantorDescriptor>& grantors,
65 native_handle_t* nHandle, size_t size);
66
67 // Takes ownership of handle
68 MQDescriptor(size_t bufferSize, native_handle_t* nHandle,
69 size_t messageSize, bool configureEventFlag = false);
70
71 MQDescriptor();
72 ~MQDescriptor();
73
MQDescriptorMQDescriptor74 explicit MQDescriptor(const MQDescriptor& other) : MQDescriptor() { *this = other; }
75 MQDescriptor& operator=(const MQDescriptor& other);
76
77 size_t getSize() const;
78
79 size_t getQuantum() const;
80
81 int32_t getFlags() const;
82
isHandleValidMQDescriptor83 bool isHandleValid() const { return mHandle != nullptr; }
countGrantorsMQDescriptor84 size_t countGrantors() const { return mGrantors.size(); }
85
grantorsMQDescriptor86 inline const ::android::hardware::hidl_vec<GrantorDescriptor> &grantors() const {
87 return mGrantors;
88 }
89
grantorsMQDescriptor90 inline ::android::hardware::hidl_vec<GrantorDescriptor> &grantors() {
91 return mGrantors;
92 }
93
handleMQDescriptor94 inline const ::native_handle_t *handle() const {
95 return mHandle;
96 }
97
handleMQDescriptor98 inline ::native_handle_t *handle() {
99 return mHandle;
100 }
101
102 static const size_t kOffsetOfGrantors;
103 static const size_t kOffsetOfHandle;
104 enum GrantorType : int { READPTRPOS = 0, WRITEPTRPOS, DATAPTRPOS, EVFLAGWORDPOS };
105
106 /*
107 * There should at least be GrantorDescriptors for the read counter, write
108 * counter and data buffer. A GrantorDescriptor for an EventFlag word is
109 * not required if there is no need for blocking FMQ operations.
110 */
111 static constexpr int32_t kMinGrantorCount = DATAPTRPOS + 1;
112
113 /*
114 * Minimum number of GrantorDescriptors required if EventFlag support is
115 * needed for blocking FMQ operations.
116 */
117 static constexpr int32_t kMinGrantorCountForEvFlagSupport = EVFLAGWORDPOS + 1;
118
119 //TODO(b/34160777) Identify a better solution that supports remoting.
alignToWordBoundaryMQDescriptor120 static inline size_t alignToWordBoundary(size_t length) {
121 constexpr size_t kAlignmentSize = 64;
122 if (kAlignmentSize % __WORDSIZE != 0) {
123 details::logAlwaysFatal("Incompatible word size");
124 }
125
126 /*
127 * Check if alignment to word boundary would cause an overflow.
128 */
129 if (length > SIZE_MAX - kAlignmentSize/8 + 1) {
130 details::logAlwaysFatal("Queue size too large");
131 }
132
133 return (length + kAlignmentSize/8 - 1) & ~(kAlignmentSize/8 - 1U);
134 }
135
isAlignedToWordBoundaryMQDescriptor136 static inline size_t isAlignedToWordBoundary(size_t offset) {
137 constexpr size_t kAlignmentSize = 64;
138 return (offset & (kAlignmentSize/8 - 1)) == 0;
139 }
140 private:
141 ::android::hardware::hidl_vec<GrantorDescriptor> mGrantors;
142 ::android::hardware::details::hidl_pointer<native_handle_t> mHandle;
143 uint32_t mQuantum;
144 uint32_t mFlags;
145 };
146
147 template<typename T, MQFlavor flavor>
148 const size_t MQDescriptor<T, flavor>::kOffsetOfGrantors = offsetof(MQDescriptor, mGrantors);
149
150 template<typename T, MQFlavor flavor>
151 const size_t MQDescriptor<T, flavor>::kOffsetOfHandle = offsetof(MQDescriptor, mHandle);
152
153 /*
154 * MQDescriptorSync will describe the wait-free synchronized
155 * flavor of FMQ.
156 */
157 template<typename T>
158 using MQDescriptorSync = MQDescriptor<T, kSynchronizedReadWrite>;
159
160 /*
161 * MQDescriptorUnsync will describe the unsynchronized write
162 * flavor of FMQ.
163 */
164 template<typename T>
165 using MQDescriptorUnsync = MQDescriptor<T, kUnsynchronizedWrite>;
166
167 template<typename T, MQFlavor flavor>
MQDescriptor(const std::vector<GrantorDescriptor> & grantors,native_handle_t * nhandle,size_t size)168 MQDescriptor<T, flavor>::MQDescriptor(
169 const std::vector<GrantorDescriptor>& grantors,
170 native_handle_t* nhandle,
171 size_t size)
172 : mHandle(nhandle),
173 mQuantum(size),
174 mFlags(flavor) {
175 mGrantors.resize(grantors.size());
176 for (size_t i = 0; i < grantors.size(); ++i) {
177 if (isAlignedToWordBoundary(grantors[i].offset) == false) {
178 details::logAlwaysFatal("Grantor offsets need to be aligned");
179 }
180 mGrantors[i] = grantors[i];
181 }
182 }
183
184 template<typename T, MQFlavor flavor>
MQDescriptor(size_t bufferSize,native_handle_t * nHandle,size_t messageSize,bool configureEventFlag)185 MQDescriptor<T, flavor>::MQDescriptor(size_t bufferSize, native_handle_t *nHandle,
186 size_t messageSize, bool configureEventFlag)
187 : mHandle(nHandle), mQuantum(messageSize), mFlags(flavor) {
188 /*
189 * If configureEventFlag is true, allocate an additional spot in mGrantor
190 * for containing the fd and offset for mmapping the EventFlag word.
191 */
192 mGrantors.resize(configureEventFlag? kMinGrantorCountForEvFlagSupport : kMinGrantorCount);
193
194 size_t memSize[] = {
195 sizeof(RingBufferPosition), /* memory to be allocated for read pointer counter */
196 sizeof(RingBufferPosition), /* memory to be allocated for write pointer counter */
197 bufferSize, /* memory to be allocated for data buffer */
198 sizeof(std::atomic<uint32_t>)/* memory to be allocated for EventFlag word */
199 };
200
201 /*
202 * Create a default grantor descriptor for read, write pointers and
203 * the data buffer. fdIndex parameter is set to 0 by default and
204 * the offset for each grantor is contiguous.
205 */
206 for (size_t grantorPos = 0, offset = 0;
207 grantorPos < mGrantors.size();
208 offset += memSize[grantorPos++]) {
209 mGrantors[grantorPos] = {
210 0 /* grantor flags */,
211 0 /* fdIndex */,
212 static_cast<uint32_t>(alignToWordBoundary(offset)),
213 memSize[grantorPos]
214 };
215 }
216 }
217
218 template <typename T, MQFlavor flavor>
219 MQDescriptor<T, flavor>& MQDescriptor<T, flavor>::operator=(const MQDescriptor& other) {
220 mGrantors = other.mGrantors;
221 if (mHandle != nullptr) {
222 native_handle_close(mHandle);
223 native_handle_delete(mHandle);
224 mHandle = nullptr;
225 }
226 mQuantum = other.mQuantum;
227 mFlags = other.mFlags;
228
229 if (other.mHandle != nullptr) {
230 mHandle = native_handle_create(
231 other.mHandle->numFds, other.mHandle->numInts);
232
233 for (int i = 0; i < other.mHandle->numFds; ++i) {
234 mHandle->data[i] = dup(other.mHandle->data[i]);
235 }
236
237 memcpy(&mHandle->data[other.mHandle->numFds],
238 &other.mHandle->data[other.mHandle->numFds],
239 other.mHandle->numInts * sizeof(int));
240 }
241
242 return *this;
243 }
244
245 template<typename T, MQFlavor flavor>
MQDescriptor()246 MQDescriptor<T, flavor>::MQDescriptor() : MQDescriptor(
247 std::vector<android::hardware::GrantorDescriptor>(),
248 nullptr /* nHandle */,
249 0 /* size */) {}
250
251 template<typename T, MQFlavor flavor>
~MQDescriptor()252 MQDescriptor<T, flavor>::~MQDescriptor() {
253 if (mHandle != nullptr) {
254 native_handle_close(mHandle);
255 native_handle_delete(mHandle);
256 }
257 }
258
259 template<typename T, MQFlavor flavor>
getSize()260 size_t MQDescriptor<T, flavor>::getSize() const {
261 return mGrantors[DATAPTRPOS].extent;
262 }
263
264 template<typename T, MQFlavor flavor>
getQuantum()265 size_t MQDescriptor<T, flavor>::getQuantum() const { return mQuantum; }
266
267 template<typename T, MQFlavor flavor>
getFlags()268 int32_t MQDescriptor<T, flavor>::getFlags() const { return mFlags; }
269
270 template<typename T, MQFlavor flavor>
toString(const MQDescriptor<T,flavor> & q)271 std::string toString(const MQDescriptor<T, flavor> &q) {
272 std::string os;
273 if (flavor & kSynchronizedReadWrite) {
274 os += "fmq_sync";
275 }
276 if (flavor & kUnsynchronizedWrite) {
277 os += "fmq_unsync";
278 }
279 os += " {"
280 + toString(q.grantors().size()) + " grantor(s), "
281 + "size = " + toString(q.getSize())
282 + ", .handle = " + toString(q.handle())
283 + ", .quantum = " + toString(q.getQuantum()) + "}";
284 return os;
285 }
286
287 } // namespace hardware
288 } // namespace android
289
290 #endif // FMSGQ_DESCRIPTOR_H
291