| /* |
| * Copyright (C) 2005 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #pragma once |
| |
| #include <binder/Common.h> |
| #include <binder/Parcel.h> |
| #include <binder/ProcessState.h> |
| #include <utils/Errors.h> |
| #include <utils/Vector.h> |
| |
| #if defined(_WIN32) |
| typedef int uid_t; |
| #endif |
| |
| // --------------------------------------------------------------------------- |
| namespace android { |
| |
| /** |
| * Kernel binder thread state. All operations here refer to kernel binder. This |
| * object is allocated per-thread. |
| */ |
| class IPCThreadState { |
| public: |
| using CallRestriction = ProcessState::CallRestriction; |
| |
| LIBBINDER_EXPORTED static IPCThreadState* self(); |
| LIBBINDER_EXPORTED static IPCThreadState* selfOrNull(); // self(), but won't instantiate |
| |
| // Freeze or unfreeze the binder interface to a specific process. When freezing, this method |
| // will block up to timeout_ms to process pending transactions directed to pid. Unfreeze |
| // is immediate. Transactions to processes frozen via this method won't be delivered and the |
| // driver will return BR_FROZEN_REPLY to the client sending them. After unfreeze, |
| // transactions will be delivered normally. |
| // |
| // pid: id for the process for which the binder interface is to be frozen |
| // enable: freeze (true) or unfreeze (false) |
| // timeout_ms: maximum time this function is allowed to block the caller waiting for pending |
| // binder transactions to be processed. |
| // |
| // returns: 0 in case of success, a value < 0 in case of error |
| LIBBINDER_EXPORTED static status_t freeze(pid_t pid, bool enabled, uint32_t timeout_ms); |
| |
| // Provide information about the state of a frozen process |
| LIBBINDER_EXPORTED static status_t getProcessFreezeInfo(pid_t pid, uint32_t* sync_received, |
| uint32_t* async_received); |
| |
| LIBBINDER_EXPORTED status_t clearLastError(); |
| |
| /** |
| * Returns the PID of the process which has made the current binder |
| * call. If not in a binder call, this will return getpid. |
| * |
| * Warning: oneway transactions do not receive PID. Even if you expect |
| * a transaction to be synchronous, a misbehaving client could send it |
| * as an asynchronous call and result in a 0 PID here. Additionally, if |
| * there is a race and the calling process dies, the PID may still be |
| * 0 for a synchronous call. |
| */ |
| [[nodiscard]] LIBBINDER_EXPORTED pid_t getCallingPid() const; |
| |
| /** |
| * Returns the SELinux security identifier of the process which has |
| * made the current binder call. If not in a binder call this will |
| * return nullptr. If this isn't requested with |
| * Binder::setRequestingSid, it will also return nullptr. |
| * |
| * This can't be restored once it's cleared, and it does not return the |
| * context of the current process when not in a binder call. |
| */ |
| [[nodiscard]] LIBBINDER_EXPORTED const char* getCallingSid() const; |
| |
| /** |
| * Returns the UID of the process which has made the current binder |
| * call. If not in a binder call, this will return 0. |
| */ |
| [[nodiscard]] LIBBINDER_EXPORTED uid_t getCallingUid() const; |
| |
| /** |
| * Make it an abort to rely on getCalling* for a section of |
| * execution. |
| * |
| * Usage: |
| * IPCThreadState::SpGuard guard { |
| * .address = __builtin_frame_address(0), |
| * .context = "...", |
| * }; |
| * const auto* orig = pushGetCallingSpGuard(&guard); |
| * { |
| * // will abort if you call getCalling*, unless you are |
| * // serving a nested binder transaction |
| * } |
| * restoreCallingSpGuard(orig); |
| */ |
| struct SpGuard { |
| const void* address; |
| const char* context; |
| }; |
| LIBBINDER_EXPORTED const SpGuard* pushGetCallingSpGuard(const SpGuard* guard); |
| LIBBINDER_EXPORTED void restoreGetCallingSpGuard(const SpGuard* guard); |
| /** |
| * Used internally by getCalling*. Can also be used to assert that |
| * you are in a binder context (getCalling* is valid). This is |
| * intentionally not exposed as a boolean API since code should be |
| * written to know its environment. |
| */ |
| LIBBINDER_EXPORTED void checkContextIsBinderForUse(const char* use) const; |
| |
| LIBBINDER_EXPORTED void setStrictModePolicy(int32_t policy); |
| LIBBINDER_EXPORTED int32_t getStrictModePolicy() const; |
| |
| // See Binder#setCallingWorkSourceUid in Binder.java. |
| LIBBINDER_EXPORTED int64_t setCallingWorkSourceUid(uid_t uid); |
| // Internal only. Use setCallingWorkSourceUid(uid) instead. |
| LIBBINDER_EXPORTED int64_t setCallingWorkSourceUidWithoutPropagation(uid_t uid); |
| // See Binder#getCallingWorkSourceUid in Binder.java. |
| LIBBINDER_EXPORTED uid_t getCallingWorkSourceUid() const; |
| // See Binder#clearCallingWorkSource in Binder.java. |
| LIBBINDER_EXPORTED int64_t clearCallingWorkSource(); |
| // See Binder#restoreCallingWorkSource in Binder.java. |
| LIBBINDER_EXPORTED void restoreCallingWorkSource(int64_t token); |
| LIBBINDER_EXPORTED void clearPropagateWorkSource(); |
| LIBBINDER_EXPORTED bool shouldPropagateWorkSource() const; |
| |
| LIBBINDER_EXPORTED void setLastTransactionBinderFlags(int32_t flags); |
| LIBBINDER_EXPORTED int32_t getLastTransactionBinderFlags() const; |
| |
| LIBBINDER_EXPORTED void setCallRestriction(CallRestriction restriction); |
| LIBBINDER_EXPORTED CallRestriction getCallRestriction() const; |
| |
| LIBBINDER_EXPORTED int64_t clearCallingIdentity(); |
| // Restores PID/UID (not SID) |
| LIBBINDER_EXPORTED void restoreCallingIdentity(int64_t token); |
| LIBBINDER_EXPORTED bool hasExplicitIdentity(); |
| |
| // For main functions - dangerous for libraries to use |
| LIBBINDER_EXPORTED status_t setupPolling(int* fd); |
| LIBBINDER_EXPORTED status_t handlePolledCommands(); |
| LIBBINDER_EXPORTED void flushCommands(); |
| LIBBINDER_EXPORTED bool flushIfNeeded(); |
| |
| // Adds the current thread into the binder threadpool. |
| // |
| // This is in addition to any threads which are started |
| // with startThreadPool. Libraries should not call this |
| // function, as they may be loaded into processes which |
| // try to configure the threadpool differently. |
| LIBBINDER_EXPORTED void joinThreadPool(bool isMain = true); |
| |
| // Stop the local process. |
| LIBBINDER_EXPORTED void stopProcess(bool immediate = true); |
| |
| LIBBINDER_EXPORTED status_t transact(int32_t handle, uint32_t code, const Parcel& data, |
| Parcel* reply, uint32_t flags); |
| |
| LIBBINDER_EXPORTED void incStrongHandle(int32_t handle, BpBinder* proxy); |
| LIBBINDER_EXPORTED void decStrongHandle(int32_t handle); |
| LIBBINDER_EXPORTED void incWeakHandle(int32_t handle, BpBinder* proxy); |
| LIBBINDER_EXPORTED void decWeakHandle(int32_t handle); |
| LIBBINDER_EXPORTED status_t attemptIncStrongHandle(int32_t handle); |
| LIBBINDER_EXPORTED static void expungeHandle(int32_t handle, IBinder* binder); |
| LIBBINDER_EXPORTED status_t requestDeathNotification(int32_t handle, BpBinder* proxy); |
| LIBBINDER_EXPORTED status_t clearDeathNotification(int32_t handle, BpBinder* proxy); |
| |
| LIBBINDER_EXPORTED static void shutdown(); |
| |
| // Call this to disable switching threads to background scheduling when |
| // receiving incoming IPC calls. This is specifically here for the |
| // Android system process, since it expects to have background apps calling |
| // in to it but doesn't want to acquire locks in its services while in |
| // the background. |
| LIBBINDER_EXPORTED static void disableBackgroundScheduling(bool disable); |
| LIBBINDER_EXPORTED bool backgroundSchedulingDisabled(); |
| |
| // Call blocks until the number of executing binder threads is less than |
| // the maximum number of binder threads threads allowed for this process. |
| LIBBINDER_EXPORTED void blockUntilThreadAvailable(); |
| |
| // Service manager registration |
| LIBBINDER_EXPORTED void setTheContextObject(const sp<BBinder>& obj); |
| |
| // WARNING: DO NOT USE THIS API |
| // |
| // Returns a pointer to the stack from the last time a transaction |
| // was initiated by the kernel. Used to compare when making nested |
| // calls between multiple different transports. |
| LIBBINDER_EXPORTED const void* getServingStackPointer() const; |
| |
| // The work source represents the UID of the process we should attribute the transaction |
| // to. We use -1 to specify that the work source was not set using #setWorkSource. |
| // |
| // This constant needs to be kept in sync with Binder.UNSET_WORKSOURCE from the Java |
| // side. |
| LIBBINDER_EXPORTED static const int32_t kUnsetWorkSource = -1; |
| |
| private: |
| IPCThreadState(); |
| ~IPCThreadState(); |
| |
| status_t sendReply(const Parcel& reply, uint32_t flags); |
| status_t waitForResponse(Parcel* reply, status_t* acquireResult = nullptr); |
| status_t talkWithDriver(bool doReceive = true); |
| status_t writeTransactionData(int32_t cmd, uint32_t binderFlags, int32_t handle, uint32_t code, |
| const Parcel& data, status_t* statusBuffer); |
| status_t getAndExecuteCommand(); |
| status_t executeCommand(int32_t command); |
| void processPendingDerefs(); |
| void processPostWriteDerefs(); |
| |
| void clearCaller(); |
| |
| static void threadDestructor(void *st); |
| static void freeBuffer(const uint8_t* data, size_t dataSize, const binder_size_t* objects, |
| size_t objectsSize); |
| static void logExtendedError(); |
| |
| const sp<ProcessState> mProcess; |
| Vector<BBinder*> mPendingStrongDerefs; |
| Vector<RefBase::weakref_type*> mPendingWeakDerefs; |
| Vector<RefBase*> mPostWriteStrongDerefs; |
| Vector<RefBase::weakref_type*> mPostWriteWeakDerefs; |
| Parcel mIn; |
| Parcel mOut; |
| status_t mLastError; |
| const void* mServingStackPointer; |
| const SpGuard* mServingStackPointerGuard; |
| pid_t mCallingPid; |
| const char* mCallingSid; |
| uid_t mCallingUid; |
| // The UID of the process who is responsible for this transaction. |
| // This is used for resource attribution. |
| int32_t mWorkSource; |
| // Whether the work source should be propagated. |
| bool mPropagateWorkSource; |
| bool mIsLooper; |
| bool mIsFlushing; |
| bool mHasExplicitIdentity; |
| int32_t mStrictModePolicy; |
| int32_t mLastTransactionBinderFlags; |
| CallRestriction mCallRestriction; |
| }; |
| |
| } // namespace android |
| |
| // --------------------------------------------------------------------------- |