blob: b8cf2dbb45404f1368257e490833748c68455fa1 [file] [log] [blame]
Steven Moreland5553ac42020-11-11 02:14:45 +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#pragma once
17
18#include <android-base/unique_fd.h>
19#include <binder/IBinder.h>
20#include <binder/Parcel.h>
Steven Morelandbdb53ab2021-05-05 17:57:41 +000021#include <binder/RpcSession.h>
Steven Moreland5553ac42020-11-11 02:14:45 +000022
23#include <map>
Steven Morelande8393342021-05-05 23:27:53 +000024#include <optional>
Steven Moreland5553ac42020-11-11 02:14:45 +000025#include <queue>
26
27namespace android {
28
29struct RpcWireHeader;
30
31/**
32 * Log a lot more information about RPC calls, when debugging issues. Usually,
33 * you would want to enable this in only one process. If repeated issues require
34 * a specific subset of logs to debug, this could be broken up like
35 * IPCThreadState's.
36 */
37#define SHOULD_LOG_RPC_DETAIL false
38
39#if SHOULD_LOG_RPC_DETAIL
40#define LOG_RPC_DETAIL(...) ALOGI(__VA_ARGS__)
41#else
42#define LOG_RPC_DETAIL(...) ALOGV(__VA_ARGS__) // for type checking
43#endif
44
Steven Morelandb8176792021-06-22 20:29:21 +000045#define RPC_FLAKE_PRONE false
46
Devin Moore08256432021-07-02 13:03:49 -070047#if RPC_FLAKE_PRONE
Steven Morelandb8176792021-06-22 20:29:21 +000048void rpcMaybeWaitToFlake();
49#define MAYBE_WAIT_IN_FLAKE_MODE rpcMaybeWaitToFlake()
50#else
51#define MAYBE_WAIT_IN_FLAKE_MODE do {} while (false)
52#endif
53
Steven Moreland5553ac42020-11-11 02:14:45 +000054/**
55 * Abstracts away management of ref counts and the wire format from
Steven Morelandbdb53ab2021-05-05 17:57:41 +000056 * RpcSession
Steven Moreland5553ac42020-11-11 02:14:45 +000057 */
58class RpcState {
59public:
60 RpcState();
61 ~RpcState();
62
Steven Morelandbf57bce2021-07-26 15:26:12 -070063 status_t readNewSessionResponse(const sp<RpcSession::RpcConnection>& connection,
64 const sp<RpcSession>& session, uint32_t* version);
Steven Moreland5ae62562021-06-10 03:21:42 +000065 status_t sendConnectionInit(const sp<RpcSession::RpcConnection>& connection,
66 const sp<RpcSession>& session);
67 status_t readConnectionInit(const sp<RpcSession::RpcConnection>& connection,
68 const sp<RpcSession>& session);
Steven Morelandc88b7fc2021-06-10 00:40:39 +000069
Steven Moreland7c5e6c22021-05-01 02:55:20 +000070 // TODO(b/182940634): combine some special transactions into one "getServerInfo" call?
Steven Moreland5ae62562021-06-10 03:21:42 +000071 sp<IBinder> getRootObject(const sp<RpcSession::RpcConnection>& connection,
72 const sp<RpcSession>& session);
73 status_t getMaxThreads(const sp<RpcSession::RpcConnection>& connection,
74 const sp<RpcSession>& session, size_t* maxThreadsOut);
75 status_t getSessionId(const sp<RpcSession::RpcConnection>& connection,
Steven Moreland826367f2021-09-10 14:05:31 -070076 const sp<RpcSession>& session, std::vector<uint8_t>* sessionIdOut);
Steven Moreland5553ac42020-11-11 02:14:45 +000077
Steven Moreland5ae62562021-06-10 03:21:42 +000078 [[nodiscard]] status_t transact(const sp<RpcSession::RpcConnection>& connection,
79 const sp<IBinder>& address, uint32_t code, const Parcel& data,
Steven Morelandbdb53ab2021-05-05 17:57:41 +000080 const sp<RpcSession>& session, Parcel* reply, uint32_t flags);
Steven Moreland5ae62562021-06-10 03:21:42 +000081 [[nodiscard]] status_t transactAddress(const sp<RpcSession::RpcConnection>& connection,
82 const RpcAddress& address, uint32_t code,
83 const Parcel& data, const sp<RpcSession>& session,
84 Parcel* reply, uint32_t flags);
85 [[nodiscard]] status_t sendDecStrong(const sp<RpcSession::RpcConnection>& connection,
86 const sp<RpcSession>& session, const RpcAddress& address);
Steven Moreland52eee942021-06-03 00:59:28 +000087
88 enum class CommandType {
89 ANY,
90 CONTROL_ONLY,
91 };
Steven Moreland5ae62562021-06-10 03:21:42 +000092 [[nodiscard]] status_t getAndExecuteCommand(const sp<RpcSession::RpcConnection>& connection,
Steven Moreland52eee942021-06-03 00:59:28 +000093 const sp<RpcSession>& session, CommandType type);
Steven Moreland5ae62562021-06-10 03:21:42 +000094 [[nodiscard]] status_t drainCommands(const sp<RpcSession::RpcConnection>& connection,
95 const sp<RpcSession>& session, CommandType type);
Steven Moreland5553ac42020-11-11 02:14:45 +000096
97 /**
98 * Called by Parcel for outgoing binders. This implies one refcount of
99 * ownership to the outgoing binder.
100 */
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000101 [[nodiscard]] status_t onBinderLeaving(const sp<RpcSession>& session, const sp<IBinder>& binder,
102 RpcAddress* outAddress);
Steven Moreland5553ac42020-11-11 02:14:45 +0000103
104 /**
105 * Called by Parcel for incoming binders. This either returns the refcount
106 * to the process, if this process already has one, or it takes ownership of
107 * that refcount
108 */
Steven Moreland7227c8a2021-06-02 00:24:32 +0000109 [[nodiscard]] status_t onBinderEntering(const sp<RpcSession>& session,
110 const RpcAddress& address, sp<IBinder>* out);
Steven Moreland5553ac42020-11-11 02:14:45 +0000111
112 size_t countBinders();
113 void dump();
114
Steven Moreland5553ac42020-11-11 02:14:45 +0000115 /**
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000116 * Called when reading or writing data to a session fails to clean up
117 * data associated with the session in order to cleanup binders.
Steven Moreland5553ac42020-11-11 02:14:45 +0000118 * Specifically, we have a strong dependency cycle, since BpBinder is
119 * OBJECT_LIFETIME_WEAK (so that onAttemptIncStrong may return true).
120 *
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000121 * BpBinder -> RpcSession -> RpcState
Steven Moreland5553ac42020-11-11 02:14:45 +0000122 * ^-----------------------------/
123 *
124 * In the success case, eventually all refcounts should be propagated over
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000125 * the session, though this could also be called to eagerly cleanup
126 * the session.
Steven Moreland5553ac42020-11-11 02:14:45 +0000127 *
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000128 * WARNING: RpcState is responsible for calling this when the session is
Steven Moreland5553ac42020-11-11 02:14:45 +0000129 * no longer recoverable.
130 */
Steven Morelandc9d7b532021-06-04 20:57:41 +0000131 void clear();
Steven Moreland5553ac42020-11-11 02:14:45 +0000132
Steven Moreland659416d2021-05-11 00:47:50 +0000133private:
Steven Moreland583a14a2021-06-04 02:04:58 +0000134 void dumpLocked();
Steven Moreland583a14a2021-06-04 02:04:58 +0000135
Steven Morelanddbe71832021-05-12 23:31:00 +0000136 // Alternative to std::vector<uint8_t> that doesn't abort on allocation failure and caps
137 // large allocations to avoid being requested from allocating too much data.
138 struct CommandData {
139 explicit CommandData(size_t size);
Steven Morelande8393342021-05-05 23:27:53 +0000140 bool valid() { return mSize == 0 || mData != nullptr; }
141 size_t size() { return mSize; }
142 uint8_t* data() { return mData.get(); }
143 uint8_t* release() { return mData.release(); }
144
145 private:
146 std::unique_ptr<uint8_t[]> mData;
147 size_t mSize;
148 };
149
Steven Moreland5ae62562021-06-10 03:21:42 +0000150 [[nodiscard]] status_t rpcSend(const sp<RpcSession::RpcConnection>& connection,
151 const sp<RpcSession>& session, const char* what,
152 const void* data, size_t size);
153 [[nodiscard]] status_t rpcRec(const sp<RpcSession::RpcConnection>& connection,
154 const sp<RpcSession>& session, const char* what, void* data,
155 size_t size);
Steven Moreland5553ac42020-11-11 02:14:45 +0000156
Steven Moreland5ae62562021-06-10 03:21:42 +0000157 [[nodiscard]] status_t waitForReply(const sp<RpcSession::RpcConnection>& connection,
158 const sp<RpcSession>& session, Parcel* reply);
Steven Moreland19fc9f72021-06-10 03:57:30 +0000159 [[nodiscard]] status_t processCommand(const sp<RpcSession::RpcConnection>& connection,
160 const sp<RpcSession>& session,
161 const RpcWireHeader& command, CommandType type);
Steven Moreland5ae62562021-06-10 03:21:42 +0000162 [[nodiscard]] status_t processTransact(const sp<RpcSession::RpcConnection>& connection,
163 const sp<RpcSession>& session,
Steven Moreland5553ac42020-11-11 02:14:45 +0000164 const RpcWireHeader& command);
Steven Moreland5ae62562021-06-10 03:21:42 +0000165 [[nodiscard]] status_t processTransactInternal(const sp<RpcSession::RpcConnection>& connection,
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000166 const sp<RpcSession>& session,
Steven Morelandada72bd2021-06-09 23:29:13 +0000167 CommandData transactionData);
Steven Moreland5ae62562021-06-10 03:21:42 +0000168 [[nodiscard]] status_t processDecStrong(const sp<RpcSession::RpcConnection>& connection,
Steven Morelandee3f4662021-05-22 01:07:33 +0000169 const sp<RpcSession>& session,
Steven Moreland5553ac42020-11-11 02:14:45 +0000170 const RpcWireHeader& command);
171
172 struct BinderNode {
173 // Two cases:
174 // A - local binder we are serving
175 // B - remote binder, we are sending transactions to
176 wp<IBinder> binder;
177
178 // if timesSent > 0, this will be equal to binder.promote()
179 sp<IBinder> sentRef;
180
181 // Number of times we've sent this binder out of process, which
182 // translates to an implicit strong count. A client must send RPC binder
183 // socket's dec ref for each time it is sent out of process in order to
184 // deallocate it. Note, a proxy binder we are holding onto might be
185 // sent (this is important when the only remaining refcount of this
186 // binder is the one associated with a transaction sending it back to
187 // its server)
188 size_t timesSent = 0;
189
190 // Number of times we've received this binder, each time corresponds to
191 // a reference we hold over the wire (not a local incStrong/decStrong)
192 size_t timesRecd = 0;
193
194 // transaction ID, for async transactions
195 uint64_t asyncNumber = 0;
196
197 //
198 // CASE A - local binder we are serving
199 //
200
201 // async transaction queue, _only_ for local binder
202 struct AsyncTodo {
Steven Morelandf5174272021-05-25 00:39:28 +0000203 sp<IBinder> ref;
Steven Morelanddbe71832021-05-12 23:31:00 +0000204 CommandData data;
Steven Moreland5553ac42020-11-11 02:14:45 +0000205 uint64_t asyncNumber = 0;
206
207 bool operator<(const AsyncTodo& o) const {
208 return asyncNumber > /* !!! */ o.asyncNumber;
209 }
210 };
211 std::priority_queue<AsyncTodo> asyncTodo;
212
213 //
214 // CASE B - remote binder, we are sending transactions to
215 //
216
217 // (no additional data specific to remote binders)
218 };
219
Steven Moreland31bde7a2021-06-04 00:57:36 +0000220 // checks if there is any reference left to a node and erases it. If erase
221 // happens, and there is a strong reference to the binder kept by
222 // binderNode, this returns that strong reference, so that it can be
223 // dropped after any locks are removed.
224 sp<IBinder> tryEraseNode(std::map<RpcAddress, BinderNode>::iterator& it);
Steven Moreland583a14a2021-06-04 02:04:58 +0000225 // true - success
Steven Morelandc9d7b532021-06-04 20:57:41 +0000226 // false - session shutdown, halt
227 [[nodiscard]] bool nodeProgressAsyncNumber(BinderNode* node);
Steven Moreland31bde7a2021-06-04 00:57:36 +0000228
Steven Moreland5553ac42020-11-11 02:14:45 +0000229 std::mutex mNodeMutex;
230 bool mTerminated = false;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000231 // binders known by both sides of a session
Steven Moreland5553ac42020-11-11 02:14:45 +0000232 std::map<RpcAddress, BinderNode> mNodeForAddress;
233};
234
235} // namespace android