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

Commit 74d967a8 authored by Michael Wachenschwanz's avatar Michael Wachenschwanz
Browse files

Log Binder Proxy Limit reached only once 

Bug: 79578081
Test: bit FrameworksCoreTests:android.os.BinderProxyCountingTest
Change-Id: Ia0d4148d5d9d5b57fe69b86b280fbeb7e68dca2a
parent 79ab7215

libs/binder/BpBinder.cpp

+25 −28
Original line number Original line Diff line number Diff line
@@ -46,7 +46,7 @@ uint32_t BpBinder::sBinderProxyCountHighWatermark = 2500; 
uint32_t BpBinder::sBinderProxyCountLowWatermark = 2000;

uint32_t BpBinder::sBinderProxyCountLowWatermark = 2000;





enum {

enum {

    CALLBACK_TRIGGERED_MASK = 0x80000000,   // A flag denoting that the callback has been called

    LIMIT_REACHED_MASK = 0x80000000,        // A flag denoting that the limit has been reached

    COUNTING_VALUE_MASK = 0x7FFFFFFF,       // A mask of the remaining bits for the count value

    COUNTING_VALUE_MASK = 0x7FFFFFFF,       // A mask of the remaining bits for the count value

};

};
@@ -109,36 +109,31 @@ void BpBinder::ObjectManager::kill() 
BpBinder* BpBinder::create(int32_t handle) {

BpBinder* BpBinder::create(int32_t handle) {

    int32_t trackedUid = -1;

    int32_t trackedUid = -1;

    if (sCountByUidEnabled) {

    if (sCountByUidEnabled) {

        BpBinder* out;

        trackedUid = IPCThreadState::self()->getCallingUid();

        trackedUid = IPCThreadState::self()->getCallingUid();

        AutoMutex _l(sTrackingLock);

        AutoMutex _l(sTrackingLock);

        if ((sTrackingMap[trackedUid] & COUNTING_VALUE_MASK) >= sBinderProxyCountHighWatermark) {

        uint32_t trackedValue = sTrackingMap[trackedUid];

            ALOGE("Too many binder proxy objects sent to uid %d from uid %d (over %d proxies held)",

        if (CC_UNLIKELY(trackedValue & LIMIT_REACHED_MASK)) {

                   getuid(), trackedUid, sBinderProxyCountHighWatermark);



            if (sBinderProxyThrottleCreate) {

            if (sBinderProxyThrottleCreate) {

                ALOGE("Returning Null Binder Proxy Object to uid %d", trackedUid);

                return nullptr;

                out = nullptr;

            }

        } else {

        } else {

                // increment and construct here in case callback has an async kill causing a race

            if ((trackedValue & COUNTING_VALUE_MASK) >= sBinderProxyCountHighWatermark) {

                sTrackingMap[trackedUid]++;

                ALOGE("Too many binder proxy objects sent to uid %d from uid %d (%d proxies held)",

                out = new BpBinder(handle, trackedUid);

                      getuid(), trackedUid, trackedValue);

                sTrackingMap[trackedUid] |= LIMIT_REACHED_MASK;

                if (sLimitCallback) sLimitCallback(trackedUid);

                if (sBinderProxyThrottleCreate) {

                    ALOGI("Throttling binder proxy creates from uid %d in uid %d until binder proxy"

                          " count drops below %d",

                          trackedUid, getuid(), sBinderProxyCountLowWatermark);

                    return nullptr;

                }

            }

            }



            if (sLimitCallback && !(sTrackingMap[trackedUid] & CALLBACK_TRIGGERED_MASK)) {

                sTrackingMap[trackedUid] |= CALLBACK_TRIGGERED_MASK;

                sLimitCallback(trackedUid);

        }

        }

        } else {

        sTrackingMap[trackedUid]++;

        sTrackingMap[trackedUid]++;

            out = new BpBinder(handle, trackedUid);

    }

    }



        return out;

    } else {

    return new BpBinder(handle, trackedUid);

    return new BpBinder(handle, trackedUid);

}

}

}





BpBinder::BpBinder(int32_t handle, int32_t trackedUid)

BpBinder::BpBinder(int32_t handle, int32_t trackedUid)

    : mHandle(handle)

    : mHandle(handle)
@@ -371,15 +366,17 @@ BpBinder::~BpBinder() 




    if (mTrackedUid >= 0) {

    if (mTrackedUid >= 0) {

        AutoMutex _l(sTrackingLock);

        AutoMutex _l(sTrackingLock);

        if (CC_UNLIKELY(sTrackingMap[mTrackedUid] == 0)) {

        uint32_t trackedValue = sTrackingMap[mTrackedUid];

        if (CC_UNLIKELY((trackedValue & COUNTING_VALUE_MASK) == 0)) {

            ALOGE("Unexpected Binder Proxy tracking decrement in %p handle %d\n", this, mHandle);

            ALOGE("Unexpected Binder Proxy tracking decrement in %p handle %d\n", this, mHandle);

        } else {

        } else {

            if (CC_UNLIKELY(

            if (CC_UNLIKELY(

                (sTrackingMap[mTrackedUid] & CALLBACK_TRIGGERED_MASK) &&

                (trackedValue & LIMIT_REACHED_MASK) &&

                ((sTrackingMap[mTrackedUid] & COUNTING_VALUE_MASK) <= sBinderProxyCountLowWatermark)

                ((trackedValue & COUNTING_VALUE_MASK) <= sBinderProxyCountLowWatermark)

                )) {

                )) {

                // Clear the Callback Triggered bit when crossing below the low watermark

                ALOGI("Limit reached bit reset for uid %d (fewer than %d proxies from uid %d held)",

                sTrackingMap[mTrackedUid] &= ~CALLBACK_TRIGGERED_MASK;

                                   getuid(), mTrackedUid, sBinderProxyCountLowWatermark);

                sTrackingMap[mTrackedUid] &= ~LIMIT_REACHED_MASK;

            }

            }

            if (--sTrackingMap[mTrackedUid] == 0) {

            if (--sTrackingMap[mTrackedUid] == 0) {

                sTrackingMap.erase(mTrackedUid);

                sTrackingMap.erase(mTrackedUid);