blob: ff50c1610218df9c6d11dd67fdd302e977b192e5 [file] [log] [blame]
Steven Morelandbdb53ab2021-05-05 17:57:41 +00001/*
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
Yifan Hong194acf22021-06-29 18:44:56 -070021#include <dlfcn.h>
Steven Morelandbdb53ab2021-05-05 17:57:41 +000022#include <inttypes.h>
Steven Moreland4ec3c432021-05-20 00:32:47 +000023#include <poll.h>
Steven Morelandbdb53ab2021-05-05 17:57:41 +000024#include <unistd.h>
25
26#include <string_view>
27
Steven Moreland826367f2021-09-10 14:05:31 -070028#include <android-base/hex.h>
Steven Moreland4ec3c432021-05-20 00:32:47 +000029#include <android-base/macros.h>
Steven Moreland27a8bc72021-09-29 16:07:41 -070030#include <android-base/scopeguard.h>
Steven Moreland4f622fe2021-09-13 17:38:09 -070031#include <binder/BpBinder.h>
Steven Morelandbdb53ab2021-05-05 17:57:41 +000032#include <binder/Parcel.h>
Steven Morelandee78e762021-05-05 21:12:51 +000033#include <binder/RpcServer.h>
Yifan Hong702115c2021-06-24 15:39:18 -070034#include <binder/RpcTransportRaw.h>
Steven Morelandbdb53ab2021-05-05 17:57:41 +000035#include <binder/Stability.h>
Andrei Homescu1d935e82022-04-25 04:58:23 +000036#include <utils/Compat.h>
Steven Morelandbdb53ab2021-05-05 17:57:41 +000037#include <utils/String8.h>
38
Andrei Homescu9b58a462022-07-28 02:26:46 +000039#include "BuildFlags.h"
Yifan Hong8c950422021-08-05 17:13:55 -070040#include "FdTrigger.h"
Andrei Homescu7c0b79f2022-06-30 02:00:46 +000041#include "OS.h"
Steven Morelandbdb53ab2021-05-05 17:57:41 +000042#include "RpcSocketAddress.h"
43#include "RpcState.h"
David Brazdil21c887c2022-09-23 12:25:18 +010044#include "RpcTransportUtils.h"
Steven Morelandbdb53ab2021-05-05 17:57:41 +000045#include "RpcWireFormat.h"
Yifan Hongb675ffe2021-08-05 16:37:17 -070046#include "Utils.h"
Steven Morelandbdb53ab2021-05-05 17:57:41 +000047
Andrei Homescu47f8c4f2022-04-30 01:38:24 +000048#if defined(__ANDROID__) && !defined(__ANDROID_RECOVERY__)
Yifan Hongd258e682021-11-01 18:34:42 -070049#include <android_runtime/vm.h>
50#include <jni.h>
51#endif
52
Steven Morelandbdb53ab2021-05-05 17:57:41 +000053namespace android {
54
55using base::unique_fd;
56
Yifan Hongecf937d2021-08-11 17:29:28 -070057RpcSession::RpcSession(std::unique_ptr<RpcTransportCtx> ctx) : mCtx(std::move(ctx)) {
Steven Morelandbdb53ab2021-05-05 17:57:41 +000058 LOG_RPC_DETAIL("RpcSession created %p", this);
59
Steven Moreland27a8bc72021-09-29 16:07:41 -070060 mRpcBinderState = std::make_unique<RpcState>();
Steven Morelandbdb53ab2021-05-05 17:57:41 +000061}
62RpcSession::~RpcSession() {
63 LOG_RPC_DETAIL("RpcSession destroyed %p", this);
64
Andrei Homescuffa3aaa2022-04-07 05:06:33 +000065 RpcMutexLockGuard _l(mMutex);
Steven Morelanda59937e2021-10-04 17:42:30 -070066 LOG_ALWAYS_FATAL_IF(mConnections.mIncoming.size() != 0,
Steven Morelandbdb53ab2021-05-05 17:57:41 +000067 "Should not be able to destroy a session with servers in use.");
68}
69
Yifan Hongecf937d2021-08-11 17:29:28 -070070sp<RpcSession> RpcSession::make() {
Yifan Hong702115c2021-06-24 15:39:18 -070071 // Default is without TLS.
Andrei Homescu024727b2022-08-24 23:54:59 +000072 return make(makeDefaultRpcTransportCtxFactory());
Yifan Hongecf937d2021-08-11 17:29:28 -070073}
74
Yifan Hongfdd9f692021-09-09 15:12:52 -070075sp<RpcSession> RpcSession::make(std::unique_ptr<RpcTransportCtxFactory> rpcTransportCtxFactory) {
Yifan Hongecf937d2021-08-11 17:29:28 -070076 auto ctx = rpcTransportCtxFactory->newClientCtx();
77 if (ctx == nullptr) return nullptr;
Yifan Hongecf937d2021-08-11 17:29:28 -070078 return sp<RpcSession>::make(std::move(ctx));
Steven Morelandbdb53ab2021-05-05 17:57:41 +000079}
80
Yifan Hong10423062021-10-08 16:26:32 -070081void RpcSession::setMaxIncomingThreads(size_t threads) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +000082 RpcMutexLockGuard _l(mMutex);
Andrei Homescu9b58a462022-07-28 02:26:46 +000083 LOG_ALWAYS_FATAL_IF(mStartedSetup,
84 "Must set max incoming threads before setting up connections");
Yifan Hong10423062021-10-08 16:26:32 -070085 mMaxIncomingThreads = threads;
Steven Moreland103424e2021-06-02 18:16:19 +000086}
87
Yifan Hong10423062021-10-08 16:26:32 -070088size_t RpcSession::getMaxIncomingThreads() {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +000089 RpcMutexLockGuard _l(mMutex);
Yifan Hong10423062021-10-08 16:26:32 -070090 return mMaxIncomingThreads;
Steven Moreland659416d2021-05-11 00:47:50 +000091}
92
Yifan Hong1f44f982021-10-08 17:16:47 -070093void RpcSession::setMaxOutgoingThreads(size_t threads) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +000094 RpcMutexLockGuard _l(mMutex);
Andrei Homescu9b58a462022-07-28 02:26:46 +000095 LOG_ALWAYS_FATAL_IF(mStartedSetup,
96 "Must set max outgoing threads before setting up connections");
Yifan Hong1f44f982021-10-08 17:16:47 -070097 mMaxOutgoingThreads = threads;
98}
99
100size_t RpcSession::getMaxOutgoingThreads() {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000101 RpcMutexLockGuard _l(mMutex);
Yifan Hong1f44f982021-10-08 17:16:47 -0700102 return mMaxOutgoingThreads;
103}
104
Andrei Homescu9b58a462022-07-28 02:26:46 +0000105bool RpcSession::setProtocolVersionInternal(uint32_t version, bool checkStarted) {
Steven Morelandbf57bce2021-07-26 15:26:12 -0700106 if (version >= RPC_WIRE_PROTOCOL_VERSION_NEXT &&
107 version != RPC_WIRE_PROTOCOL_VERSION_EXPERIMENTAL) {
108 ALOGE("Cannot start RPC session with version %u which is unknown (current protocol version "
109 "is %u).",
110 version, RPC_WIRE_PROTOCOL_VERSION);
111 return false;
112 }
113
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000114 RpcMutexLockGuard _l(mMutex);
Andrei Homescu9b58a462022-07-28 02:26:46 +0000115 LOG_ALWAYS_FATAL_IF(checkStarted && mStartedSetup,
116 "Must set protocol version before setting up connections");
Steven Moreland40b736e2021-07-30 14:37:10 -0700117 if (mProtocolVersion && version > *mProtocolVersion) {
118 ALOGE("Cannot upgrade explicitly capped protocol version %u to newer version %u",
119 *mProtocolVersion, version);
120 return false;
121 }
122
Steven Morelandbf57bce2021-07-26 15:26:12 -0700123 mProtocolVersion = version;
124 return true;
125}
126
Andrei Homescu9b58a462022-07-28 02:26:46 +0000127bool RpcSession::setProtocolVersion(uint32_t version) {
128 return setProtocolVersionInternal(version, true);
129}
130
Steven Morelandbf57bce2021-07-26 15:26:12 -0700131std::optional<uint32_t> RpcSession::getProtocolVersion() {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000132 RpcMutexLockGuard _l(mMutex);
Steven Morelandbf57bce2021-07-26 15:26:12 -0700133 return mProtocolVersion;
134}
135
Frederick Mayle69a0c992022-05-26 20:38:39 +0000136void RpcSession::setFileDescriptorTransportMode(FileDescriptorTransportMode mode) {
Andrei Homescu9b58a462022-07-28 02:26:46 +0000137 RpcMutexLockGuard _l(mMutex);
138 LOG_ALWAYS_FATAL_IF(mStartedSetup,
139 "Must set file descriptor transport mode before setting up connections");
Frederick Mayle69a0c992022-05-26 20:38:39 +0000140 mFileDescriptorTransportMode = mode;
141}
142
143RpcSession::FileDescriptorTransportMode RpcSession::getFileDescriptorTransportMode() {
144 return mFileDescriptorTransportMode;
145}
146
Steven Moreland2372f9d2021-08-05 15:42:01 -0700147status_t RpcSession::setupUnixDomainClient(const char* path) {
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000148 return setupSocketClient(UnixSocketAddress(path));
149}
150
David Brazdil21c887c2022-09-23 12:25:18 +0100151status_t RpcSession::setupUnixDomainSocketBootstrapClient(unique_fd bootstrapFd) {
152 mBootstrapTransport =
153 mCtx->newTransport(RpcTransportFd(std::move(bootstrapFd)), mShutdownTrigger.get());
154 return setupClient([&](const std::vector<uint8_t>& sessionId, bool incoming) {
155 int socks[2];
156 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, socks) < 0) {
157 int savedErrno = errno;
158 ALOGE("Failed socketpair: %s", strerror(savedErrno));
159 return -savedErrno;
160 }
161 unique_fd clientFd(socks[0]), serverFd(socks[1]);
162
163 int zero = 0;
164 iovec iov{&zero, sizeof(zero)};
165 std::vector<std::variant<base::unique_fd, base::borrowed_fd>> fds;
166 fds.push_back(std::move(serverFd));
167
168 status_t status = mBootstrapTransport->interruptableWriteFully(mShutdownTrigger.get(), &iov,
169 1, std::nullopt, &fds);
170 if (status != OK) {
171 ALOGE("Failed to send fd over bootstrap transport: %s", strerror(-status));
172 return status;
173 }
174
175 return initAndAddConnection(RpcTransportFd(std::move(clientFd)), sessionId, incoming);
176 });
177}
178
Steven Moreland2372f9d2021-08-05 15:42:01 -0700179status_t RpcSession::setupVsockClient(unsigned int cid, unsigned int port) {
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000180 return setupSocketClient(VsockSocketAddress(cid, port));
181}
182
Steven Moreland2372f9d2021-08-05 15:42:01 -0700183status_t RpcSession::setupInetClient(const char* addr, unsigned int port) {
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000184 auto aiStart = InetSocketAddress::getAddrInfo(addr, port);
Steven Moreland2372f9d2021-08-05 15:42:01 -0700185 if (aiStart == nullptr) return UNKNOWN_ERROR;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000186 for (auto ai = aiStart.get(); ai != nullptr; ai = ai->ai_next) {
187 InetSocketAddress socketAddress(ai->ai_addr, ai->ai_addrlen, addr, port);
Steven Moreland2372f9d2021-08-05 15:42:01 -0700188 if (status_t status = setupSocketClient(socketAddress); status == OK) return OK;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000189 }
190 ALOGE("None of the socket address resolved for %s:%u can be added as inet client.", addr, port);
Steven Moreland2372f9d2021-08-05 15:42:01 -0700191 return NAME_NOT_FOUND;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000192}
193
Pawan49d74cb2022-08-03 21:19:11 +0000194status_t RpcSession::setupPreconnectedClient(base::unique_fd fd,
195 std::function<unique_fd()>&& request) {
Frederick Mayle297c2772022-05-05 01:21:04 +0000196 return setupClient([&](const std::vector<uint8_t>& sessionId, bool incoming) -> status_t {
Steven Moreland4198a122021-08-03 17:37:58 -0700197 if (!fd.ok()) {
198 fd = request();
Steven Moreland2372f9d2021-08-05 15:42:01 -0700199 if (!fd.ok()) return BAD_VALUE;
Steven Moreland4198a122021-08-03 17:37:58 -0700200 }
Yifan Hongb675ffe2021-08-05 16:37:17 -0700201 if (auto res = setNonBlocking(fd); !res.ok()) {
202 ALOGE("setupPreconnectedClient: %s", res.error().message().c_str());
203 return res.error().code() == 0 ? UNKNOWN_ERROR : -res.error().code();
204 }
Pawan49d74cb2022-08-03 21:19:11 +0000205
Pawan3e0061c2022-08-26 21:08:34 +0000206 RpcTransportFd transportFd(std::move(fd));
Pawan49d74cb2022-08-03 21:19:11 +0000207 status_t status = initAndAddConnection(std::move(transportFd), sessionId, incoming);
Frederick Mayle297c2772022-05-05 01:21:04 +0000208 fd = unique_fd(); // Explicitly reset after move to avoid analyzer warning.
209 return status;
Steven Moreland4198a122021-08-03 17:37:58 -0700210 });
211}
212
Steven Moreland2372f9d2021-08-05 15:42:01 -0700213status_t RpcSession::addNullDebuggingClient() {
Yifan Hong702115c2021-06-24 15:39:18 -0700214 // Note: only works on raw sockets.
Yifan Hong832521e2021-08-05 14:55:40 -0700215 if (auto status = initShutdownTrigger(); status != OK) return status;
216
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000217 unique_fd serverFd(TEMP_FAILURE_RETRY(open("/dev/null", O_WRONLY | O_CLOEXEC)));
218
219 if (serverFd == -1) {
Steven Moreland2372f9d2021-08-05 15:42:01 -0700220 int savedErrno = errno;
221 ALOGE("Could not connect to /dev/null: %s", strerror(savedErrno));
222 return -savedErrno;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000223 }
224
Pawan3e0061c2022-08-26 21:08:34 +0000225 RpcTransportFd transportFd(std::move(serverFd));
Pawan49d74cb2022-08-03 21:19:11 +0000226 auto server = mCtx->newTransport(std::move(transportFd), mShutdownTrigger.get());
Yifan Hong702115c2021-06-24 15:39:18 -0700227 if (server == nullptr) {
228 ALOGE("Unable to set up RpcTransport");
Steven Moreland2372f9d2021-08-05 15:42:01 -0700229 return UNKNOWN_ERROR;
Yifan Hong702115c2021-06-24 15:39:18 -0700230 }
231 return addOutgoingConnection(std::move(server), false);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000232}
233
234sp<IBinder> RpcSession::getRootObject() {
Steven Moreland195edb82021-06-08 02:44:39 +0000235 ExclusiveConnection connection;
236 status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),
237 ConnectionUse::CLIENT, &connection);
238 if (status != OK) return nullptr;
Steven Moreland5ae62562021-06-10 03:21:42 +0000239 return state()->getRootObject(connection.get(), sp<RpcSession>::fromExisting(this));
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000240}
241
Steven Moreland1be91352021-05-11 22:12:15 +0000242status_t RpcSession::getRemoteMaxThreads(size_t* maxThreads) {
Steven Moreland195edb82021-06-08 02:44:39 +0000243 ExclusiveConnection connection;
244 status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),
245 ConnectionUse::CLIENT, &connection);
246 if (status != OK) return status;
Steven Moreland5ae62562021-06-10 03:21:42 +0000247 return state()->getMaxThreads(connection.get(), sp<RpcSession>::fromExisting(this), maxThreads);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000248}
249
Steven Morelandc9d7b532021-06-04 20:57:41 +0000250bool RpcSession::shutdownAndWait(bool wait) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000251 RpcMutexUniqueLock _l(mMutex);
Steven Moreland659416d2021-05-11 00:47:50 +0000252 LOG_ALWAYS_FATAL_IF(mShutdownTrigger == nullptr, "Shutdown trigger not installed");
Steven Moreland659416d2021-05-11 00:47:50 +0000253
254 mShutdownTrigger->trigger();
Steven Moreland659416d2021-05-11 00:47:50 +0000255
Steven Morelandc9d7b532021-06-04 20:57:41 +0000256 if (wait) {
257 LOG_ALWAYS_FATAL_IF(mShutdownListener == nullptr, "Shutdown listener not installed");
Steven Moreland791e4662021-09-13 15:22:58 -0700258 mShutdownListener->waitForShutdown(_l, sp<RpcSession>::fromExisting(this));
Steven Morelanddd67b942021-07-23 17:15:41 -0700259
Steven Morelanda59937e2021-10-04 17:42:30 -0700260 LOG_ALWAYS_FATAL_IF(!mConnections.mThreads.empty(), "Shutdown failed");
Steven Morelandc9d7b532021-06-04 20:57:41 +0000261 }
262
263 _l.unlock();
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000264
Devin Moore66d5b7a2022-07-07 21:42:10 +0000265 if (status_t res = state()->sendObituaries(sp<RpcSession>::fromExisting(this)); res != OK) {
266 ALOGE("Failed to send obituaries as the RpcSession is shutting down: %s",
267 statusToString(res).c_str());
268 }
269
Steven Moreland27a8bc72021-09-29 16:07:41 -0700270 mRpcBinderState->clear();
Steven Morelandc9d7b532021-06-04 20:57:41 +0000271
Steven Moreland659416d2021-05-11 00:47:50 +0000272 return true;
273}
274
Steven Morelandf5174272021-05-25 00:39:28 +0000275status_t RpcSession::transact(const sp<IBinder>& binder, uint32_t code, const Parcel& data,
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000276 Parcel* reply, uint32_t flags) {
Steven Moreland195edb82021-06-08 02:44:39 +0000277 ExclusiveConnection connection;
278 status_t status =
279 ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),
280 (flags & IBinder::FLAG_ONEWAY) ? ConnectionUse::CLIENT_ASYNC
281 : ConnectionUse::CLIENT,
282 &connection);
283 if (status != OK) return status;
Steven Moreland5ae62562021-06-10 03:21:42 +0000284 return state()->transact(connection.get(), binder, code, data,
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000285 sp<RpcSession>::fromExisting(this), reply, flags);
286}
287
Steven Moreland4f622fe2021-09-13 17:38:09 -0700288status_t RpcSession::sendDecStrong(const BpBinder* binder) {
Steven Morelandfd1e8a02021-07-21 23:30:29 +0000289 // target is 0 because this is used to free BpBinder objects
290 return sendDecStrongToTarget(binder->getPrivateAccessor().rpcAddress(), 0 /*target*/);
Steven Moreland4f622fe2021-09-13 17:38:09 -0700291}
292
Steven Morelandfd1e8a02021-07-21 23:30:29 +0000293status_t RpcSession::sendDecStrongToTarget(uint64_t address, size_t target) {
Steven Moreland195edb82021-06-08 02:44:39 +0000294 ExclusiveConnection connection;
295 status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),
296 ConnectionUse::CLIENT_REFCOUNT, &connection);
297 if (status != OK) return status;
Steven Morelandfd1e8a02021-07-21 23:30:29 +0000298 return state()->sendDecStrongToTarget(connection.get(), sp<RpcSession>::fromExisting(this),
299 address, target);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000300}
301
302status_t RpcSession::readId() {
303 {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000304 RpcMutexLockGuard _l(mMutex);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000305 LOG_ALWAYS_FATAL_IF(mForServer != nullptr, "Can only update ID for client.");
306 }
307
Steven Moreland195edb82021-06-08 02:44:39 +0000308 ExclusiveConnection connection;
309 status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),
310 ConnectionUse::CLIENT, &connection);
311 if (status != OK) return status;
312
Steven Moreland826367f2021-09-10 14:05:31 -0700313 status = state()->getSessionId(connection.get(), sp<RpcSession>::fromExisting(this), &mId);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000314 if (status != OK) return status;
315
Steven Moreland826367f2021-09-10 14:05:31 -0700316 LOG_RPC_DETAIL("RpcSession %p has id %s", this,
317 base::HexString(mId.data(), mId.size()).c_str());
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000318 return OK;
319}
320
Steven Morelanddd67b942021-07-23 17:15:41 -0700321void RpcSession::WaitForShutdownListener::onSessionAllIncomingThreadsEnded(
Steven Moreland659416d2021-05-11 00:47:50 +0000322 const sp<RpcSession>& session) {
323 (void)session;
Steven Moreland659416d2021-05-11 00:47:50 +0000324}
325
Steven Moreland19fc9f72021-06-10 03:57:30 +0000326void RpcSession::WaitForShutdownListener::onSessionIncomingThreadEnded() {
Steven Moreland659416d2021-05-11 00:47:50 +0000327 mCv.notify_all();
328}
329
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000330void RpcSession::WaitForShutdownListener::waitForShutdown(RpcMutexUniqueLock& lock,
Steven Moreland791e4662021-09-13 15:22:58 -0700331 const sp<RpcSession>& session) {
Steven Morelanda59937e2021-10-04 17:42:30 -0700332 while (session->mConnections.mIncoming.size() > 0) {
Steven Moreland659416d2021-05-11 00:47:50 +0000333 if (std::cv_status::timeout == mCv.wait_for(lock, std::chrono::seconds(1))) {
Steven Moreland791e4662021-09-13 15:22:58 -0700334 ALOGE("Waiting for RpcSession to shut down (1s w/o progress): %zu incoming connections "
335 "still.",
Steven Morelanda59937e2021-10-04 17:42:30 -0700336 session->mConnections.mIncoming.size());
Steven Moreland659416d2021-05-11 00:47:50 +0000337 }
338 }
339}
340
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000341void RpcSession::preJoinThreadOwnership(RpcMaybeThread thread) {
342 LOG_ALWAYS_FATAL_IF(thread.get_id() != rpc_this_thread::get_id(), "Must own this thread");
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000343
Steven Morelanda63ff932021-05-12 00:03:15 +0000344 {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000345 RpcMutexLockGuard _l(mMutex);
Steven Morelanda59937e2021-10-04 17:42:30 -0700346 mConnections.mThreads[thread.get_id()] = std::move(thread);
Steven Morelanda63ff932021-05-12 00:03:15 +0000347 }
Steven Moreland5802c2b2021-05-12 20:13:04 +0000348}
Steven Morelanda63ff932021-05-12 00:03:15 +0000349
Yifan Hong702115c2021-06-24 15:39:18 -0700350RpcSession::PreJoinSetupResult RpcSession::preJoinSetup(
351 std::unique_ptr<RpcTransport> rpcTransport) {
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000352 // must be registered to allow arbitrary client code executing commands to
353 // be able to do nested calls (we can't only read from it)
Yifan Hong702115c2021-06-24 15:39:18 -0700354 sp<RpcConnection> connection = assignIncomingConnectionToThisThread(std::move(rpcTransport));
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000355
Steven Morelanddd67b942021-07-23 17:15:41 -0700356 status_t status;
357
358 if (connection == nullptr) {
359 status = DEAD_OBJECT;
360 } else {
Steven Moreland27a8bc72021-09-29 16:07:41 -0700361 status =
362 mRpcBinderState->readConnectionInit(connection, sp<RpcSession>::fromExisting(this));
Steven Morelanddd67b942021-07-23 17:15:41 -0700363 }
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000364
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000365 return PreJoinSetupResult{
366 .connection = std::move(connection),
367 .status = status,
368 };
369}
370
Yifan Hong194acf22021-06-29 18:44:56 -0700371namespace {
Andrei Homescu47f8c4f2022-04-30 01:38:24 +0000372#if !defined(__ANDROID__) || defined(__ANDROID_RECOVERY__)
Yifan Hongd258e682021-11-01 18:34:42 -0700373class JavaThreadAttacher {};
374#else
Yifan Hong194acf22021-06-29 18:44:56 -0700375// RAII object for attaching / detaching current thread to JVM if Android Runtime exists. If
376// Android Runtime doesn't exist, no-op.
377class JavaThreadAttacher {
378public:
379 JavaThreadAttacher() {
380 // Use dlsym to find androidJavaAttachThread because libandroid_runtime is loaded after
381 // libbinder.
382 auto vm = getJavaVM();
383 if (vm == nullptr) return;
384
385 char threadName[16];
386 if (0 != pthread_getname_np(pthread_self(), threadName, sizeof(threadName))) {
387 constexpr const char* defaultThreadName = "UnknownRpcSessionThread";
388 memcpy(threadName, defaultThreadName,
389 std::min<size_t>(sizeof(threadName), strlen(defaultThreadName) + 1));
390 }
391 LOG_RPC_DETAIL("Attaching current thread %s to JVM", threadName);
392 JavaVMAttachArgs args;
393 args.version = JNI_VERSION_1_2;
394 args.name = threadName;
395 args.group = nullptr;
396 JNIEnv* env;
397
398 LOG_ALWAYS_FATAL_IF(vm->AttachCurrentThread(&env, &args) != JNI_OK,
399 "Cannot attach thread %s to JVM", threadName);
400 mAttached = true;
401 }
402 ~JavaThreadAttacher() {
403 if (!mAttached) return;
404 auto vm = getJavaVM();
405 LOG_ALWAYS_FATAL_IF(vm == nullptr,
406 "Unable to detach thread. No JavaVM, but it was present before!");
407
408 LOG_RPC_DETAIL("Detaching current thread from JVM");
409 if (vm->DetachCurrentThread() != JNI_OK) {
410 mAttached = false;
411 } else {
412 ALOGW("Unable to detach current thread from JVM");
413 }
414 }
415
416private:
417 DISALLOW_COPY_AND_ASSIGN(JavaThreadAttacher);
418 bool mAttached = false;
419
420 static JavaVM* getJavaVM() {
421 static auto fn = reinterpret_cast<decltype(&AndroidRuntimeGetJavaVM)>(
422 dlsym(RTLD_DEFAULT, "AndroidRuntimeGetJavaVM"));
423 if (fn == nullptr) return nullptr;
424 return fn();
425 }
426};
Yifan Hongd258e682021-11-01 18:34:42 -0700427#endif
Yifan Hong194acf22021-06-29 18:44:56 -0700428} // namespace
429
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000430void RpcSession::join(sp<RpcSession>&& session, PreJoinSetupResult&& setupResult) {
431 sp<RpcConnection>& connection = setupResult.connection;
432
433 if (setupResult.status == OK) {
Steven Morelanddd67b942021-07-23 17:15:41 -0700434 LOG_ALWAYS_FATAL_IF(!connection, "must have connection if setup succeeded");
Yifan Hongd258e682021-11-01 18:34:42 -0700435 [[maybe_unused]] JavaThreadAttacher javaThreadAttacher;
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000436 while (true) {
Steven Moreland5ae62562021-06-10 03:21:42 +0000437 status_t status = session->state()->getAndExecuteCommand(connection, session,
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000438 RpcState::CommandType::ANY);
439 if (status != OK) {
440 LOG_RPC_DETAIL("Binder connection thread closing w/ status %s",
441 statusToString(status).c_str());
442 break;
443 }
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000444 }
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000445 } else {
446 ALOGE("Connection failed to init, closing with status %s",
447 statusToString(setupResult.status).c_str());
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000448 }
449
Steven Moreland659416d2021-05-11 00:47:50 +0000450 sp<RpcSession::EventListener> listener;
Steven Morelanda63ff932021-05-12 00:03:15 +0000451 {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000452 RpcMutexLockGuard _l(session->mMutex);
453 auto it = session->mConnections.mThreads.find(rpc_this_thread::get_id());
Steven Morelanda59937e2021-10-04 17:42:30 -0700454 LOG_ALWAYS_FATAL_IF(it == session->mConnections.mThreads.end());
Steven Morelanda63ff932021-05-12 00:03:15 +0000455 it->second.detach();
Steven Morelanda59937e2021-10-04 17:42:30 -0700456 session->mConnections.mThreads.erase(it);
Steven Morelandee3f4662021-05-22 01:07:33 +0000457
Steven Moreland659416d2021-05-11 00:47:50 +0000458 listener = session->mEventListener.promote();
Steven Morelandee3f4662021-05-22 01:07:33 +0000459 }
460
Steven Morelanddd67b942021-07-23 17:15:41 -0700461 // done after all cleanup, since session shutdown progresses via callbacks here
462 if (connection != nullptr) {
463 LOG_ALWAYS_FATAL_IF(!session->removeIncomingConnection(connection),
464 "bad state: connection object guaranteed to be in list");
465 }
466
Steven Moreland659416d2021-05-11 00:47:50 +0000467 session = nullptr;
468
469 if (listener != nullptr) {
Steven Moreland19fc9f72021-06-10 03:57:30 +0000470 listener->onSessionIncomingThreadEnded();
Steven Morelandee78e762021-05-05 21:12:51 +0000471 }
472}
473
Steven Moreland7b8bc4c2021-06-10 22:50:27 +0000474sp<RpcServer> RpcSession::server() {
475 RpcServer* unsafeServer = mForServer.unsafe_get();
476 sp<RpcServer> server = mForServer.promote();
477
478 LOG_ALWAYS_FATAL_IF((unsafeServer == nullptr) != (server == nullptr),
479 "wp<> is to avoid strong cycle only");
480 return server;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000481}
482
Steven Moreland826367f2021-09-10 14:05:31 -0700483status_t RpcSession::setupClient(const std::function<status_t(const std::vector<uint8_t>& sessionId,
484 bool incoming)>& connectAndInit) {
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000485 {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000486 RpcMutexLockGuard _l(mMutex);
Andrei Homescu9b58a462022-07-28 02:26:46 +0000487 LOG_ALWAYS_FATAL_IF(mStartedSetup, "Must only setup session once");
488 mStartedSetup = true;
489
490 if constexpr (!kEnableRpcThreads) {
491 LOG_ALWAYS_FATAL_IF(mMaxIncomingThreads > 0,
492 "Incoming threads are not supported on single-threaded libbinder");
493 // mMaxIncomingThreads should not change from here to its use below,
494 // since we set mStartedSetup==true and setMaxIncomingThreads checks
495 // for that
496 }
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000497 }
Steven Moreland27a8bc72021-09-29 16:07:41 -0700498
Yifan Hong832521e2021-08-05 14:55:40 -0700499 if (auto status = initShutdownTrigger(); status != OK) return status;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000500
Steven Moreland27a8bc72021-09-29 16:07:41 -0700501 auto oldProtocolVersion = mProtocolVersion;
502 auto cleanup = base::ScopeGuard([&] {
503 // if any threads are started, shut them down
504 (void)shutdownAndWait(true);
505
506 mShutdownListener = nullptr;
507 mEventListener.clear();
508
509 mId.clear();
510
511 mShutdownTrigger = nullptr;
512 mRpcBinderState = std::make_unique<RpcState>();
513
514 // protocol version may have been downgraded - if we reuse this object
515 // to connect to another server, force that server to request a
516 // downgrade again
517 mProtocolVersion = oldProtocolVersion;
518
Steven Morelanda59937e2021-10-04 17:42:30 -0700519 mConnections = {};
Andrei Homescu77ddf622022-08-23 00:33:15 +0000520
521 // clear mStartedSetup so that we can reuse this RpcSession
522 mStartedSetup = false;
Steven Moreland27a8bc72021-09-29 16:07:41 -0700523 });
524
Steven Moreland826367f2021-09-10 14:05:31 -0700525 if (status_t status = connectAndInit({}, false /*incoming*/); status != OK) return status;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000526
Steven Morelandbf57bce2021-07-26 15:26:12 -0700527 {
528 ExclusiveConnection connection;
Steven Moreland2372f9d2021-08-05 15:42:01 -0700529 if (status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this),
530 ConnectionUse::CLIENT, &connection);
531 status != OK)
532 return status;
Steven Morelandbf57bce2021-07-26 15:26:12 -0700533
534 uint32_t version;
Steven Moreland2372f9d2021-08-05 15:42:01 -0700535 if (status_t status =
536 state()->readNewSessionResponse(connection.get(),
537 sp<RpcSession>::fromExisting(this), &version);
538 status != OK)
539 return status;
Andrei Homescu9b58a462022-07-28 02:26:46 +0000540 if (!setProtocolVersionInternal(version, false)) return BAD_VALUE;
Steven Morelandbf57bce2021-07-26 15:26:12 -0700541 }
542
Steven Morelanda5036f02021-06-08 02:26:57 +0000543 // TODO(b/189955605): we should add additional sessions dynamically
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000544 // instead of all at once.
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000545 size_t numThreadsAvailable;
Steven Moreland1be91352021-05-11 22:12:15 +0000546 if (status_t status = getRemoteMaxThreads(&numThreadsAvailable); status != OK) {
Steven Moreland4198a122021-08-03 17:37:58 -0700547 ALOGE("Could not get max threads after initial session setup: %s",
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000548 statusToString(status).c_str());
Steven Moreland2372f9d2021-08-05 15:42:01 -0700549 return status;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000550 }
551
552 if (status_t status = readId(); status != OK) {
Steven Moreland4198a122021-08-03 17:37:58 -0700553 ALOGE("Could not get session id after initial session setup: %s",
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000554 statusToString(status).c_str());
Steven Moreland2372f9d2021-08-05 15:42:01 -0700555 return status;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000556 }
557
Yifan Hong1f44f982021-10-08 17:16:47 -0700558 size_t outgoingThreads = std::min(numThreadsAvailable, mMaxOutgoingThreads);
559 ALOGI_IF(outgoingThreads != numThreadsAvailable,
560 "Server hints client to start %zu outgoing threads, but client will only start %zu "
561 "because it is preconfigured to start at most %zu outgoing threads.",
562 numThreadsAvailable, outgoingThreads, mMaxOutgoingThreads);
563
Steven Morelanda5036f02021-06-08 02:26:57 +0000564 // TODO(b/189955605): we should add additional sessions dynamically
Steven Moreland659416d2021-05-11 00:47:50 +0000565 // instead of all at once - the other side should be responsible for setting
566 // up additional connections. We need to create at least one (unless 0 are
567 // requested to be set) in order to allow the other side to reliably make
568 // any requests at all.
569
Steven Moreland4198a122021-08-03 17:37:58 -0700570 // we've already setup one client
Yifan Hong1f44f982021-10-08 17:16:47 -0700571 LOG_RPC_DETAIL("RpcSession::setupClient() instantiating %zu outgoing (server max: %zu) and %zu "
572 "incoming threads",
573 outgoingThreads, numThreadsAvailable, mMaxIncomingThreads);
574 for (size_t i = 0; i + 1 < outgoingThreads; i++) {
Steven Moreland826367f2021-09-10 14:05:31 -0700575 if (status_t status = connectAndInit(mId, false /*incoming*/); status != OK) return status;
Steven Moreland4198a122021-08-03 17:37:58 -0700576 }
577
Yifan Hong10423062021-10-08 16:26:32 -0700578 for (size_t i = 0; i < mMaxIncomingThreads; i++) {
Steven Moreland826367f2021-09-10 14:05:31 -0700579 if (status_t status = connectAndInit(mId, true /*incoming*/); status != OK) return status;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000580 }
581
Steven Moreland27a8bc72021-09-29 16:07:41 -0700582 cleanup.Disable();
583
Steven Moreland2372f9d2021-08-05 15:42:01 -0700584 return OK;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000585}
586
Steven Moreland2372f9d2021-08-05 15:42:01 -0700587status_t RpcSession::setupSocketClient(const RpcSocketAddress& addr) {
Steven Moreland826367f2021-09-10 14:05:31 -0700588 return setupClient([&](const std::vector<uint8_t>& sessionId, bool incoming) {
Steven Moreland4198a122021-08-03 17:37:58 -0700589 return setupOneSocketConnection(addr, sessionId, incoming);
590 });
591}
592
Steven Moreland2372f9d2021-08-05 15:42:01 -0700593status_t RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr,
Steven Moreland826367f2021-09-10 14:05:31 -0700594 const std::vector<uint8_t>& sessionId,
595 bool incoming) {
Steven Moreland76d2c1f2021-05-05 20:28:58 +0000596 for (size_t tries = 0; tries < 5; tries++) {
597 if (tries > 0) usleep(10000);
598
Yifan Hongb675ffe2021-08-05 16:37:17 -0700599 unique_fd serverFd(TEMP_FAILURE_RETRY(
600 socket(addr.addr()->sa_family, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0)));
Steven Moreland76d2c1f2021-05-05 20:28:58 +0000601 if (serverFd == -1) {
602 int savedErrno = errno;
603 ALOGE("Could not create socket at %s: %s", addr.toString().c_str(),
604 strerror(savedErrno));
Steven Moreland2372f9d2021-08-05 15:42:01 -0700605 return -savedErrno;
Steven Moreland76d2c1f2021-05-05 20:28:58 +0000606 }
607
Pawan3e0061c2022-08-26 21:08:34 +0000608 RpcTransportFd transportFd(std::move(serverFd));
Pawan49d74cb2022-08-03 21:19:11 +0000609
610 if (0 != TEMP_FAILURE_RETRY(connect(transportFd.fd.get(), addr.addr(), addr.addrSize()))) {
Yifan Hong95d15e52021-08-25 17:15:15 -0700611 int connErrno = errno;
612 if (connErrno == EAGAIN || connErrno == EINPROGRESS) {
613 // For non-blocking sockets, connect() may return EAGAIN (for unix domain socket) or
614 // EINPROGRESS (for others). Call poll() and getsockopt() to get the error.
Pawan49d74cb2022-08-03 21:19:11 +0000615 status_t pollStatus = mShutdownTrigger->triggerablePoll(transportFd, POLLOUT);
Yifan Hong95d15e52021-08-25 17:15:15 -0700616 if (pollStatus != OK) {
617 ALOGE("Could not POLLOUT after connect() on non-blocking socket: %s",
618 statusToString(pollStatus).c_str());
619 return pollStatus;
620 }
621 // Set connErrno to the errno that connect() would have set if the fd were blocking.
622 socklen_t connErrnoLen = sizeof(connErrno);
Pawan49d74cb2022-08-03 21:19:11 +0000623 int ret = getsockopt(transportFd.fd.get(), SOL_SOCKET, SO_ERROR, &connErrno,
624 &connErrnoLen);
Yifan Hong95d15e52021-08-25 17:15:15 -0700625 if (ret == -1) {
626 int savedErrno = errno;
627 ALOGE("Could not getsockopt() after connect() on non-blocking socket: %s. "
628 "(Original error from connect() is: %s)",
629 strerror(savedErrno), strerror(connErrno));
630 return -savedErrno;
631 }
632 // Retrieved the real connErrno as if connect() was called with a blocking socket
633 // fd. Continue checking connErrno.
634 }
635 if (connErrno == ECONNRESET) {
Steven Moreland76d2c1f2021-05-05 20:28:58 +0000636 ALOGW("Connection reset on %s", addr.toString().c_str());
637 continue;
638 }
Yifan Hong95d15e52021-08-25 17:15:15 -0700639 // connErrno could be zero if getsockopt determines so. Hence zero-check again.
640 if (connErrno != 0) {
Yifan Hongd9f8cef2021-08-05 15:17:31 -0700641 ALOGE("Could not connect socket at %s: %s", addr.toString().c_str(),
Yifan Hong95d15e52021-08-25 17:15:15 -0700642 strerror(connErrno));
643 return -connErrno;
Yifan Hongd9f8cef2021-08-05 15:17:31 -0700644 }
Steven Moreland76d2c1f2021-05-05 20:28:58 +0000645 }
Pawan49d74cb2022-08-03 21:19:11 +0000646 LOG_RPC_DETAIL("Socket at %s client with fd %d", addr.toString().c_str(),
647 transportFd.fd.get());
Yifan Hong702115c2021-06-24 15:39:18 -0700648
Pawan49d74cb2022-08-03 21:19:11 +0000649 return initAndAddConnection(std::move(transportFd), sessionId, incoming);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000650 }
651
Steven Moreland76d2c1f2021-05-05 20:28:58 +0000652 ALOGE("Ran out of retries to connect to %s", addr.toString().c_str());
Steven Moreland2372f9d2021-08-05 15:42:01 -0700653 return UNKNOWN_ERROR;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000654}
655
Pawan3e0061c2022-08-26 21:08:34 +0000656status_t RpcSession::initAndAddConnection(RpcTransportFd fd, const std::vector<uint8_t>& sessionId,
Steven Moreland2372f9d2021-08-05 15:42:01 -0700657 bool incoming) {
Yifan Hong8c950422021-08-05 17:13:55 -0700658 LOG_ALWAYS_FATAL_IF(mShutdownTrigger == nullptr);
Yifan Hongecf937d2021-08-11 17:29:28 -0700659 auto server = mCtx->newTransport(std::move(fd), mShutdownTrigger.get());
Steven Moreland4198a122021-08-03 17:37:58 -0700660 if (server == nullptr) {
Yifan Hongecf937d2021-08-11 17:29:28 -0700661 ALOGE("%s: Unable to set up RpcTransport", __PRETTY_FUNCTION__);
Steven Moreland2372f9d2021-08-05 15:42:01 -0700662 return UNKNOWN_ERROR;
Steven Moreland4198a122021-08-03 17:37:58 -0700663 }
664
665 LOG_RPC_DETAIL("Socket at client with RpcTransport %p", server.get());
666
Steven Moreland826367f2021-09-10 14:05:31 -0700667 if (sessionId.size() > std::numeric_limits<uint16_t>::max()) {
668 ALOGE("Session ID too big %zu", sessionId.size());
669 return BAD_VALUE;
670 }
671
Steven Moreland4198a122021-08-03 17:37:58 -0700672 RpcConnectionHeader header{
673 .version = mProtocolVersion.value_or(RPC_WIRE_PROTOCOL_VERSION),
674 .options = 0,
Frederick Mayle69a0c992022-05-26 20:38:39 +0000675 .fileDescriptorTransportMode = static_cast<uint8_t>(mFileDescriptorTransportMode),
Steven Moreland826367f2021-09-10 14:05:31 -0700676 .sessionIdSize = static_cast<uint16_t>(sessionId.size()),
Steven Moreland4198a122021-08-03 17:37:58 -0700677 };
Steven Moreland4198a122021-08-03 17:37:58 -0700678
Steven Moreland826367f2021-09-10 14:05:31 -0700679 if (incoming) {
680 header.options |= RPC_CONNECTION_OPTION_INCOMING;
681 }
Steven Moreland4198a122021-08-03 17:37:58 -0700682
Andrei Homescua39e4ed2021-12-10 08:41:54 +0000683 iovec headerIov{&header, sizeof(header)};
Frederick Mayle69a0c992022-05-26 20:38:39 +0000684 auto sendHeaderStatus = server->interruptableWriteFully(mShutdownTrigger.get(), &headerIov, 1,
685 std::nullopt, nullptr);
Yifan Hong8c950422021-08-05 17:13:55 -0700686 if (sendHeaderStatus != OK) {
Steven Moreland4198a122021-08-03 17:37:58 -0700687 ALOGE("Could not write connection header to socket: %s",
Yifan Hong8c950422021-08-05 17:13:55 -0700688 statusToString(sendHeaderStatus).c_str());
689 return sendHeaderStatus;
Steven Moreland4198a122021-08-03 17:37:58 -0700690 }
691
Steven Moreland826367f2021-09-10 14:05:31 -0700692 if (sessionId.size() > 0) {
Andrei Homescua39e4ed2021-12-10 08:41:54 +0000693 iovec sessionIov{const_cast<void*>(static_cast<const void*>(sessionId.data())),
694 sessionId.size()};
Frederick Mayle69a0c992022-05-26 20:38:39 +0000695 auto sendSessionIdStatus =
696 server->interruptableWriteFully(mShutdownTrigger.get(), &sessionIov, 1,
697 std::nullopt, nullptr);
Steven Moreland826367f2021-09-10 14:05:31 -0700698 if (sendSessionIdStatus != OK) {
699 ALOGE("Could not write session ID ('%s') to socket: %s",
700 base::HexString(sessionId.data(), sessionId.size()).c_str(),
701 statusToString(sendSessionIdStatus).c_str());
702 return sendSessionIdStatus;
703 }
704 }
705
Steven Moreland4198a122021-08-03 17:37:58 -0700706 LOG_RPC_DETAIL("Socket at client: header sent");
707
708 if (incoming) {
709 return addIncomingConnection(std::move(server));
710 } else {
711 return addOutgoingConnection(std::move(server), true /*init*/);
712 }
713}
714
Steven Moreland2372f9d2021-08-05 15:42:01 -0700715status_t RpcSession::addIncomingConnection(std::unique_ptr<RpcTransport> rpcTransport) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000716 RpcMutex mutex;
717 RpcConditionVariable joinCv;
718 RpcMutexUniqueLock lock(mutex);
719 RpcMaybeThread thread;
Steven Morelandfba6f772021-07-15 22:45:09 +0000720 sp<RpcSession> thiz = sp<RpcSession>::fromExisting(this);
721 bool ownershipTransferred = false;
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000722 thread = RpcMaybeThread([&]() {
723 RpcMutexUniqueLock threadLock(mutex);
Yifan Hong702115c2021-06-24 15:39:18 -0700724 std::unique_ptr<RpcTransport> movedRpcTransport = std::move(rpcTransport);
Steven Morelandfba6f772021-07-15 22:45:09 +0000725 // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
726 sp<RpcSession> session = thiz;
727 session->preJoinThreadOwnership(std::move(thread));
728
729 // only continue once we have a response or the connection fails
Yifan Hong702115c2021-06-24 15:39:18 -0700730 auto setupResult = session->preJoinSetup(std::move(movedRpcTransport));
Steven Morelandfba6f772021-07-15 22:45:09 +0000731
732 ownershipTransferred = true;
733 threadLock.unlock();
734 joinCv.notify_one();
735 // do not use & vars below
736
737 RpcSession::join(std::move(session), std::move(setupResult));
738 });
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000739 rpcJoinIfSingleThreaded(thread);
Steven Morelandfba6f772021-07-15 22:45:09 +0000740 joinCv.wait(lock, [&] { return ownershipTransferred; });
741 LOG_ALWAYS_FATAL_IF(!ownershipTransferred);
Steven Moreland2372f9d2021-08-05 15:42:01 -0700742 return OK;
Steven Morelandfba6f772021-07-15 22:45:09 +0000743}
744
Yifan Hong832521e2021-08-05 14:55:40 -0700745status_t RpcSession::initShutdownTrigger() {
746 // first client connection added, but setForServer not called, so
747 // initializaing for a client.
748 if (mShutdownTrigger == nullptr) {
749 mShutdownTrigger = FdTrigger::make();
750 mEventListener = mShutdownListener = sp<WaitForShutdownListener>::make();
751 if (mShutdownTrigger == nullptr) return INVALID_OPERATION;
752 }
753 return OK;
754}
755
Steven Moreland2372f9d2021-08-05 15:42:01 -0700756status_t RpcSession::addOutgoingConnection(std::unique_ptr<RpcTransport> rpcTransport, bool init) {
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000757 sp<RpcConnection> connection = sp<RpcConnection>::make();
758 {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000759 RpcMutexLockGuard _l(mMutex);
Yifan Hong702115c2021-06-24 15:39:18 -0700760 connection->rpcTransport = std::move(rpcTransport);
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000761 connection->exclusiveTid = rpcGetThreadId();
Steven Morelanda59937e2021-10-04 17:42:30 -0700762 mConnections.mOutgoing.push_back(connection);
Steven Morelandee3f4662021-05-22 01:07:33 +0000763 }
764
Steven Morelandb86e26b2021-06-12 00:35:58 +0000765 status_t status = OK;
766 if (init) {
Steven Morelandfc027e02021-10-25 15:31:31 -0700767 status =
768 mRpcBinderState->sendConnectionInit(connection, sp<RpcSession>::fromExisting(this));
Steven Morelandb86e26b2021-06-12 00:35:58 +0000769 }
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000770
Andrei Homescuc8490872022-06-23 05:18:51 +0000771 clearConnectionTid(connection);
Steven Morelandc88b7fc2021-06-10 00:40:39 +0000772
Steven Moreland2372f9d2021-08-05 15:42:01 -0700773 return status;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000774}
775
Steven Morelanda8b44292021-06-08 01:27:53 +0000776bool RpcSession::setForServer(const wp<RpcServer>& server, const wp<EventListener>& eventListener,
Steven Moreland51c44a92021-10-14 16:50:35 -0700777 const std::vector<uint8_t>& sessionId,
778 const sp<IBinder>& sessionSpecificRoot) {
Steven Moreland659416d2021-05-11 00:47:50 +0000779 LOG_ALWAYS_FATAL_IF(mForServer != nullptr);
780 LOG_ALWAYS_FATAL_IF(server == nullptr);
781 LOG_ALWAYS_FATAL_IF(mEventListener != nullptr);
782 LOG_ALWAYS_FATAL_IF(eventListener == nullptr);
Steven Morelandee3f4662021-05-22 01:07:33 +0000783 LOG_ALWAYS_FATAL_IF(mShutdownTrigger != nullptr);
Andrei Homescu5e301462022-05-12 00:52:34 +0000784 LOG_ALWAYS_FATAL_IF(mCtx != nullptr);
Steven Morelanda8b44292021-06-08 01:27:53 +0000785
786 mShutdownTrigger = FdTrigger::make();
787 if (mShutdownTrigger == nullptr) return false;
Steven Morelandee3f4662021-05-22 01:07:33 +0000788
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000789 mId = sessionId;
790 mForServer = server;
Steven Moreland659416d2021-05-11 00:47:50 +0000791 mEventListener = eventListener;
Steven Moreland51c44a92021-10-14 16:50:35 -0700792 mSessionSpecificRootObject = sessionSpecificRoot;
Steven Morelanda8b44292021-06-08 01:27:53 +0000793 return true;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000794}
795
Yifan Hong702115c2021-06-24 15:39:18 -0700796sp<RpcSession::RpcConnection> RpcSession::assignIncomingConnectionToThisThread(
797 std::unique_ptr<RpcTransport> rpcTransport) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000798 RpcMutexLockGuard _l(mMutex);
Steven Morelanddd67b942021-07-23 17:15:41 -0700799
Yifan Hong10423062021-10-08 16:26:32 -0700800 if (mConnections.mIncoming.size() >= mMaxIncomingThreads) {
Steven Moreland132d5bf2021-08-03 16:13:24 -0700801 ALOGE("Cannot add thread to session with %zu threads (max is set to %zu)",
Yifan Hong10423062021-10-08 16:26:32 -0700802 mConnections.mIncoming.size(), mMaxIncomingThreads);
Steven Moreland132d5bf2021-08-03 16:13:24 -0700803 return nullptr;
804 }
805
Steven Morelanddd67b942021-07-23 17:15:41 -0700806 // Don't accept any more connections, some have shutdown. Usually this
807 // happens when new connections are still being established as part of a
808 // very short-lived session which shuts down after it already started
809 // accepting new connections.
Steven Morelanda59937e2021-10-04 17:42:30 -0700810 if (mConnections.mIncoming.size() < mConnections.mMaxIncoming) {
Steven Morelanddd67b942021-07-23 17:15:41 -0700811 return nullptr;
812 }
813
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000814 sp<RpcConnection> session = sp<RpcConnection>::make();
Yifan Hong702115c2021-06-24 15:39:18 -0700815 session->rpcTransport = std::move(rpcTransport);
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000816 session->exclusiveTid = rpcGetThreadId();
Steven Morelanddd67b942021-07-23 17:15:41 -0700817
Steven Morelanda59937e2021-10-04 17:42:30 -0700818 mConnections.mIncoming.push_back(session);
819 mConnections.mMaxIncoming = mConnections.mIncoming.size();
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000820
821 return session;
822}
823
Steven Moreland19fc9f72021-06-10 03:57:30 +0000824bool RpcSession::removeIncomingConnection(const sp<RpcConnection>& connection) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000825 RpcMutexUniqueLock _l(mMutex);
Steven Morelanda59937e2021-10-04 17:42:30 -0700826 if (auto it =
827 std::find(mConnections.mIncoming.begin(), mConnections.mIncoming.end(), connection);
828 it != mConnections.mIncoming.end()) {
829 mConnections.mIncoming.erase(it);
830 if (mConnections.mIncoming.size() == 0) {
Steven Moreland659416d2021-05-11 00:47:50 +0000831 sp<EventListener> listener = mEventListener.promote();
832 if (listener) {
Steven Morelanddd67b942021-07-23 17:15:41 -0700833 _l.unlock();
834 listener->onSessionAllIncomingThreadsEnded(sp<RpcSession>::fromExisting(this));
Steven Morelanda86e8fe2021-05-26 22:52:35 +0000835 }
Steven Morelandee78e762021-05-05 21:12:51 +0000836 }
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000837 return true;
838 }
839 return false;
840}
841
Andrei Homescuc8490872022-06-23 05:18:51 +0000842void RpcSession::clearConnectionTid(const sp<RpcConnection>& connection) {
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000843 RpcMutexUniqueLock _l(mMutex);
Andrei Homescuc8490872022-06-23 05:18:51 +0000844 connection->exclusiveTid = std::nullopt;
845 if (mConnections.mWaitingThreads > 0) {
846 _l.unlock();
847 mAvailableConnectionCv.notify_one();
848 }
849}
850
Yifan Hong9734cfc2021-09-13 16:14:09 -0700851std::vector<uint8_t> RpcSession::getCertificate(RpcCertificateFormat format) {
Yifan Hongecf937d2021-08-11 17:29:28 -0700852 return mCtx->getCertificate(format);
853}
854
Steven Moreland195edb82021-06-08 02:44:39 +0000855status_t RpcSession::ExclusiveConnection::find(const sp<RpcSession>& session, ConnectionUse use,
856 ExclusiveConnection* connection) {
857 connection->mSession = session;
858 connection->mConnection = nullptr;
859 connection->mReentrant = false;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000860
Andrei Homescuffa3aaa2022-04-07 05:06:33 +0000861 uint64_t tid = rpcGetThreadId();
862 RpcMutexUniqueLock _l(session->mMutex);
Steven Moreland195edb82021-06-08 02:44:39 +0000863
Steven Morelanda59937e2021-10-04 17:42:30 -0700864 session->mConnections.mWaitingThreads++;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000865 while (true) {
866 sp<RpcConnection> exclusive;
867 sp<RpcConnection> available;
868
869 // CHECK FOR DEDICATED CLIENT SOCKET
870 //
Steven Moreland85e067b2021-05-26 17:43:53 +0000871 // A server/looper should always use a dedicated connection if available
Steven Morelanda59937e2021-10-04 17:42:30 -0700872 findConnection(tid, &exclusive, &available, session->mConnections.mOutgoing,
873 session->mConnections.mOutgoingOffset);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000874
875 // WARNING: this assumes a server cannot request its client to send
Steven Morelanda59937e2021-10-04 17:42:30 -0700876 // a transaction, as mIncoming is excluded below.
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000877 //
878 // Imagine we have more than one thread in play, and a single thread
879 // sends a synchronous, then an asynchronous command. Imagine the
880 // asynchronous command is sent on the first client connection. Then, if
881 // we naively send a synchronous command to that same connection, the
882 // thread on the far side might be busy processing the asynchronous
883 // command. So, we move to considering the second available thread
884 // for subsequent calls.
885 if (use == ConnectionUse::CLIENT_ASYNC && (exclusive != nullptr || available != nullptr)) {
Steven Morelanda59937e2021-10-04 17:42:30 -0700886 session->mConnections.mOutgoingOffset = (session->mConnections.mOutgoingOffset + 1) %
887 session->mConnections.mOutgoing.size();
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000888 }
889
Steven Morelandc7d40132021-06-10 03:42:11 +0000890 // USE SERVING SOCKET (e.g. nested transaction)
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000891 if (use != ConnectionUse::CLIENT_ASYNC) {
Steven Moreland19fc9f72021-06-10 03:57:30 +0000892 sp<RpcConnection> exclusiveIncoming;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000893 // server connections are always assigned to a thread
Steven Moreland19fc9f72021-06-10 03:57:30 +0000894 findConnection(tid, &exclusiveIncoming, nullptr /*available*/,
Steven Morelanda59937e2021-10-04 17:42:30 -0700895 session->mConnections.mIncoming, 0 /* index hint */);
Steven Morelandc7d40132021-06-10 03:42:11 +0000896
897 // asynchronous calls cannot be nested, we currently allow ref count
898 // calls to be nested (so that you can use this without having extra
899 // threads). Note 'drainCommands' is used so that these ref counts can't
900 // build up.
Steven Moreland19fc9f72021-06-10 03:57:30 +0000901 if (exclusiveIncoming != nullptr) {
902 if (exclusiveIncoming->allowNested) {
Steven Morelandc7d40132021-06-10 03:42:11 +0000903 // guaranteed to be processed as nested command
Steven Moreland19fc9f72021-06-10 03:57:30 +0000904 exclusive = exclusiveIncoming;
Steven Morelandc7d40132021-06-10 03:42:11 +0000905 } else if (use == ConnectionUse::CLIENT_REFCOUNT && available == nullptr) {
906 // prefer available socket, but if we don't have one, don't
907 // wait for one
Steven Moreland19fc9f72021-06-10 03:57:30 +0000908 exclusive = exclusiveIncoming;
Steven Morelandc7d40132021-06-10 03:42:11 +0000909 }
910 }
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000911 }
912
Steven Moreland85e067b2021-05-26 17:43:53 +0000913 // if our thread is already using a connection, prioritize using that
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000914 if (exclusive != nullptr) {
Steven Moreland195edb82021-06-08 02:44:39 +0000915 connection->mConnection = exclusive;
916 connection->mReentrant = true;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000917 break;
918 } else if (available != nullptr) {
Steven Moreland195edb82021-06-08 02:44:39 +0000919 connection->mConnection = available;
920 connection->mConnection->exclusiveTid = tid;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000921 break;
922 }
923
Steven Morelanda59937e2021-10-04 17:42:30 -0700924 if (session->mConnections.mOutgoing.size() == 0) {
Steven Moreland25d9cc52022-03-10 23:11:56 +0000925 ALOGE("Session has no outgoing connections. This is required for an RPC server to make "
926 "any non-nested (e.g. oneway or on another thread) calls. Use code request "
927 "reason: %d. Incoming connections: %zu. %s.",
928 static_cast<int>(use), session->mConnections.mIncoming.size(),
929 (session->server()
930 ? "This is a server session, so see RpcSession::setMaxIncomingThreads "
931 "for the corresponding client"
932 : "This is a client session, so see RpcSession::setMaxOutgoingThreads "
933 "for this client or RpcServer::setMaxThreads for the corresponding "
934 "server"));
Steven Moreland195edb82021-06-08 02:44:39 +0000935 return WOULD_BLOCK;
936 }
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000937
Steven Moreland85e067b2021-05-26 17:43:53 +0000938 LOG_RPC_DETAIL("No available connections (have %zu clients and %zu servers). Waiting...",
Steven Morelanda59937e2021-10-04 17:42:30 -0700939 session->mConnections.mOutgoing.size(),
940 session->mConnections.mIncoming.size());
Steven Moreland195edb82021-06-08 02:44:39 +0000941 session->mAvailableConnectionCv.wait(_l);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000942 }
Steven Morelanda59937e2021-10-04 17:42:30 -0700943 session->mConnections.mWaitingThreads--;
Steven Moreland195edb82021-06-08 02:44:39 +0000944
945 return OK;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000946}
947
Andrei Homescue922b232022-04-23 03:41:09 +0000948void RpcSession::ExclusiveConnection::findConnection(uint64_t tid, sp<RpcConnection>* exclusive,
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000949 sp<RpcConnection>* available,
950 std::vector<sp<RpcConnection>>& sockets,
951 size_t socketsIndexHint) {
952 LOG_ALWAYS_FATAL_IF(sockets.size() > 0 && socketsIndexHint >= sockets.size(),
953 "Bad index %zu >= %zu", socketsIndexHint, sockets.size());
954
955 if (*exclusive != nullptr) return; // consistent with break below
956
957 for (size_t i = 0; i < sockets.size(); i++) {
958 sp<RpcConnection>& socket = sockets[(i + socketsIndexHint) % sockets.size()];
959
Steven Moreland85e067b2021-05-26 17:43:53 +0000960 // take first available connection (intuition = caching)
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000961 if (available && *available == nullptr && socket->exclusiveTid == std::nullopt) {
962 *available = socket;
963 continue;
964 }
965
Steven Moreland85e067b2021-05-26 17:43:53 +0000966 // though, prefer to take connection which is already inuse by this thread
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000967 // (nested transactions)
968 if (exclusive && socket->exclusiveTid == tid) {
969 *exclusive = socket;
970 break; // consistent with return above
971 }
972 }
973}
974
975RpcSession::ExclusiveConnection::~ExclusiveConnection() {
Steven Moreland85e067b2021-05-26 17:43:53 +0000976 // reentrant use of a connection means something less deep in the call stack
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000977 // is using this fd, and it retains the right to it. So, we don't give up
978 // exclusive ownership, and no thread is freed.
Steven Moreland195edb82021-06-08 02:44:39 +0000979 if (!mReentrant && mConnection != nullptr) {
Andrei Homescuc8490872022-06-23 05:18:51 +0000980 mSession->clearConnectionTid(mConnection);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000981 }
982}
983
Pawan1c24f9c2022-08-26 23:23:15 +0000984bool RpcSession::hasActiveConnection(const std::vector<sp<RpcConnection>>& connections) {
985 for (const auto& connection : connections) {
986 if (connection->exclusiveTid != std::nullopt && !connection->rpcTransport->isWaiting()) {
987 return true;
988 }
989 }
990 return false;
991}
992
993bool RpcSession::hasActiveRequests() {
994 RpcMutexUniqueLock _l(mMutex);
995 if (hasActiveConnection(mConnections.mIncoming)) {
996 return true;
997 }
998 if (hasActiveConnection(mConnections.mOutgoing)) {
999 return true;
1000 }
1001 return mConnections.mWaitingThreads != 0;
1002}
1003
Steven Morelandbdb53ab2021-05-05 17:57:41 +00001004} // namespace android