blob: 74ffde217524b337475f6e20268d2390d3cde2ba [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2005 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "BpBinder"
18//#define LOG_NDEBUG 0
19
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070020#include <binder/BpBinder.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070022#include <binder/IPCThreadState.h>
Dianne Hackborn23eb1e22015-10-07 17:35:27 -070023#include <binder/IResultReceiver.h>
Steven Moreland6e5a7752019-08-05 20:30:14 -070024#include <binder/Stability.h>
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -070025#include <cutils/compiler.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080026#include <utils/Log.h>
27
28#include <stdio.h>
29
Steve Block6807e592011-10-20 11:56:00 +010030//#undef ALOGV
31//#define ALOGV(...) fprintf(stderr, __VA_ARGS__)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080032
33namespace android {
34
35// ---------------------------------------------------------------------------
36
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -070037Mutex BpBinder::sTrackingLock;
38std::unordered_map<int32_t,uint32_t> BpBinder::sTrackingMap;
39int BpBinder::sNumTrackedUids = 0;
40std::atomic_bool BpBinder::sCountByUidEnabled(false);
41binder_proxy_limit_callback BpBinder::sLimitCallback;
42bool BpBinder::sBinderProxyThrottleCreate = false;
43
44// Arbitrarily high value that probably distinguishes a bad behaving app
45uint32_t BpBinder::sBinderProxyCountHighWatermark = 2500;
46// Another arbitrary value a binder count needs to drop below before another callback will be called
47uint32_t BpBinder::sBinderProxyCountLowWatermark = 2000;
48
49enum {
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -070050 LIMIT_REACHED_MASK = 0x80000000, // A flag denoting that the limit has been reached
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -070051 COUNTING_VALUE_MASK = 0x7FFFFFFF, // A mask of the remaining bits for the count value
52};
53
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080054BpBinder::ObjectManager::ObjectManager()
55{
56}
57
58BpBinder::ObjectManager::~ObjectManager()
59{
60 kill();
61}
62
63void BpBinder::ObjectManager::attach(
64 const void* objectID, void* object, void* cleanupCookie,
65 IBinder::object_cleanup_func func)
66{
67 entry_t e;
68 e.object = object;
69 e.cleanupCookie = cleanupCookie;
70 e.func = func;
71
72 if (mObjects.indexOfKey(objectID) >= 0) {
Steve Blocke6f43dd2012-01-06 19:20:56 +000073 ALOGE("Trying to attach object ID %p to binder ObjectManager %p with object %p, but object ID already in use",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080074 objectID, this, object);
75 return;
76 }
77
78 mObjects.add(objectID, e);
79}
80
81void* BpBinder::ObjectManager::find(const void* objectID) const
82{
83 const ssize_t i = mObjects.indexOfKey(objectID);
Yi Kongfdd8da92018-06-07 17:52:27 -070084 if (i < 0) return nullptr;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080085 return mObjects.valueAt(i).object;
86}
87
88void BpBinder::ObjectManager::detach(const void* objectID)
89{
90 mObjects.removeItem(objectID);
91}
92
93void BpBinder::ObjectManager::kill()
94{
95 const size_t N = mObjects.size();
Mark Salyzynd4ecccf2014-05-30 16:35:57 -070096 ALOGV("Killing %zu objects in manager %p", N, this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080097 for (size_t i=0; i<N; i++) {
98 const entry_t& e = mObjects.valueAt(i);
Yi Kongfdd8da92018-06-07 17:52:27 -070099 if (e.func != nullptr) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800100 e.func(mObjects.keyAt(i), e.object, e.cleanupCookie);
101 }
102 }
103
104 mObjects.clear();
105}
106
107// ---------------------------------------------------------------------------
108
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700109
110BpBinder* BpBinder::create(int32_t handle) {
111 int32_t trackedUid = -1;
112 if (sCountByUidEnabled) {
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700113 trackedUid = IPCThreadState::self()->getCallingUid();
114 AutoMutex _l(sTrackingLock);
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700115 uint32_t trackedValue = sTrackingMap[trackedUid];
116 if (CC_UNLIKELY(trackedValue & LIMIT_REACHED_MASK)) {
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700117 if (sBinderProxyThrottleCreate) {
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700118 return nullptr;
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700119 }
120 } else {
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700121 if ((trackedValue & COUNTING_VALUE_MASK) >= sBinderProxyCountHighWatermark) {
122 ALOGE("Too many binder proxy objects sent to uid %d from uid %d (%d proxies held)",
123 getuid(), trackedUid, trackedValue);
124 sTrackingMap[trackedUid] |= LIMIT_REACHED_MASK;
125 if (sLimitCallback) sLimitCallback(trackedUid);
126 if (sBinderProxyThrottleCreate) {
127 ALOGI("Throttling binder proxy creates from uid %d in uid %d until binder proxy"
128 " count drops below %d",
129 trackedUid, getuid(), sBinderProxyCountLowWatermark);
130 return nullptr;
131 }
132 }
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700133 }
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700134 sTrackingMap[trackedUid]++;
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700135 }
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700136 return new BpBinder(handle, trackedUid);
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700137}
138
139BpBinder::BpBinder(int32_t handle, int32_t trackedUid)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800140 : mHandle(handle)
141 , mAlive(1)
142 , mObitsSent(0)
Yi Kongfdd8da92018-06-07 17:52:27 -0700143 , mObituaries(nullptr)
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700144 , mTrackedUid(trackedUid)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800145{
Steve Block6807e592011-10-20 11:56:00 +0100146 ALOGV("Creating BpBinder %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800147
148 extendObjectLifetime(OBJECT_LIFETIME_WEAK);
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700149 IPCThreadState::self()->incWeakHandle(handle, this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800150}
151
Steven Moreland85180c02019-07-16 14:24:20 -0700152int32_t BpBinder::handle() const {
153 return mHandle;
154}
155
Mathias Agopian83c04462009-05-22 19:00:22 -0700156bool BpBinder::isDescriptorCached() const {
157 Mutex::Autolock _l(mLock);
158 return mDescriptorCache.size() ? true : false;
159}
160
161const String16& BpBinder::getInterfaceDescriptor() const
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800162{
Mathias Agopian83c04462009-05-22 19:00:22 -0700163 if (isDescriptorCached() == false) {
164 Parcel send, reply;
165 // do the IPC without a lock held.
166 status_t err = const_cast<BpBinder*>(this)->transact(
167 INTERFACE_TRANSACTION, send, &reply);
168 if (err == NO_ERROR) {
169 String16 res(reply.readString16());
170 Mutex::Autolock _l(mLock);
171 // mDescriptorCache could have been assigned while the lock was
172 // released.
173 if (mDescriptorCache.size() == 0)
174 mDescriptorCache = res;
175 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800176 }
Mark Salyzynd4ecccf2014-05-30 16:35:57 -0700177
Mathias Agopian83c04462009-05-22 19:00:22 -0700178 // we're returning a reference to a non-static object here. Usually this
Mark Salyzynd4ecccf2014-05-30 16:35:57 -0700179 // is not something smart to do, however, with binder objects it is
Mathias Agopian83c04462009-05-22 19:00:22 -0700180 // (usually) safe because they are reference-counted.
Mark Salyzynd4ecccf2014-05-30 16:35:57 -0700181
Mathias Agopian83c04462009-05-22 19:00:22 -0700182 return mDescriptorCache;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800183}
184
185bool BpBinder::isBinderAlive() const
186{
187 return mAlive != 0;
188}
189
190status_t BpBinder::pingBinder()
191{
192 Parcel send;
193 Parcel reply;
Steven Moreland6e69d652019-07-10 14:17:55 -0700194 return transact(PING_TRANSACTION, send, &reply);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800195}
196
197status_t BpBinder::dump(int fd, const Vector<String16>& args)
198{
199 Parcel send;
200 Parcel reply;
201 send.writeFileDescriptor(fd);
202 const size_t numArgs = args.size();
203 send.writeInt32(numArgs);
204 for (size_t i = 0; i < numArgs; i++) {
205 send.writeString16(args[i]);
206 }
207 status_t err = transact(DUMP_TRANSACTION, send, &reply);
208 return err;
209}
210
Jiyong Parkb86c8662018-10-29 23:01:57 +0900211// NOLINTNEXTLINE(google-default-arguments)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800212status_t BpBinder::transact(
213 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
214{
215 // Once a binder has died, it will never come back to life.
216 if (mAlive) {
Steven Moreland6e5a7752019-08-05 20:30:14 -0700217 // user transactions require a given stability level
218 if (code >= FIRST_CALL_TRANSACTION && code <= LAST_CALL_TRANSACTION) {
219 using android::internal::Stability;
220
221 auto stability = Stability::get(this);
222
223 if (CC_UNLIKELY(!Stability::check(stability, Stability::kLocalStability))) {
224 return BAD_TYPE;
225 }
226 }
227
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800228 status_t status = IPCThreadState::self()->transact(
229 mHandle, code, data, reply, flags);
230 if (status == DEAD_OBJECT) mAlive = 0;
Steven Morelanda86a3562019-08-01 23:28:34 +0000231
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800232 return status;
233 }
234
235 return DEAD_OBJECT;
236}
237
Jiyong Parkb86c8662018-10-29 23:01:57 +0900238// NOLINTNEXTLINE(google-default-arguments)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800239status_t BpBinder::linkToDeath(
240 const sp<DeathRecipient>& recipient, void* cookie, uint32_t flags)
241{
242 Obituary ob;
243 ob.recipient = recipient;
244 ob.cookie = cookie;
245 ob.flags = flags;
246
Yi Kongfdd8da92018-06-07 17:52:27 -0700247 LOG_ALWAYS_FATAL_IF(recipient == nullptr,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800248 "linkToDeath(): recipient must be non-NULL");
249
250 {
251 AutoMutex _l(mLock);
252
253 if (!mObitsSent) {
254 if (!mObituaries) {
255 mObituaries = new Vector<Obituary>;
256 if (!mObituaries) {
257 return NO_MEMORY;
258 }
Steve Block6807e592011-10-20 11:56:00 +0100259 ALOGV("Requesting death notification: %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800260 getWeakRefs()->incWeak(this);
261 IPCThreadState* self = IPCThreadState::self();
262 self->requestDeathNotification(mHandle, this);
263 self->flushCommands();
264 }
265 ssize_t res = mObituaries->add(ob);
266 return res >= (ssize_t)NO_ERROR ? (status_t)NO_ERROR : res;
267 }
268 }
269
270 return DEAD_OBJECT;
271}
272
Jiyong Parkb86c8662018-10-29 23:01:57 +0900273// NOLINTNEXTLINE(google-default-arguments)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800274status_t BpBinder::unlinkToDeath(
275 const wp<DeathRecipient>& recipient, void* cookie, uint32_t flags,
276 wp<DeathRecipient>* outRecipient)
277{
278 AutoMutex _l(mLock);
279
280 if (mObitsSent) {
281 return DEAD_OBJECT;
282 }
283
284 const size_t N = mObituaries ? mObituaries->size() : 0;
285 for (size_t i=0; i<N; i++) {
286 const Obituary& obit = mObituaries->itemAt(i);
287 if ((obit.recipient == recipient
Yi Kongfdd8da92018-06-07 17:52:27 -0700288 || (recipient == nullptr && obit.cookie == cookie))
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800289 && obit.flags == flags) {
Yi Kongfdd8da92018-06-07 17:52:27 -0700290 if (outRecipient != nullptr) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800291 *outRecipient = mObituaries->itemAt(i).recipient;
292 }
293 mObituaries->removeAt(i);
294 if (mObituaries->size() == 0) {
Steve Block6807e592011-10-20 11:56:00 +0100295 ALOGV("Clearing death notification: %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800296 IPCThreadState* self = IPCThreadState::self();
297 self->clearDeathNotification(mHandle, this);
298 self->flushCommands();
299 delete mObituaries;
Yi Kongfdd8da92018-06-07 17:52:27 -0700300 mObituaries = nullptr;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800301 }
302 return NO_ERROR;
303 }
304 }
305
306 return NAME_NOT_FOUND;
307}
308
309void BpBinder::sendObituary()
310{
Steve Block6807e592011-10-20 11:56:00 +0100311 ALOGV("Sending obituary for proxy %p handle %d, mObitsSent=%s\n",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800312 this, mHandle, mObitsSent ? "true" : "false");
313
314 mAlive = 0;
315 if (mObitsSent) return;
316
317 mLock.lock();
318 Vector<Obituary>* obits = mObituaries;
Yi Kongfdd8da92018-06-07 17:52:27 -0700319 if(obits != nullptr) {
Steve Block6807e592011-10-20 11:56:00 +0100320 ALOGV("Clearing sent death notification: %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800321 IPCThreadState* self = IPCThreadState::self();
322 self->clearDeathNotification(mHandle, this);
323 self->flushCommands();
Yi Kongfdd8da92018-06-07 17:52:27 -0700324 mObituaries = nullptr;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800325 }
326 mObitsSent = 1;
327 mLock.unlock();
328
Mark Salyzynd4ecccf2014-05-30 16:35:57 -0700329 ALOGV("Reporting death of proxy %p for %zu recipients\n",
330 this, obits ? obits->size() : 0U);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800331
Yi Kongfdd8da92018-06-07 17:52:27 -0700332 if (obits != nullptr) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800333 const size_t N = obits->size();
334 for (size_t i=0; i<N; i++) {
335 reportOneDeath(obits->itemAt(i));
336 }
337
338 delete obits;
339 }
340}
341
342void BpBinder::reportOneDeath(const Obituary& obit)
343{
344 sp<DeathRecipient> recipient = obit.recipient.promote();
Steve Block6807e592011-10-20 11:56:00 +0100345 ALOGV("Reporting death to recipient: %p\n", recipient.get());
Yi Kongfdd8da92018-06-07 17:52:27 -0700346 if (recipient == nullptr) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800347
348 recipient->binderDied(this);
349}
350
351
352void BpBinder::attachObject(
353 const void* objectID, void* object, void* cleanupCookie,
354 object_cleanup_func func)
355{
356 AutoMutex _l(mLock);
Steve Block6807e592011-10-20 11:56:00 +0100357 ALOGV("Attaching object %p to binder %p (manager=%p)", object, this, &mObjects);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800358 mObjects.attach(objectID, object, cleanupCookie, func);
359}
360
361void* BpBinder::findObject(const void* objectID) const
362{
363 AutoMutex _l(mLock);
364 return mObjects.find(objectID);
365}
366
367void BpBinder::detachObject(const void* objectID)
368{
369 AutoMutex _l(mLock);
370 mObjects.detach(objectID);
371}
372
373BpBinder* BpBinder::remoteBinder()
374{
375 return this;
376}
377
378BpBinder::~BpBinder()
379{
Steve Block6807e592011-10-20 11:56:00 +0100380 ALOGV("Destroying BpBinder %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800381
382 IPCThreadState* ipc = IPCThreadState::self();
383
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700384 if (mTrackedUid >= 0) {
385 AutoMutex _l(sTrackingLock);
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700386 uint32_t trackedValue = sTrackingMap[mTrackedUid];
387 if (CC_UNLIKELY((trackedValue & COUNTING_VALUE_MASK) == 0)) {
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700388 ALOGE("Unexpected Binder Proxy tracking decrement in %p handle %d\n", this, mHandle);
389 } else {
390 if (CC_UNLIKELY(
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700391 (trackedValue & LIMIT_REACHED_MASK) &&
392 ((trackedValue & COUNTING_VALUE_MASK) <= sBinderProxyCountLowWatermark)
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700393 )) {
Michael Wachenschwanz74d967a2018-05-15 15:03:57 -0700394 ALOGI("Limit reached bit reset for uid %d (fewer than %d proxies from uid %d held)",
395 getuid(), mTrackedUid, sBinderProxyCountLowWatermark);
396 sTrackingMap[mTrackedUid] &= ~LIMIT_REACHED_MASK;
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700397 }
398 if (--sTrackingMap[mTrackedUid] == 0) {
399 sTrackingMap.erase(mTrackedUid);
400 }
401 }
402 }
403
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800404 if (ipc) {
405 ipc->expungeHandle(mHandle, this);
406 ipc->decWeakHandle(mHandle);
407 }
408}
409
410void BpBinder::onFirstRef()
411{
Steve Block6807e592011-10-20 11:56:00 +0100412 ALOGV("onFirstRef BpBinder %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800413 IPCThreadState* ipc = IPCThreadState::self();
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700414 if (ipc) ipc->incStrongHandle(mHandle, this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800415}
416
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800417void BpBinder::onLastStrongRef(const void* /*id*/)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800418{
Steve Block6807e592011-10-20 11:56:00 +0100419 ALOGV("onLastStrongRef BpBinder %p handle %d\n", this, mHandle);
420 IF_ALOGV() {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800421 printRefs();
422 }
423 IPCThreadState* ipc = IPCThreadState::self();
424 if (ipc) ipc->decStrongHandle(mHandle);
Steven Moreland80d23932019-06-07 12:43:27 -0700425
426 mLock.lock();
427 Vector<Obituary>* obits = mObituaries;
428 if(obits != nullptr) {
429 if (!obits->isEmpty()) {
430 ALOGI("onLastStrongRef automatically unlinking death recipients");
431 }
432
433 if (ipc) ipc->clearDeathNotification(mHandle, this);
434 mObituaries = nullptr;
435 }
436 mLock.unlock();
437
438 if (obits != nullptr) {
439 // XXX Should we tell any remaining DeathRecipient
440 // objects that the last strong ref has gone away, so they
441 // are no longer linked?
442 delete obits;
443 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800444}
445
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800446bool BpBinder::onIncStrongAttempted(uint32_t /*flags*/, const void* /*id*/)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800447{
Steve Block6807e592011-10-20 11:56:00 +0100448 ALOGV("onIncStrongAttempted BpBinder %p handle %d\n", this, mHandle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800449 IPCThreadState* ipc = IPCThreadState::self();
450 return ipc ? ipc->attemptIncStrongHandle(mHandle) == NO_ERROR : false;
451}
452
Michael Wachenschwanzd296d0c2017-08-15 00:57:14 -0700453uint32_t BpBinder::getBinderProxyCount(uint32_t uid)
454{
455 AutoMutex _l(sTrackingLock);
456 auto it = sTrackingMap.find(uid);
457 if (it != sTrackingMap.end()) {
458 return it->second & COUNTING_VALUE_MASK;
459 }
460 return 0;
461}
462
463void BpBinder::getCountByUid(Vector<uint32_t>& uids, Vector<uint32_t>& counts)
464{
465 AutoMutex _l(sTrackingLock);
466 uids.setCapacity(sTrackingMap.size());
467 counts.setCapacity(sTrackingMap.size());
468 for (const auto& it : sTrackingMap) {
469 uids.push_back(it.first);
470 counts.push_back(it.second & COUNTING_VALUE_MASK);
471 }
472}
473
474void BpBinder::enableCountByUid() { sCountByUidEnabled.store(true); }
475void BpBinder::disableCountByUid() { sCountByUidEnabled.store(false); }
476void BpBinder::setCountByUidEnabled(bool enable) { sCountByUidEnabled.store(enable); }
477
478void BpBinder::setLimitCallback(binder_proxy_limit_callback cb) {
479 AutoMutex _l(sTrackingLock);
480 sLimitCallback = cb;
481}
482
483void BpBinder::setBinderProxyCountWatermarks(int high, int low) {
484 AutoMutex _l(sTrackingLock);
485 sBinderProxyCountHighWatermark = high;
486 sBinderProxyCountLowWatermark = low;
487}
488
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800489// ---------------------------------------------------------------------------
490
491}; // namespace android