1/* 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 20#include <binder/BpBinder.h> 21 22#include <binder/IPCThreadState.h> 23#include <binder/IResultReceiver.h> 24#include <utils/Log.h> 25 26#include <stdio.h> 27 28//#undef ALOGV 29//#define ALOGV(...) fprintf(stderr, __VA_ARGS__) 30 31namespace android { 32 33// --------------------------------------------------------------------------- 34 35BpBinder::ObjectManager::ObjectManager() 36{ 37} 38 39BpBinder::ObjectManager::~ObjectManager() 40{ 41 kill(); 42} 43 44void BpBinder::ObjectManager::attach( 45 const void* objectID, void* object, void* cleanupCookie, 46 IBinder::object_cleanup_func func) 47{ 48 entry_t e; 49 e.object = object; 50 e.cleanupCookie = cleanupCookie; 51 e.func = func; 52 53 if (mObjects.indexOfKey(objectID) >= 0) { 54 ALOGE("Trying to attach object ID %p to binder ObjectManager %p with object %p, but object ID already in use", 55 objectID, this, object); 56 return; 57 } 58 59 mObjects.add(objectID, e); 60} 61 62void* BpBinder::ObjectManager::find(const void* objectID) const 63{ 64 const ssize_t i = mObjects.indexOfKey(objectID); 65 if (i < 0) return NULL; 66 return mObjects.valueAt(i).object; 67} 68 69void BpBinder::ObjectManager::detach(const void* objectID) 70{ 71 mObjects.removeItem(objectID); 72} 73 74void BpBinder::ObjectManager::kill() 75{ 76 const size_t N = mObjects.size(); 77 ALOGV("Killing %zu objects in manager %p", N, this); 78 for (size_t i=0; i<N; i++) { 79 const entry_t& e = mObjects.valueAt(i); 80 if (e.func != NULL) { 81 e.func(mObjects.keyAt(i), e.object, e.cleanupCookie); 82 } 83 } 84 85 mObjects.clear(); 86} 87 88// --------------------------------------------------------------------------- 89 90BpBinder::BpBinder(int32_t handle) 91 : mHandle(handle) 92 , mAlive(1) 93 , mObitsSent(0) 94 , mObituaries(NULL) 95{ 96 ALOGV("Creating BpBinder %p handle %d\n", this, mHandle); 97 98 extendObjectLifetime(OBJECT_LIFETIME_WEAK); 99 IPCThreadState::self()->incWeakHandle(handle); 100} 101 102bool BpBinder::isDescriptorCached() const { 103 Mutex::Autolock _l(mLock); 104 return mDescriptorCache.size() ? true : false; 105} 106 107const String16& BpBinder::getInterfaceDescriptor() const 108{ 109 if (isDescriptorCached() == false) { 110 Parcel send, reply; 111 // do the IPC without a lock held. 112 status_t err = const_cast<BpBinder*>(this)->transact( 113 INTERFACE_TRANSACTION, send, &reply); 114 if (err == NO_ERROR) { 115 String16 res(reply.readString16()); 116 Mutex::Autolock _l(mLock); 117 // mDescriptorCache could have been assigned while the lock was 118 // released. 119 if (mDescriptorCache.size() == 0) 120 mDescriptorCache = res; 121 } 122 } 123 124 // we're returning a reference to a non-static object here. Usually this 125 // is not something smart to do, however, with binder objects it is 126 // (usually) safe because they are reference-counted. 127 128 return mDescriptorCache; 129} 130 131bool BpBinder::isBinderAlive() const 132{ 133 return mAlive != 0; 134} 135 136status_t BpBinder::pingBinder() 137{ 138 Parcel send; 139 Parcel reply; 140 status_t err = transact(PING_TRANSACTION, send, &reply); 141 if (err != NO_ERROR) return err; 142 if (reply.dataSize() < sizeof(status_t)) return NOT_ENOUGH_DATA; 143 return (status_t)reply.readInt32(); 144} 145 146status_t BpBinder::dump(int fd, const Vector<String16>& args) 147{ 148 Parcel send; 149 Parcel reply; 150 send.writeFileDescriptor(fd); 151 const size_t numArgs = args.size(); 152 send.writeInt32(numArgs); 153 for (size_t i = 0; i < numArgs; i++) { 154 send.writeString16(args[i]); 155 } 156 status_t err = transact(DUMP_TRANSACTION, send, &reply); 157 return err; 158} 159 160status_t BpBinder::transact( 161 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 162{ 163 // Once a binder has died, it will never come back to life. 164 if (mAlive) { 165 status_t status = IPCThreadState::self()->transact( 166 mHandle, code, data, reply, flags); 167 if (status == DEAD_OBJECT) mAlive = 0; 168 return status; 169 } 170 171 return DEAD_OBJECT; 172} 173 174status_t BpBinder::linkToDeath( 175 const sp<DeathRecipient>& recipient, void* cookie, uint32_t flags) 176{ 177 Obituary ob; 178 ob.recipient = recipient; 179 ob.cookie = cookie; 180 ob.flags = flags; 181 182 LOG_ALWAYS_FATAL_IF(recipient == NULL, 183 "linkToDeath(): recipient must be non-NULL"); 184 185 { 186 AutoMutex _l(mLock); 187 188 if (!mObitsSent) { 189 if (!mObituaries) { 190 mObituaries = new Vector<Obituary>; 191 if (!mObituaries) { 192 return NO_MEMORY; 193 } 194 ALOGV("Requesting death notification: %p handle %d\n", this, mHandle); 195 getWeakRefs()->incWeak(this); 196 IPCThreadState* self = IPCThreadState::self(); 197 self->requestDeathNotification(mHandle, this); 198 self->flushCommands(); 199 } 200 ssize_t res = mObituaries->add(ob); 201 return res >= (ssize_t)NO_ERROR ? (status_t)NO_ERROR : res; 202 } 203 } 204 205 return DEAD_OBJECT; 206} 207 208status_t BpBinder::unlinkToDeath( 209 const wp<DeathRecipient>& recipient, void* cookie, uint32_t flags, 210 wp<DeathRecipient>* outRecipient) 211{ 212 AutoMutex _l(mLock); 213 214 if (mObitsSent) { 215 return DEAD_OBJECT; 216 } 217 218 const size_t N = mObituaries ? mObituaries->size() : 0; 219 for (size_t i=0; i<N; i++) { 220 const Obituary& obit = mObituaries->itemAt(i); 221 if ((obit.recipient == recipient 222 || (recipient == NULL && obit.cookie == cookie)) 223 && obit.flags == flags) { 224 if (outRecipient != NULL) { 225 *outRecipient = mObituaries->itemAt(i).recipient; 226 } 227 mObituaries->removeAt(i); 228 if (mObituaries->size() == 0) { 229 ALOGV("Clearing death notification: %p handle %d\n", this, mHandle); 230 IPCThreadState* self = IPCThreadState::self(); 231 self->clearDeathNotification(mHandle, this); 232 self->flushCommands(); 233 delete mObituaries; 234 mObituaries = NULL; 235 } 236 return NO_ERROR; 237 } 238 } 239 240 return NAME_NOT_FOUND; 241} 242 243void BpBinder::sendObituary() 244{ 245 ALOGV("Sending obituary for proxy %p handle %d, mObitsSent=%s\n", 246 this, mHandle, mObitsSent ? "true" : "false"); 247 248 mAlive = 0; 249 if (mObitsSent) return; 250 251 mLock.lock(); 252 Vector<Obituary>* obits = mObituaries; 253 if(obits != NULL) { 254 ALOGV("Clearing sent death notification: %p handle %d\n", this, mHandle); 255 IPCThreadState* self = IPCThreadState::self(); 256 self->clearDeathNotification(mHandle, this); 257 self->flushCommands(); 258 mObituaries = NULL; 259 } 260 mObitsSent = 1; 261 mLock.unlock(); 262 263 ALOGV("Reporting death of proxy %p for %zu recipients\n", 264 this, obits ? obits->size() : 0U); 265 266 if (obits != NULL) { 267 const size_t N = obits->size(); 268 for (size_t i=0; i<N; i++) { 269 reportOneDeath(obits->itemAt(i)); 270 } 271 272 delete obits; 273 } 274} 275 276void BpBinder::reportOneDeath(const Obituary& obit) 277{ 278 sp<DeathRecipient> recipient = obit.recipient.promote(); 279 ALOGV("Reporting death to recipient: %p\n", recipient.get()); 280 if (recipient == NULL) return; 281 282 recipient->binderDied(this); 283} 284 285 286void BpBinder::attachObject( 287 const void* objectID, void* object, void* cleanupCookie, 288 object_cleanup_func func) 289{ 290 AutoMutex _l(mLock); 291 ALOGV("Attaching object %p to binder %p (manager=%p)", object, this, &mObjects); 292 mObjects.attach(objectID, object, cleanupCookie, func); 293} 294 295void* BpBinder::findObject(const void* objectID) const 296{ 297 AutoMutex _l(mLock); 298 return mObjects.find(objectID); 299} 300 301void BpBinder::detachObject(const void* objectID) 302{ 303 AutoMutex _l(mLock); 304 mObjects.detach(objectID); 305} 306 307BpBinder* BpBinder::remoteBinder() 308{ 309 return this; 310} 311 312BpBinder::~BpBinder() 313{ 314 ALOGV("Destroying BpBinder %p handle %d\n", this, mHandle); 315 316 IPCThreadState* ipc = IPCThreadState::self(); 317 318 mLock.lock(); 319 Vector<Obituary>* obits = mObituaries; 320 if(obits != NULL) { 321 if (ipc) ipc->clearDeathNotification(mHandle, this); 322 mObituaries = NULL; 323 } 324 mLock.unlock(); 325 326 if (obits != NULL) { 327 // XXX Should we tell any remaining DeathRecipient 328 // objects that the last strong ref has gone away, so they 329 // are no longer linked? 330 delete obits; 331 } 332 333 if (ipc) { 334 ipc->expungeHandle(mHandle, this); 335 ipc->decWeakHandle(mHandle); 336 } 337} 338 339void BpBinder::onFirstRef() 340{ 341 ALOGV("onFirstRef BpBinder %p handle %d\n", this, mHandle); 342 IPCThreadState* ipc = IPCThreadState::self(); 343 if (ipc) ipc->incStrongHandle(mHandle); 344} 345 346void BpBinder::onLastStrongRef(const void* /*id*/) 347{ 348 ALOGV("onLastStrongRef BpBinder %p handle %d\n", this, mHandle); 349 IF_ALOGV() { 350 printRefs(); 351 } 352 IPCThreadState* ipc = IPCThreadState::self(); 353 if (ipc) ipc->decStrongHandle(mHandle); 354} 355 356bool BpBinder::onIncStrongAttempted(uint32_t /*flags*/, const void* /*id*/) 357{ 358 ALOGV("onIncStrongAttempted BpBinder %p handle %d\n", this, mHandle); 359 IPCThreadState* ipc = IPCThreadState::self(); 360 return ipc ? ipc->attemptIncStrongHandle(mHandle) == NO_ERROR : false; 361} 362 363// --------------------------------------------------------------------------- 364 365}; // namespace android 366