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 #pragma once 17 18 #include <android-base/unique_fd.h> 19 #include <binder/IBinder.h> 20 #include <binder/Parcel.h> 21 #include <binder/RpcSession.h> 22 23 #include <map> 24 #include <optional> 25 #include <queue> 26 27 namespace android { 28 29 struct 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 47 * RpcSession 48 */ 49 class RpcState { 50 public: 51 RpcState(); 52 ~RpcState(); 53 54 // TODO(b/182940634): combine some special transactions into one "getServerInfo" call? 55 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, 57 size_t* maxThreadsOut); 58 status_t getSessionId(const base::unique_fd& fd, const sp<RpcSession>& session, 59 int32_t* sessionIdOut); 60 61 [[nodiscard]] status_t transact(const base::unique_fd& fd, const RpcAddress& address, 62 uint32_t code, const Parcel& data, 63 const sp<RpcSession>& session, Parcel* reply, uint32_t flags); 64 [[nodiscard]] status_t sendDecStrong(const base::unique_fd& fd, const RpcAddress& address); 65 [[nodiscard]] status_t getAndExecuteCommand(const base::unique_fd& fd, 66 const sp<RpcSession>& session); 67 68 /** 69 * Called by Parcel for outgoing binders. This implies one refcount of 70 * ownership to the outgoing binder. 71 */ 72 [[nodiscard]] status_t onBinderLeaving(const sp<RpcSession>& session, const sp<IBinder>& binder, 73 RpcAddress* outAddress); 74 75 /** 76 * Called by Parcel for incoming binders. This either returns the refcount 77 * to the process, if this process already has one, or it takes ownership of 78 * that refcount 79 */ 80 sp<IBinder> onBinderEntering(const sp<RpcSession>& session, const RpcAddress& address); 81 82 size_t countBinders(); 83 void dump(); 84 85 private: 86 /** 87 * Called when reading or writing data to a session fails to clean up 88 * data associated with the session in order to cleanup binders. 89 * Specifically, we have a strong dependency cycle, since BpBinder is 90 * OBJECT_LIFETIME_WEAK (so that onAttemptIncStrong may return true). 91 * 92 * BpBinder -> RpcSession -> RpcState 93 * ^-----------------------------/ 94 * 95 * In the success case, eventually all refcounts should be propagated over 96 * the session, though this could also be called to eagerly cleanup 97 * the session. 98 * 99 * WARNING: RpcState is responsible for calling this when the session is 100 * no longer recoverable. 101 */ 102 void terminate(); 103 104 // Alternative to std::vector<uint8_t> that doesn't abort on allocation failure and caps 105 // large allocations to avoid being requested from allocating too much data. 106 struct CommandData { 107 explicit CommandData(size_t size); validCommandData108 bool valid() { return mSize == 0 || mData != nullptr; } sizeCommandData109 size_t size() { return mSize; } dataCommandData110 uint8_t* data() { return mData.get(); } releaseCommandData111 uint8_t* release() { return mData.release(); } 112 113 private: 114 std::unique_ptr<uint8_t[]> mData; 115 size_t mSize; 116 }; 117 118 [[nodiscard]] bool rpcSend(const base::unique_fd& fd, const char* what, const void* data, 119 size_t size); 120 [[nodiscard]] bool rpcRec(const base::unique_fd& fd, const char* what, void* data, size_t size); 121 122 [[nodiscard]] status_t waitForReply(const base::unique_fd& fd, const sp<RpcSession>& session, 123 Parcel* reply); 124 [[nodiscard]] status_t processServerCommand(const base::unique_fd& fd, 125 const sp<RpcSession>& session, 126 const RpcWireHeader& command); 127 [[nodiscard]] status_t processTransact(const base::unique_fd& fd, const sp<RpcSession>& session, 128 const RpcWireHeader& command); 129 [[nodiscard]] status_t processTransactInternal(const base::unique_fd& fd, 130 const sp<RpcSession>& session, 131 CommandData transactionData); 132 [[nodiscard]] status_t processDecStrong(const base::unique_fd& fd, 133 const RpcWireHeader& command); 134 135 struct BinderNode { 136 // Two cases: 137 // A - local binder we are serving 138 // B - remote binder, we are sending transactions to 139 wp<IBinder> binder; 140 141 // if timesSent > 0, this will be equal to binder.promote() 142 sp<IBinder> sentRef; 143 144 // Number of times we've sent this binder out of process, which 145 // translates to an implicit strong count. A client must send RPC binder 146 // socket's dec ref for each time it is sent out of process in order to 147 // deallocate it. Note, a proxy binder we are holding onto might be 148 // sent (this is important when the only remaining refcount of this 149 // binder is the one associated with a transaction sending it back to 150 // its server) 151 size_t timesSent = 0; 152 153 // Number of times we've received this binder, each time corresponds to 154 // a reference we hold over the wire (not a local incStrong/decStrong) 155 size_t timesRecd = 0; 156 157 // transaction ID, for async transactions 158 uint64_t asyncNumber = 0; 159 160 // 161 // CASE A - local binder we are serving 162 // 163 164 // async transaction queue, _only_ for local binder 165 struct AsyncTodo { 166 CommandData data; 167 uint64_t asyncNumber = 0; 168 169 bool operator<(const AsyncTodo& o) const { 170 return asyncNumber > /* !!! */ o.asyncNumber; 171 } 172 }; 173 std::priority_queue<AsyncTodo> asyncTodo; 174 175 // 176 // CASE B - remote binder, we are sending transactions to 177 // 178 179 // (no additional data specific to remote binders) 180 }; 181 182 std::mutex mNodeMutex; 183 bool mTerminated = false; 184 // binders known by both sides of a session 185 std::map<RpcAddress, BinderNode> mNodeForAddress; 186 }; 187 188 } // namespace android 189