blob: d63c1c36ba6a82f96de5b6453336ae28e0e2515f [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
45/**
46 * Abstracts away management of ref counts and the wire format from
Steven Morelandbdb53ab2021-05-05 17:57:41 +000047 * RpcSession
Steven Moreland5553ac42020-11-11 02:14:45 +000048 */
49class RpcState {
50public:
51 RpcState();
52 ~RpcState();
53
Steven Moreland7c5e6c22021-05-01 02:55:20 +000054 // TODO(b/182940634): combine some special transactions into one "getServerInfo" call?
Steven Morelandbdb53ab2021-05-05 17:57:41 +000055 sp<IBinder> getRootObject(const base::unique_fd& fd, const sp<RpcSession>& session);
56 status_t getMaxThreads(const base::unique_fd& fd, const sp<RpcSession>& session,
Steven Morelandf137de92021-04-24 01:54:26 +000057 size_t* maxThreadsOut);
Steven Morelandbdb53ab2021-05-05 17:57:41 +000058 status_t getSessionId(const base::unique_fd& fd, const sp<RpcSession>& session,
59 int32_t* sessionIdOut);
Steven Moreland5553ac42020-11-11 02:14:45 +000060
Steven Morelandf5174272021-05-25 00:39:28 +000061 [[nodiscard]] status_t transact(const base::unique_fd& fd, const sp<IBinder>& address,
Steven Moreland5553ac42020-11-11 02:14:45 +000062 uint32_t code, const Parcel& data,
Steven Morelandbdb53ab2021-05-05 17:57:41 +000063 const sp<RpcSession>& session, Parcel* reply, uint32_t flags);
Steven Morelandf5174272021-05-25 00:39:28 +000064 [[nodiscard]] status_t transactAddress(const base::unique_fd& fd, const RpcAddress& address,
65 uint32_t code, const Parcel& data,
66 const sp<RpcSession>& session, Parcel* reply,
67 uint32_t flags);
Steven Moreland5553ac42020-11-11 02:14:45 +000068 [[nodiscard]] status_t sendDecStrong(const base::unique_fd& fd, const RpcAddress& address);
69 [[nodiscard]] status_t getAndExecuteCommand(const base::unique_fd& fd,
Steven Morelandbdb53ab2021-05-05 17:57:41 +000070 const sp<RpcSession>& session);
Steven Moreland5553ac42020-11-11 02:14:45 +000071
72 /**
73 * Called by Parcel for outgoing binders. This implies one refcount of
74 * ownership to the outgoing binder.
75 */
Steven Morelandbdb53ab2021-05-05 17:57:41 +000076 [[nodiscard]] status_t onBinderLeaving(const sp<RpcSession>& session, const sp<IBinder>& binder,
77 RpcAddress* outAddress);
Steven Moreland5553ac42020-11-11 02:14:45 +000078
79 /**
80 * Called by Parcel for incoming binders. This either returns the refcount
81 * to the process, if this process already has one, or it takes ownership of
82 * that refcount
83 */
Steven Moreland7227c8a2021-06-02 00:24:32 +000084 [[nodiscard]] status_t onBinderEntering(const sp<RpcSession>& session,
85 const RpcAddress& address, sp<IBinder>* out);
Steven Moreland5553ac42020-11-11 02:14:45 +000086
87 size_t countBinders();
88 void dump();
89
Steven Moreland5553ac42020-11-11 02:14:45 +000090 /**
Steven Morelandbdb53ab2021-05-05 17:57:41 +000091 * Called when reading or writing data to a session fails to clean up
92 * data associated with the session in order to cleanup binders.
Steven Moreland5553ac42020-11-11 02:14:45 +000093 * Specifically, we have a strong dependency cycle, since BpBinder is
94 * OBJECT_LIFETIME_WEAK (so that onAttemptIncStrong may return true).
95 *
Steven Morelandbdb53ab2021-05-05 17:57:41 +000096 * BpBinder -> RpcSession -> RpcState
Steven Moreland5553ac42020-11-11 02:14:45 +000097 * ^-----------------------------/
98 *
99 * In the success case, eventually all refcounts should be propagated over
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000100 * the session, though this could also be called to eagerly cleanup
101 * the session.
Steven Moreland5553ac42020-11-11 02:14:45 +0000102 *
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000103 * WARNING: RpcState is responsible for calling this when the session is
Steven Moreland5553ac42020-11-11 02:14:45 +0000104 * no longer recoverable.
105 */
106 void terminate();
107
Steven Moreland659416d2021-05-11 00:47:50 +0000108private:
Steven Morelanddbe71832021-05-12 23:31:00 +0000109 // Alternative to std::vector<uint8_t> that doesn't abort on allocation failure and caps
110 // large allocations to avoid being requested from allocating too much data.
111 struct CommandData {
112 explicit CommandData(size_t size);
Steven Morelande8393342021-05-05 23:27:53 +0000113 bool valid() { return mSize == 0 || mData != nullptr; }
114 size_t size() { return mSize; }
115 uint8_t* data() { return mData.get(); }
116 uint8_t* release() { return mData.release(); }
117
118 private:
119 std::unique_ptr<uint8_t[]> mData;
120 size_t mSize;
121 };
122
Steven Moreland1e4c2b82021-05-25 01:51:31 +0000123 [[nodiscard]] status_t rpcSend(const base::unique_fd& fd, const char* what, const void* data,
124 size_t size);
125 [[nodiscard]] status_t rpcRec(const base::unique_fd& fd, const sp<RpcSession>& session,
126 const char* what, void* data, size_t size);
Steven Moreland5553ac42020-11-11 02:14:45 +0000127
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000128 [[nodiscard]] status_t waitForReply(const base::unique_fd& fd, const sp<RpcSession>& session,
129 Parcel* reply);
Steven Moreland5553ac42020-11-11 02:14:45 +0000130 [[nodiscard]] status_t processServerCommand(const base::unique_fd& fd,
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000131 const sp<RpcSession>& session,
Steven Moreland5553ac42020-11-11 02:14:45 +0000132 const RpcWireHeader& command);
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000133 [[nodiscard]] status_t processTransact(const base::unique_fd& fd, const sp<RpcSession>& session,
Steven Moreland5553ac42020-11-11 02:14:45 +0000134 const RpcWireHeader& command);
135 [[nodiscard]] status_t processTransactInternal(const base::unique_fd& fd,
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000136 const sp<RpcSession>& session,
Steven Morelandf5174272021-05-25 00:39:28 +0000137 CommandData transactionData,
138 sp<IBinder>&& targetRef);
Steven Moreland5553ac42020-11-11 02:14:45 +0000139 [[nodiscard]] status_t processDecStrong(const base::unique_fd& fd,
Steven Morelandee3f4662021-05-22 01:07:33 +0000140 const sp<RpcSession>& session,
Steven Moreland5553ac42020-11-11 02:14:45 +0000141 const RpcWireHeader& command);
142
143 struct BinderNode {
144 // Two cases:
145 // A - local binder we are serving
146 // B - remote binder, we are sending transactions to
147 wp<IBinder> binder;
148
149 // if timesSent > 0, this will be equal to binder.promote()
150 sp<IBinder> sentRef;
151
152 // Number of times we've sent this binder out of process, which
153 // translates to an implicit strong count. A client must send RPC binder
154 // socket's dec ref for each time it is sent out of process in order to
155 // deallocate it. Note, a proxy binder we are holding onto might be
156 // sent (this is important when the only remaining refcount of this
157 // binder is the one associated with a transaction sending it back to
158 // its server)
159 size_t timesSent = 0;
160
161 // Number of times we've received this binder, each time corresponds to
162 // a reference we hold over the wire (not a local incStrong/decStrong)
163 size_t timesRecd = 0;
164
165 // transaction ID, for async transactions
166 uint64_t asyncNumber = 0;
167
168 //
169 // CASE A - local binder we are serving
170 //
171
172 // async transaction queue, _only_ for local binder
173 struct AsyncTodo {
Steven Morelandf5174272021-05-25 00:39:28 +0000174 sp<IBinder> ref;
Steven Morelanddbe71832021-05-12 23:31:00 +0000175 CommandData data;
Steven Moreland5553ac42020-11-11 02:14:45 +0000176 uint64_t asyncNumber = 0;
177
178 bool operator<(const AsyncTodo& o) const {
179 return asyncNumber > /* !!! */ o.asyncNumber;
180 }
181 };
182 std::priority_queue<AsyncTodo> asyncTodo;
183
184 //
185 // CASE B - remote binder, we are sending transactions to
186 //
187
188 // (no additional data specific to remote binders)
189 };
190
191 std::mutex mNodeMutex;
192 bool mTerminated = false;
Steven Morelandbdb53ab2021-05-05 17:57:41 +0000193 // binders known by both sides of a session
Steven Moreland5553ac42020-11-11 02:14:45 +0000194 std::map<RpcAddress, BinderNode> mNodeForAddress;
195};
196
197} // namespace android