Merge changes Id824b7df,I4cba7ab9 into sc-dev am: b7fb09b894 (b0aefd2d) · Commits · e / os / android_frameworks_native

libs/binder/IPCThreadState.cpp

+9 −35

Original line number	Diff line number	Diff line
		@@ -366,45 +366,19 @@ status_t IPCThreadState::clearLastError()

		pid_t IPCThreadState::getCallingPid() const
		{
		checkContextIsBinderForUse(__func__);
		return mCallingPid;
		}

		const char* IPCThreadState::getCallingSid() const
		{
		checkContextIsBinderForUse(__func__);
		return mCallingSid;
		}

		uid_t IPCThreadState::getCallingUid() const
		{
		checkContextIsBinderForUse(__func__);
		return mCallingUid;
		}

		IPCThreadState::SpGuard* IPCThreadState::pushGetCallingSpGuard(SpGuard* guard) {
		SpGuard* orig = mServingStackPointerGuard;
		mServingStackPointerGuard = guard;
		return orig;
		}

		void IPCThreadState::restoreGetCallingSpGuard(SpGuard* guard) {
		mServingStackPointerGuard = guard;
		}

		void IPCThreadState::checkContextIsBinderForUse(const char* use) const {
		if (mServingStackPointerGuard == nullptr) return;

		if (!mServingStackPointer \|\| mServingStackPointerGuard < mServingStackPointer) {
		LOG_ALWAYS_FATAL("In context %s, %s does not make sense.",
		mServingStackPointerGuard->context, use);
		}

		// in the case mServingStackPointer is deeper in the stack than the guard,
		// we must be serving a binder transaction (maybe nested). This is a binder
		// context, so we don't abort
		}

		int64_t IPCThreadState::clearCallingIdentity()
		{
		// ignore mCallingSid for legacy reasons
		@@ -875,13 +849,13 @@ status_t IPCThreadState::clearDeathNotification(int32_t handle, BpBinder* proxy)
		IPCThreadState::IPCThreadState()
		: mProcess(ProcessState::self()),
		mServingStackPointer(nullptr),
		mServingStackPointerGuard(nullptr),
		mWorkSource(kUnsetWorkSource),
		mPropagateWorkSource(false),
		mIsLooper(false),
		mStrictModePolicy(0),
		mLastTransactionBinderFlags(0),
		mCallRestriction(mProcess->mCallRestriction) {
		mCallRestriction(mProcess->mCallRestriction)
		{
		pthread_setspecific(gTLS, this);
		clearCaller();
		mIn.setDataCapacity(256);

libs/binder/include/binder/IPCThreadState.h

+0 −27

Original line number	Diff line number	Diff line
		@@ -81,32 +81,6 @@ public:
		*/
		uid_t getCallingUid() const;

		/**
		* Make it an abort to rely on getCalling* for a section of
		* execution.
		*
		* Usage:
		* IPCThreadState::SpGuard guard { "..." };
		* auto* orig = pushGetCallingSpGuard(&guard);
		* {
		* // will abort if you call getCalling*, unless you are
		* // serving a nested binder transaction
		* }
		* restoreCallingSpGuard(orig);
		*/
		struct SpGuard {
		const char* context;
		};
		SpGuard* pushGetCallingSpGuard(SpGuard* guard);
		void restoreGetCallingSpGuard(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.
		*/
		void checkContextIsBinderForUse(const char* use) const;

		void setStrictModePolicy(int32_t policy);
		int32_t getStrictModePolicy() const;

		@@ -229,7 +203,6 @@ private:
		Parcel mOut;
		status_t mLastError;
		const void* mServingStackPointer;
		SpGuard* mServingStackPointerGuard;
		pid_t mCallingPid;
		const char* mCallingSid;
		uid_t mCallingUid;

libs/binder/tests/binderLibTest.cpp

+0 −36

Original line number	Diff line number	Diff line
		@@ -73,7 +73,6 @@ enum BinderLibTestTranscationCode {
		BINDER_LIB_TEST_REGISTER_SERVER,
		BINDER_LIB_TEST_ADD_SERVER,
		BINDER_LIB_TEST_ADD_POLL_SERVER,
		BINDER_LIB_TEST_USE_CALLING_GUARD_TRANSACTION,
		BINDER_LIB_TEST_CALL_BACK,
		BINDER_LIB_TEST_CALL_BACK_VERIFY_BUF,
		BINDER_LIB_TEST_DELAYED_CALL_BACK,
		@@ -605,24 +604,6 @@ TEST_F(BinderLibTest, CallBack)
		EXPECT_THAT(callBack->getResult(), StatusEq(NO_ERROR));
		}

		TEST_F(BinderLibTest, NoBinderCallContextGuard) {
		IPCThreadState::SpGuard spGuard{"NoBinderCallContext"};
		IPCThreadState::SpGuard *origGuard = IPCThreadState::self()->pushGetCallingSpGuard(&spGuard);

		// yes, this test uses threads, but it's careful and uses fork in addServer
		EXPECT_DEATH({ IPCThreadState::self()->getCallingPid(); },
		"In context NoBinderCallContext, getCallingPid does not make sense.");

		IPCThreadState::self()->restoreGetCallingSpGuard(origGuard);
		}

		TEST_F(BinderLibTest, BinderCallContextGuard) {
		sp<IBinder> binder = addServer();
		Parcel data, reply;
		EXPECT_THAT(binder->transact(BINDER_LIB_TEST_USE_CALLING_GUARD_TRANSACTION, data, &reply),
		StatusEq(DEAD_OBJECT));
		}

		TEST_F(BinderLibTest, AddServer)
		{
		sp<IBinder> server = addServer();
		@@ -1281,18 +1262,6 @@ class BinderLibTestService : public BBinder
		pthread_mutex_unlock(&m_serverWaitMutex);
		return ret;
		}
		case BINDER_LIB_TEST_USE_CALLING_GUARD_TRANSACTION: {
		IPCThreadState::SpGuard spGuard{"GuardInBinderTransaction"};
		IPCThreadState::SpGuard *origGuard =
		IPCThreadState::self()->pushGetCallingSpGuard(&spGuard);

		// if the guard works, this should abort
		(void)IPCThreadState::self()->getCallingPid();

		IPCThreadState::self()->restoreGetCallingSpGuard(origGuard);
		return NO_ERROR;
		}

		case BINDER_LIB_TEST_GETPID:
		reply->writeInt32(getpid());
		return NO_ERROR;
		@@ -1520,11 +1489,6 @@ int run_server(int index, int readypipefd, bool usePoll)
		{
		binderLibTestServiceName += String16(binderserversuffix);

		// Testing to make sure that calls that we are serving can use getCallin*
		// even though we don't here.
		IPCThreadState::SpGuard spGuard{"main server thread"};
		(void)IPCThreadState::self()->pushGetCallingSpGuard(&spGuard);

		status_t ret;
		sp<IServiceManager> sm = defaultServiceManager();
		BinderLibTestService* testServicePtr;