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 #include <shared/macros.h>
18 #include <shared/send_message.h>
19
20 #include <inttypes.h>
21
22 #include <shared/abort.h>
23 #include <shared/chunk_allocator.h>
24 #include <shared/nano_endian.h>
25 #include <shared/nano_string.h>
26
27 #include <chre/util/nanoapp/log.h>
28
29 #include "chre_api/chre.h"
30
31 #define LOG_TAG "[SendMessage]"
32
33 namespace nanoapp_testing {
34
35 namespace {
36 // If true, indicates that a test has failed. This variable is used to guard
37 // against sending additional messages to the host when the test already failed.
38 bool gTestFailed = false;
39 } // namespace
40
41 constexpr size_t kAllocSize = 128;
42
43 static ChunkAllocator<kAllocSize, 4> gChunkAlloc;
44
freeChunkAllocMessage(void * message,size_t messageSize)45 static void freeChunkAllocMessage(void *message, size_t messageSize) {
46 if (messageSize > kAllocSize) {
47 uint32_t localSize = uint32_t(messageSize);
48 EXPECT_FAIL_RETURN("freeChunkAllocMessage given oversized message:",
49 &localSize);
50 }
51 if (!gChunkAlloc.free(message)) {
52 uint32_t localPtr =
53 reinterpret_cast<size_t>(message) & UINT32_C(0xFFFFFFFF);
54 EXPECT_FAIL_RETURN("freeChunkAllocMessage given bad pointer:", &localPtr);
55 }
56 }
57
freeHeapMessage(void * message,size_t)58 static void freeHeapMessage(void *message, size_t /* messageSize */) {
59 if (gChunkAlloc.contains(message)) {
60 uint32_t localPtr =
61 reinterpret_cast<size_t>(message) & UINT32_C(0xFFFFFFFF);
62 EXPECT_FAIL_RETURN("freeHeapMessage given ChunkAlloc pointer:", &localPtr);
63 }
64 chreHeapFree(message);
65 }
66
fatalError()67 static void fatalError() {
68 // Attempt to send a context-less failure message, in the hopes that
69 // might get through.
70 chreSendMessageToHostEndpoint(nullptr, 0,
71 static_cast<uint32_t>(MessageType::kFailure),
72 CHRE_HOST_ENDPOINT_BROADCAST, nullptr);
73 // Whether or not that made it through, unambigiously fail this test
74 // by aborting.
75 nanoapp_testing::abort();
76 }
77
78 // TODO(b/32114261): Remove this method.
needToPrependMessageType()79 static bool needToPrependMessageType() {
80 // TODO: When we have a new API that properly send the messageType,
81 // this method should get the API version and return appropriately.
82 // Eventually we should remove this hacky method.
83 return true;
84 }
85
getMessageMemory(size_t * size,bool * ChunkAlloc)86 static void *getMessageMemory(size_t *size, bool *ChunkAlloc) {
87 if (needToPrependMessageType()) {
88 *size += sizeof(uint32_t);
89 }
90 void *ret = gChunkAlloc.alloc(*size);
91 if (ret != nullptr) {
92 *ChunkAlloc = true;
93 } else {
94 // Not expected, but possible if the CHRE is lagging in freeing
95 // these messages, or if we're sending a huge message.
96 *ChunkAlloc = false;
97 ret = chreHeapAlloc(static_cast<uint32_t>(*size));
98 if (ret == nullptr) {
99 fatalError();
100 }
101 }
102 return ret;
103 }
104
105 // TODO(b/32114261): Remove this method.
prependMessageType(MessageType messageType,void * memory)106 static void *prependMessageType(MessageType messageType, void *memory) {
107 if (!needToPrependMessageType()) {
108 return memory;
109 }
110 uint32_t type =
111 nanoapp_testing::hostToLittleEndian(static_cast<uint32_t>(messageType));
112 memcpy(memory, &type, sizeof(type));
113 uint8_t *ptr = static_cast<uint8_t *>(memory);
114 ptr += sizeof(type);
115 return ptr;
116 }
117
internalSendMessage(MessageType messageType,void * data,size_t dataSize,bool ChunkAlloc)118 static void internalSendMessage(MessageType messageType, void *data,
119 size_t dataSize, bool ChunkAlloc) {
120 if (gTestFailed) {
121 LOGW("Test already failed: skipping sending message type %" PRIu32,
122 messageType);
123 return;
124 } else if (messageType == MessageType::kFailure ||
125 messageType == MessageType::kInternalFailure) {
126 gTestFailed = true;
127 }
128
129 // Note that if the CHRE implementation occasionally drops a message
130 // here, then tests will become flaky. For now, we consider that to
131 // be a flaky CHRE implementation which should fail testing.
132 if (!chreSendMessageToHostEndpoint(
133 data, dataSize, static_cast<uint32_t>(messageType),
134 CHRE_HOST_ENDPOINT_BROADCAST,
135 ChunkAlloc ? freeChunkAllocMessage : freeHeapMessage)) {
136 fatalError();
137 }
138 }
139
sendMessageToHost(MessageType messageType,const void * data,size_t dataSize)140 void sendMessageToHost(MessageType messageType, const void *data,
141 size_t dataSize) {
142 if ((dataSize == 0) && (data != nullptr)) {
143 sendInternalFailureToHost("Bad sendMessageToHost args");
144 }
145 bool ChunkAlloc = true;
146 size_t fullMessageSize = dataSize;
147 void *myMessageBase = getMessageMemory(&fullMessageSize, &ChunkAlloc);
148 void *ptr = prependMessageType(messageType, myMessageBase);
149 memcpy(ptr, data, dataSize);
150 internalSendMessage(messageType, myMessageBase, fullMessageSize, ChunkAlloc);
151 }
152
sendStringToHost(MessageType messageType,const char * message,const uint32_t * value)153 void sendStringToHost(MessageType messageType, const char *message,
154 const uint32_t *value) {
155 if (message == nullptr) {
156 sendInternalFailureToHost("sendStringToHost 'message' is NULL");
157 }
158 bool ChunkAlloc = true;
159 const size_t messageStrlen = strlen(message);
160 size_t myMessageLen = messageStrlen;
161 if (value != nullptr) {
162 myMessageLen += kUint32ToHexAsciiBufferMinLen;
163 }
164 // Add null terminator
165 myMessageLen++;
166
167 size_t fullMessageLen = myMessageLen;
168 char *fullMessage =
169 static_cast<char *>(getMessageMemory(&fullMessageLen, &ChunkAlloc));
170 char *ptr = static_cast<char *>(prependMessageType(messageType, fullMessage));
171 memcpy(ptr, message, messageStrlen);
172 ptr += messageStrlen;
173 if (value != nullptr) {
174 uint32ToHexAscii(
175 ptr, fullMessageLen - static_cast<size_t>(ptr - fullMessage), *value);
176 }
177 // Add the terminator.
178 fullMessage[fullMessageLen - 1] = '\0';
179
180 internalSendMessage(messageType, fullMessage, fullMessageLen, ChunkAlloc);
181 }
182
logFailureMessage(const char * message,const uint32_t * value)183 void logFailureMessage(const char *message, const uint32_t *value) {
184 if (value != nullptr) {
185 LOGE("TEST FAIL: %s0x%08" PRIX32, message, *value);
186 } else {
187 LOGE("TEST FAIL: %s", message);
188 }
189 }
190
sendInternalFailureToHost(const char * message,const uint32_t * value,AbortBlame reason)191 void sendInternalFailureToHost(const char *message, const uint32_t *value,
192 AbortBlame reason) {
193 sendStringToHost(MessageType::kInternalFailure, message, value);
194 logFailureMessage(message, value);
195 nanoapp_testing::abort(reason);
196 }
197
198 } // namespace nanoapp_testing
199