Merge "Log Binder Proxy Limit reached only once" into pi-dev (c61c0c11) · Commits · e / os / android_frameworks_native

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);