Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3d8abec5 authored by Steven Moreland's avatar Steven Moreland Committed by Automerger Merge Worker
Browse files

Merge changes from topic "revert-1707789-SWNRVZMCZA" am: c85de8c2

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/1708068

Change-Id: I3ff6605a8ee1afe295753daa1ff37e377f28363a
parents c01cd2da c85de8c2
Loading
Loading
Loading
Loading
+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);
+0 −16
Original line number Diff line number Diff line
@@ -18,9 +18,7 @@

#include "RpcState.h"

#include <android-base/scopeguard.h>
#include <binder/BpBinder.h>
#include <binder/IPCThreadState.h>
#include <binder/RpcServer.h>

#include "Debug.h"
@@ -30,8 +28,6 @@

namespace android {

using base::ScopeGuard;

RpcState::RpcState() {}
RpcState::~RpcState() {}

@@ -474,18 +470,6 @@ status_t RpcState::getAndExecuteCommand(const base::unique_fd& fd, const sp<RpcS

status_t RpcState::processServerCommand(const base::unique_fd& fd, const sp<RpcSession>& session,
                                        const RpcWireHeader& command) {
    IPCThreadState* kernelBinderState = IPCThreadState::selfOrNull();
    IPCThreadState::SpGuard spGuard{"processing binder RPC command"};
    IPCThreadState::SpGuard* origGuard;
    if (kernelBinderState != nullptr) {
        origGuard = kernelBinderState->pushGetCallingSpGuard(&spGuard);
    }
    ScopeGuard guardUnguard = [&]() {
        if (kernelBinderState != nullptr) {
            kernelBinderState->restoreGetCallingSpGuard(origGuard);
        }
    };

    switch (command.command) {
        case RPC_COMMAND_TRANSACT:
            return processTransact(fd, session, command);
+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;
+0 −2
Original line number Diff line number Diff line
@@ -55,6 +55,4 @@ interface IBinderRpcTest {
    oneway void sleepMsAsync(int ms);

    void die(boolean cleanup);

    void useKernelBinderCallingId();
}
+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;
Loading