Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 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 | #define LOG_TAG "RpcSession" |
| 18 | |
| 19 | #include <binder/RpcSession.h> |
| 20 | |
| 21 | #include <inttypes.h> |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 22 | #include <poll.h> |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 23 | #include <unistd.h> |
| 24 | |
| 25 | #include <string_view> |
| 26 | |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 27 | #include <android-base/macros.h> |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 28 | #include <binder/Parcel.h> |
Steven Moreland | ee78e76 | 2021-05-05 21:12:51 +0000 | [diff] [blame] | 29 | #include <binder/RpcServer.h> |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 30 | #include <binder/Stability.h> |
| 31 | #include <utils/String8.h> |
| 32 | |
| 33 | #include "RpcSocketAddress.h" |
| 34 | #include "RpcState.h" |
| 35 | #include "RpcWireFormat.h" |
| 36 | |
| 37 | #ifdef __GLIBC__ |
| 38 | extern "C" pid_t gettid(); |
| 39 | #endif |
| 40 | |
| 41 | namespace android { |
| 42 | |
| 43 | using base::unique_fd; |
| 44 | |
| 45 | RpcSession::RpcSession() { |
| 46 | LOG_RPC_DETAIL("RpcSession created %p", this); |
| 47 | |
| 48 | mState = std::make_unique<RpcState>(); |
| 49 | } |
| 50 | RpcSession::~RpcSession() { |
| 51 | LOG_RPC_DETAIL("RpcSession destroyed %p", this); |
| 52 | |
| 53 | std::lock_guard<std::mutex> _l(mMutex); |
Steven Moreland | bb543a8 | 2021-05-11 02:31:50 +0000 | [diff] [blame] | 54 | LOG_ALWAYS_FATAL_IF(mServerConnections.size() != 0, |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 55 | "Should not be able to destroy a session with servers in use."); |
| 56 | } |
| 57 | |
| 58 | sp<RpcSession> RpcSession::make() { |
| 59 | return sp<RpcSession>::make(); |
| 60 | } |
| 61 | |
Steven Moreland | 103424e | 2021-06-02 18:16:19 +0000 | [diff] [blame] | 62 | void RpcSession::setMaxThreads(size_t threads) { |
| 63 | std::lock_guard<std::mutex> _l(mMutex); |
| 64 | LOG_ALWAYS_FATAL_IF(!mClientConnections.empty() || !mServerConnections.empty(), |
| 65 | "Must set max threads before setting up connections, but has %zu client(s) " |
| 66 | "and %zu server(s)", |
| 67 | mClientConnections.size(), mServerConnections.size()); |
| 68 | mMaxThreads = threads; |
| 69 | } |
| 70 | |
| 71 | size_t RpcSession::getMaxThreads() { |
| 72 | std::lock_guard<std::mutex> _l(mMutex); |
| 73 | return mMaxThreads; |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 74 | } |
| 75 | |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 76 | bool RpcSession::setupUnixDomainClient(const char* path) { |
| 77 | return setupSocketClient(UnixSocketAddress(path)); |
| 78 | } |
| 79 | |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 80 | bool RpcSession::setupVsockClient(unsigned int cid, unsigned int port) { |
| 81 | return setupSocketClient(VsockSocketAddress(cid, port)); |
| 82 | } |
| 83 | |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 84 | bool RpcSession::setupInetClient(const char* addr, unsigned int port) { |
| 85 | auto aiStart = InetSocketAddress::getAddrInfo(addr, port); |
| 86 | if (aiStart == nullptr) return false; |
| 87 | for (auto ai = aiStart.get(); ai != nullptr; ai = ai->ai_next) { |
| 88 | InetSocketAddress socketAddress(ai->ai_addr, ai->ai_addrlen, addr, port); |
| 89 | if (setupSocketClient(socketAddress)) return true; |
| 90 | } |
| 91 | ALOGE("None of the socket address resolved for %s:%u can be added as inet client.", addr, port); |
| 92 | return false; |
| 93 | } |
| 94 | |
| 95 | bool RpcSession::addNullDebuggingClient() { |
| 96 | unique_fd serverFd(TEMP_FAILURE_RETRY(open("/dev/null", O_WRONLY | O_CLOEXEC))); |
| 97 | |
| 98 | if (serverFd == -1) { |
| 99 | ALOGE("Could not connect to /dev/null: %s", strerror(errno)); |
| 100 | return false; |
| 101 | } |
| 102 | |
Steven Moreland | b0dd118 | 2021-05-25 01:56:46 +0000 | [diff] [blame] | 103 | return addClientConnection(std::move(serverFd)); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | sp<IBinder> RpcSession::getRootObject() { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 107 | ExclusiveConnection connection; |
| 108 | status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), |
| 109 | ConnectionUse::CLIENT, &connection); |
| 110 | if (status != OK) return nullptr; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 111 | return state()->getRootObject(connection.fd(), sp<RpcSession>::fromExisting(this)); |
| 112 | } |
| 113 | |
Steven Moreland | 1be9135 | 2021-05-11 22:12:15 +0000 | [diff] [blame] | 114 | status_t RpcSession::getRemoteMaxThreads(size_t* maxThreads) { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 115 | ExclusiveConnection connection; |
| 116 | status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), |
| 117 | ConnectionUse::CLIENT, &connection); |
| 118 | if (status != OK) return status; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 119 | return state()->getMaxThreads(connection.fd(), sp<RpcSession>::fromExisting(this), maxThreads); |
| 120 | } |
| 121 | |
Steven Moreland | c9d7b53 | 2021-06-04 20:57:41 +0000 | [diff] [blame] | 122 | bool RpcSession::shutdownAndWait(bool wait) { |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 123 | std::unique_lock<std::mutex> _l(mMutex); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 124 | LOG_ALWAYS_FATAL_IF(mShutdownTrigger == nullptr, "Shutdown trigger not installed"); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 125 | |
| 126 | mShutdownTrigger->trigger(); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 127 | |
Steven Moreland | c9d7b53 | 2021-06-04 20:57:41 +0000 | [diff] [blame] | 128 | if (wait) { |
| 129 | LOG_ALWAYS_FATAL_IF(mShutdownListener == nullptr, "Shutdown listener not installed"); |
| 130 | mShutdownListener->waitForShutdown(_l); |
| 131 | LOG_ALWAYS_FATAL_IF(!mThreads.empty(), "Shutdown failed"); |
| 132 | } |
| 133 | |
| 134 | _l.unlock(); |
| 135 | mState->clear(); |
| 136 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 137 | return true; |
| 138 | } |
| 139 | |
Steven Moreland | f517427 | 2021-05-25 00:39:28 +0000 | [diff] [blame] | 140 | status_t RpcSession::transact(const sp<IBinder>& binder, uint32_t code, const Parcel& data, |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 141 | Parcel* reply, uint32_t flags) { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 142 | ExclusiveConnection connection; |
| 143 | status_t status = |
| 144 | ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), |
| 145 | (flags & IBinder::FLAG_ONEWAY) ? ConnectionUse::CLIENT_ASYNC |
| 146 | : ConnectionUse::CLIENT, |
| 147 | &connection); |
| 148 | if (status != OK) return status; |
Steven Moreland | f517427 | 2021-05-25 00:39:28 +0000 | [diff] [blame] | 149 | return state()->transact(connection.fd(), binder, code, data, |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 150 | sp<RpcSession>::fromExisting(this), reply, flags); |
| 151 | } |
| 152 | |
| 153 | status_t RpcSession::sendDecStrong(const RpcAddress& address) { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 154 | ExclusiveConnection connection; |
| 155 | status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), |
| 156 | ConnectionUse::CLIENT_REFCOUNT, &connection); |
| 157 | if (status != OK) return status; |
Steven Moreland | c9d7b53 | 2021-06-04 20:57:41 +0000 | [diff] [blame] | 158 | return state()->sendDecStrong(connection.fd(), sp<RpcSession>::fromExisting(this), address); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 159 | } |
| 160 | |
Steven Moreland | e47511f | 2021-05-20 00:07:41 +0000 | [diff] [blame] | 161 | std::unique_ptr<RpcSession::FdTrigger> RpcSession::FdTrigger::make() { |
| 162 | auto ret = std::make_unique<RpcSession::FdTrigger>(); |
Steven Moreland | a8b4429 | 2021-06-08 01:27:53 +0000 | [diff] [blame] | 163 | if (!android::base::Pipe(&ret->mRead, &ret->mWrite)) { |
| 164 | ALOGE("Could not create pipe %s", strerror(errno)); |
| 165 | return nullptr; |
| 166 | } |
Steven Moreland | e47511f | 2021-05-20 00:07:41 +0000 | [diff] [blame] | 167 | return ret; |
| 168 | } |
| 169 | |
| 170 | void RpcSession::FdTrigger::trigger() { |
| 171 | mWrite.reset(); |
| 172 | } |
| 173 | |
Steven Moreland | a8b4429 | 2021-06-08 01:27:53 +0000 | [diff] [blame] | 174 | bool RpcSession::FdTrigger::isTriggered() { |
| 175 | return mWrite == -1; |
| 176 | } |
| 177 | |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 178 | status_t RpcSession::FdTrigger::triggerablePollRead(base::borrowed_fd fd) { |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 179 | while (true) { |
Steven Moreland | dfe3be9 | 2021-05-22 00:24:29 +0000 | [diff] [blame] | 180 | pollfd pfd[]{{.fd = fd.get(), .events = POLLIN | POLLHUP, .revents = 0}, |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 181 | {.fd = mRead.get(), .events = POLLHUP, .revents = 0}}; |
| 182 | int ret = TEMP_FAILURE_RETRY(poll(pfd, arraysize(pfd), -1)); |
| 183 | if (ret < 0) { |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 184 | return -errno; |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 185 | } |
| 186 | if (ret == 0) { |
| 187 | continue; |
| 188 | } |
| 189 | if (pfd[1].revents & POLLHUP) { |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 190 | return -ECANCELED; |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 191 | } |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 192 | return pfd[0].revents & POLLIN ? OK : DEAD_OBJECT; |
Steven Moreland | 4ec3c43 | 2021-05-20 00:32:47 +0000 | [diff] [blame] | 193 | } |
| 194 | } |
| 195 | |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 196 | status_t RpcSession::FdTrigger::interruptableReadFully(base::borrowed_fd fd, void* data, |
| 197 | size_t size) { |
Steven Moreland | 9d11b92 | 2021-05-20 01:22:58 +0000 | [diff] [blame] | 198 | uint8_t* buffer = reinterpret_cast<uint8_t*>(data); |
| 199 | uint8_t* end = buffer + size; |
| 200 | |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 201 | status_t status; |
| 202 | while ((status = triggerablePollRead(fd)) == OK) { |
Steven Moreland | 9d11b92 | 2021-05-20 01:22:58 +0000 | [diff] [blame] | 203 | ssize_t readSize = TEMP_FAILURE_RETRY(recv(fd.get(), buffer, end - buffer, MSG_NOSIGNAL)); |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 204 | if (readSize == 0) return DEAD_OBJECT; // EOF |
Steven Moreland | dfe3be9 | 2021-05-22 00:24:29 +0000 | [diff] [blame] | 205 | |
Steven Moreland | 9d11b92 | 2021-05-20 01:22:58 +0000 | [diff] [blame] | 206 | if (readSize < 0) { |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 207 | return -errno; |
Steven Moreland | 9d11b92 | 2021-05-20 01:22:58 +0000 | [diff] [blame] | 208 | } |
| 209 | buffer += readSize; |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 210 | if (buffer == end) return OK; |
Steven Moreland | 9d11b92 | 2021-05-20 01:22:58 +0000 | [diff] [blame] | 211 | } |
Steven Moreland | 2b4f380 | 2021-05-22 01:46:27 +0000 | [diff] [blame] | 212 | return status; |
Steven Moreland | 9d11b92 | 2021-05-20 01:22:58 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 215 | status_t RpcSession::readId() { |
| 216 | { |
| 217 | std::lock_guard<std::mutex> _l(mMutex); |
| 218 | LOG_ALWAYS_FATAL_IF(mForServer != nullptr, "Can only update ID for client."); |
| 219 | } |
| 220 | |
| 221 | int32_t id; |
| 222 | |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 223 | ExclusiveConnection connection; |
| 224 | status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), |
| 225 | ConnectionUse::CLIENT, &connection); |
| 226 | if (status != OK) return status; |
| 227 | |
| 228 | status = state()->getSessionId(connection.fd(), sp<RpcSession>::fromExisting(this), &id); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 229 | if (status != OK) return status; |
| 230 | |
| 231 | LOG_RPC_DETAIL("RpcSession %p has id %d", this, id); |
| 232 | mId = id; |
| 233 | return OK; |
| 234 | } |
| 235 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 236 | void RpcSession::WaitForShutdownListener::onSessionLockedAllServerThreadsEnded( |
| 237 | const sp<RpcSession>& session) { |
| 238 | (void)session; |
| 239 | mShutdown = true; |
| 240 | } |
| 241 | |
| 242 | void RpcSession::WaitForShutdownListener::onSessionServerThreadEnded() { |
| 243 | mCv.notify_all(); |
| 244 | } |
| 245 | |
| 246 | void RpcSession::WaitForShutdownListener::waitForShutdown(std::unique_lock<std::mutex>& lock) { |
| 247 | while (!mShutdown) { |
| 248 | if (std::cv_status::timeout == mCv.wait_for(lock, std::chrono::seconds(1))) { |
| 249 | ALOGE("Waiting for RpcSession to shut down (1s w/o progress)."); |
| 250 | } |
| 251 | } |
| 252 | } |
| 253 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 254 | void RpcSession::preJoinThreadOwnership(std::thread thread) { |
Steven Moreland | a63ff93 | 2021-05-12 00:03:15 +0000 | [diff] [blame] | 255 | LOG_ALWAYS_FATAL_IF(thread.get_id() != std::this_thread::get_id(), "Must own this thread"); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 256 | |
Steven Moreland | a63ff93 | 2021-05-12 00:03:15 +0000 | [diff] [blame] | 257 | { |
| 258 | std::lock_guard<std::mutex> _l(mMutex); |
| 259 | mThreads[thread.get_id()] = std::move(thread); |
| 260 | } |
Steven Moreland | 5802c2b | 2021-05-12 20:13:04 +0000 | [diff] [blame] | 261 | } |
Steven Moreland | a63ff93 | 2021-05-12 00:03:15 +0000 | [diff] [blame] | 262 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 263 | RpcSession::PreJoinSetupResult RpcSession::preJoinSetup(base::unique_fd fd) { |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 264 | // must be registered to allow arbitrary client code executing commands to |
| 265 | // be able to do nested calls (we can't only read from it) |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 266 | sp<RpcConnection> connection = assignServerToThisThread(std::move(fd)); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 267 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 268 | status_t status = |
| 269 | mState->readConnectionInit(connection->fd, sp<RpcSession>::fromExisting(this)); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 270 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 271 | return PreJoinSetupResult{ |
| 272 | .connection = std::move(connection), |
| 273 | .status = status, |
| 274 | }; |
| 275 | } |
| 276 | |
| 277 | void RpcSession::join(sp<RpcSession>&& session, PreJoinSetupResult&& setupResult) { |
| 278 | sp<RpcConnection>& connection = setupResult.connection; |
| 279 | |
| 280 | if (setupResult.status == OK) { |
| 281 | while (true) { |
| 282 | status_t status = session->state()->getAndExecuteCommand(connection->fd, session, |
| 283 | RpcState::CommandType::ANY); |
| 284 | if (status != OK) { |
| 285 | LOG_RPC_DETAIL("Binder connection thread closing w/ status %s", |
| 286 | statusToString(status).c_str()); |
| 287 | break; |
| 288 | } |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 289 | } |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 290 | } else { |
| 291 | ALOGE("Connection failed to init, closing with status %s", |
| 292 | statusToString(setupResult.status).c_str()); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 293 | } |
| 294 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 295 | LOG_ALWAYS_FATAL_IF(!session->removeServerConnection(connection), |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 296 | "bad state: connection object guaranteed to be in list"); |
Steven Moreland | a63ff93 | 2021-05-12 00:03:15 +0000 | [diff] [blame] | 297 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 298 | sp<RpcSession::EventListener> listener; |
Steven Moreland | a63ff93 | 2021-05-12 00:03:15 +0000 | [diff] [blame] | 299 | { |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 300 | std::lock_guard<std::mutex> _l(session->mMutex); |
| 301 | auto it = session->mThreads.find(std::this_thread::get_id()); |
| 302 | LOG_ALWAYS_FATAL_IF(it == session->mThreads.end()); |
Steven Moreland | a63ff93 | 2021-05-12 00:03:15 +0000 | [diff] [blame] | 303 | it->second.detach(); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 304 | session->mThreads.erase(it); |
Steven Moreland | ee3f466 | 2021-05-22 01:07:33 +0000 | [diff] [blame] | 305 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 306 | listener = session->mEventListener.promote(); |
Steven Moreland | ee3f466 | 2021-05-22 01:07:33 +0000 | [diff] [blame] | 307 | } |
| 308 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 309 | session = nullptr; |
| 310 | |
| 311 | if (listener != nullptr) { |
| 312 | listener->onSessionServerThreadEnded(); |
Steven Moreland | ee78e76 | 2021-05-05 21:12:51 +0000 | [diff] [blame] | 313 | } |
| 314 | } |
| 315 | |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 316 | wp<RpcServer> RpcSession::server() { |
| 317 | return mForServer; |
| 318 | } |
| 319 | |
| 320 | bool RpcSession::setupSocketClient(const RpcSocketAddress& addr) { |
| 321 | { |
| 322 | std::lock_guard<std::mutex> _l(mMutex); |
Steven Moreland | bb543a8 | 2021-05-11 02:31:50 +0000 | [diff] [blame] | 323 | LOG_ALWAYS_FATAL_IF(mClientConnections.size() != 0, |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 324 | "Must only setup session once, but already has %zu clients", |
Steven Moreland | bb543a8 | 2021-05-11 02:31:50 +0000 | [diff] [blame] | 325 | mClientConnections.size()); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 326 | } |
| 327 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 328 | if (!setupOneSocketConnection(addr, RPC_SESSION_ID_NEW, false /*reverse*/)) return false; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 329 | |
Steven Moreland | a5036f0 | 2021-06-08 02:26:57 +0000 | [diff] [blame] | 330 | // TODO(b/189955605): we should add additional sessions dynamically |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 331 | // instead of all at once. |
| 332 | // TODO(b/186470974): first risk of blocking |
| 333 | size_t numThreadsAvailable; |
Steven Moreland | 1be9135 | 2021-05-11 22:12:15 +0000 | [diff] [blame] | 334 | if (status_t status = getRemoteMaxThreads(&numThreadsAvailable); status != OK) { |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 335 | ALOGE("Could not get max threads after initial session to %s: %s", addr.toString().c_str(), |
| 336 | statusToString(status).c_str()); |
| 337 | return false; |
| 338 | } |
| 339 | |
| 340 | if (status_t status = readId(); status != OK) { |
| 341 | ALOGE("Could not get session id after initial session to %s; %s", addr.toString().c_str(), |
| 342 | statusToString(status).c_str()); |
| 343 | return false; |
| 344 | } |
| 345 | |
| 346 | // we've already setup one client |
| 347 | for (size_t i = 0; i + 1 < numThreadsAvailable; i++) { |
Steven Moreland | a5036f0 | 2021-06-08 02:26:57 +0000 | [diff] [blame] | 348 | // TODO(b/189955605): shutdown existing connections? |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 349 | if (!setupOneSocketConnection(addr, mId.value(), false /*reverse*/)) return false; |
| 350 | } |
| 351 | |
Steven Moreland | a5036f0 | 2021-06-08 02:26:57 +0000 | [diff] [blame] | 352 | // TODO(b/189955605): we should add additional sessions dynamically |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 353 | // instead of all at once - the other side should be responsible for setting |
| 354 | // up additional connections. We need to create at least one (unless 0 are |
| 355 | // requested to be set) in order to allow the other side to reliably make |
| 356 | // any requests at all. |
| 357 | |
Steven Moreland | 103424e | 2021-06-02 18:16:19 +0000 | [diff] [blame] | 358 | for (size_t i = 0; i < mMaxThreads; i++) { |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 359 | if (!setupOneSocketConnection(addr, mId.value(), true /*reverse*/)) return false; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | return true; |
| 363 | } |
| 364 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 365 | bool RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr, int32_t id, bool reverse) { |
Steven Moreland | 76d2c1f | 2021-05-05 20:28:58 +0000 | [diff] [blame] | 366 | for (size_t tries = 0; tries < 5; tries++) { |
| 367 | if (tries > 0) usleep(10000); |
| 368 | |
| 369 | unique_fd serverFd( |
| 370 | TEMP_FAILURE_RETRY(socket(addr.addr()->sa_family, SOCK_STREAM | SOCK_CLOEXEC, 0))); |
| 371 | if (serverFd == -1) { |
| 372 | int savedErrno = errno; |
| 373 | ALOGE("Could not create socket at %s: %s", addr.toString().c_str(), |
| 374 | strerror(savedErrno)); |
| 375 | return false; |
| 376 | } |
| 377 | |
| 378 | if (0 != TEMP_FAILURE_RETRY(connect(serverFd.get(), addr.addr(), addr.addrSize()))) { |
| 379 | if (errno == ECONNRESET) { |
| 380 | ALOGW("Connection reset on %s", addr.toString().c_str()); |
| 381 | continue; |
| 382 | } |
| 383 | int savedErrno = errno; |
| 384 | ALOGE("Could not connect socket at %s: %s", addr.toString().c_str(), |
| 385 | strerror(savedErrno)); |
| 386 | return false; |
| 387 | } |
| 388 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 389 | RpcConnectionHeader header{ |
| 390 | .sessionId = id, |
| 391 | }; |
| 392 | if (reverse) header.options |= RPC_CONNECTION_OPTION_REVERSE; |
| 393 | |
| 394 | if (sizeof(header) != TEMP_FAILURE_RETRY(write(serverFd.get(), &header, sizeof(header)))) { |
Steven Moreland | 76d2c1f | 2021-05-05 20:28:58 +0000 | [diff] [blame] | 395 | int savedErrno = errno; |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 396 | ALOGE("Could not write connection header to socket at %s: %s", addr.toString().c_str(), |
Steven Moreland | 76d2c1f | 2021-05-05 20:28:58 +0000 | [diff] [blame] | 397 | strerror(savedErrno)); |
| 398 | return false; |
| 399 | } |
| 400 | |
| 401 | LOG_RPC_DETAIL("Socket at %s client with fd %d", addr.toString().c_str(), serverFd.get()); |
| 402 | |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 403 | if (reverse) { |
| 404 | std::mutex mutex; |
| 405 | std::condition_variable joinCv; |
| 406 | std::unique_lock<std::mutex> lock(mutex); |
| 407 | std::thread thread; |
| 408 | sp<RpcSession> thiz = sp<RpcSession>::fromExisting(this); |
| 409 | bool ownershipTransferred = false; |
| 410 | thread = std::thread([&]() { |
| 411 | std::unique_lock<std::mutex> threadLock(mutex); |
| 412 | unique_fd fd = std::move(serverFd); |
| 413 | // NOLINTNEXTLINE(performance-unnecessary-copy-initialization) |
| 414 | sp<RpcSession> session = thiz; |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 415 | session->preJoinThreadOwnership(std::move(thread)); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 416 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 417 | // only continue once we have a response or the connection fails |
| 418 | auto setupResult = session->preJoinSetup(std::move(fd)); |
| 419 | |
| 420 | ownershipTransferred = true; |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 421 | threadLock.unlock(); |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 422 | joinCv.notify_one(); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 423 | // do not use & vars below |
| 424 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 425 | RpcSession::join(std::move(session), std::move(setupResult)); |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 426 | }); |
| 427 | joinCv.wait(lock, [&] { return ownershipTransferred; }); |
| 428 | LOG_ALWAYS_FATAL_IF(!ownershipTransferred); |
| 429 | return true; |
| 430 | } else { |
| 431 | return addClientConnection(std::move(serverFd)); |
| 432 | } |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 433 | } |
| 434 | |
Steven Moreland | 76d2c1f | 2021-05-05 20:28:58 +0000 | [diff] [blame] | 435 | ALOGE("Ran out of retries to connect to %s", addr.toString().c_str()); |
| 436 | return false; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 437 | } |
| 438 | |
Steven Moreland | b0dd118 | 2021-05-25 01:56:46 +0000 | [diff] [blame] | 439 | bool RpcSession::addClientConnection(unique_fd fd) { |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 440 | sp<RpcConnection> connection = sp<RpcConnection>::make(); |
| 441 | { |
| 442 | std::lock_guard<std::mutex> _l(mMutex); |
Steven Moreland | ee3f466 | 2021-05-22 01:07:33 +0000 | [diff] [blame] | 443 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 444 | // first client connection added, but setForServer not called, so |
| 445 | // initializaing for a client. |
| 446 | if (mShutdownTrigger == nullptr) { |
| 447 | mShutdownTrigger = FdTrigger::make(); |
| 448 | mEventListener = mShutdownListener = sp<WaitForShutdownListener>::make(); |
| 449 | if (mShutdownTrigger == nullptr) return false; |
| 450 | } |
| 451 | |
| 452 | connection->fd = std::move(fd); |
| 453 | connection->exclusiveTid = gettid(); |
| 454 | mClientConnections.push_back(connection); |
Steven Moreland | ee3f466 | 2021-05-22 01:07:33 +0000 | [diff] [blame] | 455 | } |
| 456 | |
Steven Moreland | c88b7fc | 2021-06-10 00:40:39 +0000 | [diff] [blame] | 457 | status_t status = |
| 458 | mState->sendConnectionInit(connection->fd, sp<RpcSession>::fromExisting(this)); |
| 459 | |
| 460 | { |
| 461 | std::lock_guard<std::mutex> _l(mMutex); |
| 462 | connection->exclusiveTid = std::nullopt; |
| 463 | } |
| 464 | |
| 465 | return status == OK; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 466 | } |
| 467 | |
Steven Moreland | a8b4429 | 2021-06-08 01:27:53 +0000 | [diff] [blame] | 468 | bool RpcSession::setForServer(const wp<RpcServer>& server, const wp<EventListener>& eventListener, |
| 469 | int32_t sessionId) { |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 470 | LOG_ALWAYS_FATAL_IF(mForServer != nullptr); |
| 471 | LOG_ALWAYS_FATAL_IF(server == nullptr); |
| 472 | LOG_ALWAYS_FATAL_IF(mEventListener != nullptr); |
| 473 | LOG_ALWAYS_FATAL_IF(eventListener == nullptr); |
Steven Moreland | ee3f466 | 2021-05-22 01:07:33 +0000 | [diff] [blame] | 474 | LOG_ALWAYS_FATAL_IF(mShutdownTrigger != nullptr); |
Steven Moreland | a8b4429 | 2021-06-08 01:27:53 +0000 | [diff] [blame] | 475 | |
| 476 | mShutdownTrigger = FdTrigger::make(); |
| 477 | if (mShutdownTrigger == nullptr) return false; |
Steven Moreland | ee3f466 | 2021-05-22 01:07:33 +0000 | [diff] [blame] | 478 | |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 479 | mId = sessionId; |
| 480 | mForServer = server; |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 481 | mEventListener = eventListener; |
Steven Moreland | a8b4429 | 2021-06-08 01:27:53 +0000 | [diff] [blame] | 482 | return true; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 483 | } |
| 484 | |
| 485 | sp<RpcSession::RpcConnection> RpcSession::assignServerToThisThread(unique_fd fd) { |
| 486 | std::lock_guard<std::mutex> _l(mMutex); |
| 487 | sp<RpcConnection> session = sp<RpcConnection>::make(); |
| 488 | session->fd = std::move(fd); |
| 489 | session->exclusiveTid = gettid(); |
Steven Moreland | bb543a8 | 2021-05-11 02:31:50 +0000 | [diff] [blame] | 490 | mServerConnections.push_back(session); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 491 | |
| 492 | return session; |
| 493 | } |
| 494 | |
| 495 | bool RpcSession::removeServerConnection(const sp<RpcConnection>& connection) { |
| 496 | std::lock_guard<std::mutex> _l(mMutex); |
Steven Moreland | bb543a8 | 2021-05-11 02:31:50 +0000 | [diff] [blame] | 497 | if (auto it = std::find(mServerConnections.begin(), mServerConnections.end(), connection); |
| 498 | it != mServerConnections.end()) { |
| 499 | mServerConnections.erase(it); |
| 500 | if (mServerConnections.size() == 0) { |
Steven Moreland | 659416d | 2021-05-11 00:47:50 +0000 | [diff] [blame] | 501 | sp<EventListener> listener = mEventListener.promote(); |
| 502 | if (listener) { |
| 503 | listener->onSessionLockedAllServerThreadsEnded(sp<RpcSession>::fromExisting(this)); |
Steven Moreland | a86e8fe | 2021-05-26 22:52:35 +0000 | [diff] [blame] | 504 | } |
Steven Moreland | ee78e76 | 2021-05-05 21:12:51 +0000 | [diff] [blame] | 505 | } |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 506 | return true; |
| 507 | } |
| 508 | return false; |
| 509 | } |
| 510 | |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 511 | status_t RpcSession::ExclusiveConnection::find(const sp<RpcSession>& session, ConnectionUse use, |
| 512 | ExclusiveConnection* connection) { |
| 513 | connection->mSession = session; |
| 514 | connection->mConnection = nullptr; |
| 515 | connection->mReentrant = false; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 516 | |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 517 | pid_t tid = gettid(); |
| 518 | std::unique_lock<std::mutex> _l(session->mMutex); |
| 519 | |
| 520 | session->mWaitingThreads++; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 521 | while (true) { |
| 522 | sp<RpcConnection> exclusive; |
| 523 | sp<RpcConnection> available; |
| 524 | |
| 525 | // CHECK FOR DEDICATED CLIENT SOCKET |
| 526 | // |
Steven Moreland | 85e067b | 2021-05-26 17:43:53 +0000 | [diff] [blame] | 527 | // A server/looper should always use a dedicated connection if available |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 528 | findConnection(tid, &exclusive, &available, session->mClientConnections, |
| 529 | session->mClientConnectionsOffset); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 530 | |
| 531 | // WARNING: this assumes a server cannot request its client to send |
Steven Moreland | bb543a8 | 2021-05-11 02:31:50 +0000 | [diff] [blame] | 532 | // a transaction, as mServerConnections is excluded below. |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 533 | // |
| 534 | // Imagine we have more than one thread in play, and a single thread |
| 535 | // sends a synchronous, then an asynchronous command. Imagine the |
| 536 | // asynchronous command is sent on the first client connection. Then, if |
| 537 | // we naively send a synchronous command to that same connection, the |
| 538 | // thread on the far side might be busy processing the asynchronous |
| 539 | // command. So, we move to considering the second available thread |
| 540 | // for subsequent calls. |
| 541 | if (use == ConnectionUse::CLIENT_ASYNC && (exclusive != nullptr || available != nullptr)) { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 542 | session->mClientConnectionsOffset = |
| 543 | (session->mClientConnectionsOffset + 1) % session->mClientConnections.size(); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 544 | } |
| 545 | |
| 546 | // USE SERVING SOCKET (for nested transaction) |
| 547 | // |
| 548 | // asynchronous calls cannot be nested |
| 549 | if (use != ConnectionUse::CLIENT_ASYNC) { |
| 550 | // server connections are always assigned to a thread |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 551 | findConnection(tid, &exclusive, nullptr /*available*/, session->mServerConnections, |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 552 | 0 /* index hint */); |
| 553 | } |
| 554 | |
Steven Moreland | 85e067b | 2021-05-26 17:43:53 +0000 | [diff] [blame] | 555 | // if our thread is already using a connection, prioritize using that |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 556 | if (exclusive != nullptr) { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 557 | connection->mConnection = exclusive; |
| 558 | connection->mReentrant = true; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 559 | break; |
| 560 | } else if (available != nullptr) { |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 561 | connection->mConnection = available; |
| 562 | connection->mConnection->exclusiveTid = tid; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 563 | break; |
| 564 | } |
| 565 | |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 566 | if (session->mClientConnections.size() == 0) { |
| 567 | ALOGE("Session has no client connections. This is required for an RPC server to make " |
| 568 | "any non-nested (e.g. oneway or on another thread) calls. Use: %d. Server " |
| 569 | "connections: %zu", |
| 570 | static_cast<int>(use), session->mServerConnections.size()); |
| 571 | return WOULD_BLOCK; |
| 572 | } |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 573 | |
Steven Moreland | 85e067b | 2021-05-26 17:43:53 +0000 | [diff] [blame] | 574 | LOG_RPC_DETAIL("No available connections (have %zu clients and %zu servers). Waiting...", |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 575 | session->mClientConnections.size(), session->mServerConnections.size()); |
| 576 | session->mAvailableConnectionCv.wait(_l); |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 577 | } |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 578 | session->mWaitingThreads--; |
| 579 | |
| 580 | return OK; |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 581 | } |
| 582 | |
| 583 | void RpcSession::ExclusiveConnection::findConnection(pid_t tid, sp<RpcConnection>* exclusive, |
| 584 | sp<RpcConnection>* available, |
| 585 | std::vector<sp<RpcConnection>>& sockets, |
| 586 | size_t socketsIndexHint) { |
| 587 | LOG_ALWAYS_FATAL_IF(sockets.size() > 0 && socketsIndexHint >= sockets.size(), |
| 588 | "Bad index %zu >= %zu", socketsIndexHint, sockets.size()); |
| 589 | |
| 590 | if (*exclusive != nullptr) return; // consistent with break below |
| 591 | |
| 592 | for (size_t i = 0; i < sockets.size(); i++) { |
| 593 | sp<RpcConnection>& socket = sockets[(i + socketsIndexHint) % sockets.size()]; |
| 594 | |
Steven Moreland | 85e067b | 2021-05-26 17:43:53 +0000 | [diff] [blame] | 595 | // take first available connection (intuition = caching) |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 596 | if (available && *available == nullptr && socket->exclusiveTid == std::nullopt) { |
| 597 | *available = socket; |
| 598 | continue; |
| 599 | } |
| 600 | |
Steven Moreland | 85e067b | 2021-05-26 17:43:53 +0000 | [diff] [blame] | 601 | // though, prefer to take connection which is already inuse by this thread |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 602 | // (nested transactions) |
| 603 | if (exclusive && socket->exclusiveTid == tid) { |
| 604 | *exclusive = socket; |
| 605 | break; // consistent with return above |
| 606 | } |
| 607 | } |
| 608 | } |
| 609 | |
| 610 | RpcSession::ExclusiveConnection::~ExclusiveConnection() { |
Steven Moreland | 85e067b | 2021-05-26 17:43:53 +0000 | [diff] [blame] | 611 | // reentrant use of a connection means something less deep in the call stack |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 612 | // is using this fd, and it retains the right to it. So, we don't give up |
| 613 | // exclusive ownership, and no thread is freed. |
Steven Moreland | 195edb8 | 2021-06-08 02:44:39 +0000 | [diff] [blame^] | 614 | if (!mReentrant && mConnection != nullptr) { |
Steven Moreland | bdb53ab | 2021-05-05 17:57:41 +0000 | [diff] [blame] | 615 | std::unique_lock<std::mutex> _l(mSession->mMutex); |
| 616 | mConnection->exclusiveTid = std::nullopt; |
| 617 | if (mSession->mWaitingThreads > 0) { |
| 618 | _l.unlock(); |
| 619 | mSession->mAvailableConnectionCv.notify_one(); |
| 620 | } |
| 621 | } |
| 622 | } |
| 623 | |
| 624 | } // namespace android |