blob: 094f89f7d9fedd71f057010882b810c7e852ba98 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2008 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 "IMemory"
18
Hans Boehm7e202972016-07-12 18:05:49 -070019#include <atomic>
Mathias Agopiane9e9fe42017-02-28 16:25:16 -080020#include <stdatomic.h>
21
Mark Salyzyna5e161b2016-09-29 08:08:05 -070022#include <fcntl.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080023#include <stdint.h>
24#include <stdio.h>
25#include <stdlib.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080026#include <sys/types.h>
27#include <sys/mman.h>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070028#include <unistd.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080029
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070030#include <binder/IMemory.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070031#include <binder/Parcel.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070032#include <log/log.h>
Mathias Agopiane9e9fe42017-02-28 16:25:16 -080033
Mark Salyzyna5e161b2016-09-29 08:08:05 -070034#include <utils/KeyedVector.h>
35#include <utils/threads.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080036
37#define VERBOSE 0
38
39namespace android {
40// ---------------------------------------------------------------------------
41
42class HeapCache : public IBinder::DeathRecipient
43{
44public:
45 HeapCache();
46 virtual ~HeapCache();
Anu Sundararajan5728a922011-06-22 15:58:59 -050047
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080048 virtual void binderDied(const wp<IBinder>& who);
49
Anu Sundararajan5728a922011-06-22 15:58:59 -050050 sp<IMemoryHeap> find_heap(const sp<IBinder>& binder);
51 void free_heap(const sp<IBinder>& binder);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080052 sp<IMemoryHeap> get_heap(const sp<IBinder>& binder);
53 void dump_heaps();
54
55private:
56 // For IMemory.cpp
57 struct heap_info_t {
58 sp<IMemoryHeap> heap;
59 int32_t count;
Hans Boehm7e202972016-07-12 18:05:49 -070060 // Note that this cannot be meaningfully copied.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080061 };
62
Anu Sundararajan5728a922011-06-22 15:58:59 -050063 void free_heap(const wp<IBinder>& binder);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080064
Hans Boehm7e202972016-07-12 18:05:49 -070065 Mutex mHeapCacheLock; // Protects entire vector below.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080066 KeyedVector< wp<IBinder>, heap_info_t > mHeapCache;
Hans Boehm7e202972016-07-12 18:05:49 -070067 // We do not use the copy-on-write capabilities of KeyedVector.
68 // TODO: Reimplemement based on standard C++ container?
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080069};
70
71static sp<HeapCache> gHeapCache = new HeapCache();
72
73/******************************************************************************/
74
75enum {
76 HEAP_ID = IBinder::FIRST_CALL_TRANSACTION
77};
78
79class BpMemoryHeap : public BpInterface<IMemoryHeap>
80{
81public:
Chih-Hung Hsiehe2347b72016-04-25 15:41:05 -070082 explicit BpMemoryHeap(const sp<IBinder>& impl);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080083 virtual ~BpMemoryHeap();
84
85 virtual int getHeapID() const;
86 virtual void* getBase() const;
87 virtual size_t getSize() const;
88 virtual uint32_t getFlags() const;
Andy Hung5b028522018-10-22 15:29:49 -070089 off_t getOffset() const override;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080090
91private:
92 friend class IMemory;
93 friend class HeapCache;
Anu Sundararajan5728a922011-06-22 15:58:59 -050094
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080095 // for debugging in this module
96 static inline sp<IMemoryHeap> find_heap(const sp<IBinder>& binder) {
97 return gHeapCache->find_heap(binder);
98 }
99 static inline void free_heap(const sp<IBinder>& binder) {
100 gHeapCache->free_heap(binder);
101 }
102 static inline sp<IMemoryHeap> get_heap(const sp<IBinder>& binder) {
103 return gHeapCache->get_heap(binder);
104 }
105 static inline void dump_heaps() {
Anu Sundararajan5728a922011-06-22 15:58:59 -0500106 gHeapCache->dump_heaps();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800107 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800108
109 void assertMapped() const;
110 void assertReallyMapped() const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800111
Hans Boehm7e202972016-07-12 18:05:49 -0700112 mutable std::atomic<int32_t> mHeapId;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800113 mutable void* mBase;
114 mutable size_t mSize;
115 mutable uint32_t mFlags;
Andy Hung5b028522018-10-22 15:29:49 -0700116 mutable off_t mOffset;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800117 mutable bool mRealHeap;
118 mutable Mutex mLock;
119};
120
121// ----------------------------------------------------------------------------
122
123enum {
124 GET_MEMORY = IBinder::FIRST_CALL_TRANSACTION
125};
126
127class BpMemory : public BpInterface<IMemory>
128{
129public:
Chih-Hung Hsiehe2347b72016-04-25 15:41:05 -0700130 explicit BpMemory(const sp<IBinder>& impl);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800131 virtual ~BpMemory();
Jiyong Parkb86c8662018-10-29 23:01:57 +0900132 // NOLINTNEXTLINE(google-default-arguments)
Yi Kongfdd8da92018-06-07 17:52:27 -0700133 virtual sp<IMemoryHeap> getMemory(ssize_t* offset=nullptr, size_t* size=nullptr) const;
Anu Sundararajan5728a922011-06-22 15:58:59 -0500134
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800135private:
136 mutable sp<IMemoryHeap> mHeap;
137 mutable ssize_t mOffset;
138 mutable size_t mSize;
139};
140
141/******************************************************************************/
142
143void* IMemory::fastPointer(const sp<IBinder>& binder, ssize_t offset) const
144{
145 sp<IMemoryHeap> realHeap = BpMemoryHeap::get_heap(binder);
146 void* const base = realHeap->base();
147 if (base == MAP_FAILED)
Yi Kongfdd8da92018-06-07 17:52:27 -0700148 return nullptr;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800149 return static_cast<char*>(base) + offset;
150}
151
152void* IMemory::pointer() const {
153 ssize_t offset;
154 sp<IMemoryHeap> heap = getMemory(&offset);
Yi Kongfdd8da92018-06-07 17:52:27 -0700155 void* const base = heap!=nullptr ? heap->base() : MAP_FAILED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800156 if (base == MAP_FAILED)
Yi Kongfdd8da92018-06-07 17:52:27 -0700157 return nullptr;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800158 return static_cast<char*>(base) + offset;
159}
160
161size_t IMemory::size() const {
162 size_t size;
Yi Kongfdd8da92018-06-07 17:52:27 -0700163 getMemory(nullptr, &size);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800164 return size;
165}
166
167ssize_t IMemory::offset() const {
168 ssize_t offset;
169 getMemory(&offset);
170 return offset;
171}
172
173/******************************************************************************/
174
175BpMemory::BpMemory(const sp<IBinder>& impl)
176 : BpInterface<IMemory>(impl), mOffset(0), mSize(0)
177{
178}
179
180BpMemory::~BpMemory()
181{
182}
183
Jiyong Parkb86c8662018-10-29 23:01:57 +0900184// NOLINTNEXTLINE(google-default-arguments)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800185sp<IMemoryHeap> BpMemory::getMemory(ssize_t* offset, size_t* size) const
186{
Yi Kongfdd8da92018-06-07 17:52:27 -0700187 if (mHeap == nullptr) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800188 Parcel data, reply;
189 data.writeInterfaceToken(IMemory::getInterfaceDescriptor());
190 if (remote()->transact(GET_MEMORY, data, &reply) == NO_ERROR) {
191 sp<IBinder> heap = reply.readStrongBinder();
Yi Kongfdd8da92018-06-07 17:52:27 -0700192 if (heap != nullptr) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800193 mHeap = interface_cast<IMemoryHeap>(heap);
Yi Kongfdd8da92018-06-07 17:52:27 -0700194 if (mHeap != nullptr) {
Andy Hung5b028522018-10-22 15:29:49 -0700195 const int64_t offset64 = reply.readInt64();
196 const uint64_t size64 = reply.readUint64();
197 const ssize_t o = (ssize_t)offset64;
198 const size_t s = (size_t)size64;
Christopher Tate94b0d4e2016-02-05 19:02:56 -0800199 size_t heapSize = mHeap->getSize();
Andy Hung5b028522018-10-22 15:29:49 -0700200 if (s == size64 && o == offset64 // ILP32 bounds check
201 && s <= heapSize
Christopher Tate94b0d4e2016-02-05 19:02:56 -0800202 && o >= 0
203 && (static_cast<size_t>(o) <= heapSize - s)) {
204 mOffset = o;
205 mSize = s;
206 } else {
207 // Hm.
208 android_errorWriteWithInfoLog(0x534e4554,
Yi Kongfdd8da92018-06-07 17:52:27 -0700209 "26877992", -1, nullptr, 0);
Christopher Tate94b0d4e2016-02-05 19:02:56 -0800210 mOffset = 0;
211 mSize = 0;
212 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800213 }
214 }
215 }
216 }
217 if (offset) *offset = mOffset;
218 if (size) *size = mSize;
Yi Kongfdd8da92018-06-07 17:52:27 -0700219 return (mSize > 0) ? mHeap : nullptr;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800220}
221
222// ---------------------------------------------------------------------------
223
224IMPLEMENT_META_INTERFACE(Memory, "android.utils.IMemory");
225
Mathias Agopian83c04462009-05-22 19:00:22 -0700226BnMemory::BnMemory() {
227}
228
Anu Sundararajan5728a922011-06-22 15:58:59 -0500229BnMemory::~BnMemory() {
Mathias Agopian83c04462009-05-22 19:00:22 -0700230}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800231
Jiyong Parkb86c8662018-10-29 23:01:57 +0900232// NOLINTNEXTLINE(google-default-arguments)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800233status_t BnMemory::onTransact(
234 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
235{
236 switch(code) {
237 case GET_MEMORY: {
238 CHECK_INTERFACE(IMemory, data, reply);
239 ssize_t offset;
240 size_t size;
Marco Nelissen097ca272014-11-14 08:01:01 -0800241 reply->writeStrongBinder( IInterface::asBinder(getMemory(&offset, &size)) );
Andy Hung5b028522018-10-22 15:29:49 -0700242 reply->writeInt64(offset);
243 reply->writeUint64(size);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800244 return NO_ERROR;
245 } break;
246 default:
247 return BBinder::onTransact(code, data, reply, flags);
248 }
249}
250
251
252/******************************************************************************/
253
254BpMemoryHeap::BpMemoryHeap(const sp<IBinder>& impl)
255 : BpInterface<IMemoryHeap>(impl),
Anu Sundararajan5728a922011-06-22 15:58:59 -0500256 mHeapId(-1), mBase(MAP_FAILED), mSize(0), mFlags(0), mOffset(0), mRealHeap(false)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800257{
258}
259
260BpMemoryHeap::~BpMemoryHeap() {
Hans Boehm7e202972016-07-12 18:05:49 -0700261 int32_t heapId = mHeapId.load(memory_order_relaxed);
262 if (heapId != -1) {
263 close(heapId);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800264 if (mRealHeap) {
265 // by construction we're the last one
266 if (mBase != MAP_FAILED) {
Marco Nelissen097ca272014-11-14 08:01:01 -0800267 sp<IBinder> binder = IInterface::asBinder(this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800268
269 if (VERBOSE) {
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800270 ALOGD("UNMAPPING binder=%p, heap=%p, size=%zu, fd=%d",
Hans Boehm7e202972016-07-12 18:05:49 -0700271 binder.get(), this, mSize, heapId);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800272 }
273
274 munmap(mBase, mSize);
275 }
276 } else {
277 // remove from list only if it was mapped before
Marco Nelissen097ca272014-11-14 08:01:01 -0800278 sp<IBinder> binder = IInterface::asBinder(this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800279 free_heap(binder);
280 }
281 }
282}
283
284void BpMemoryHeap::assertMapped() const
285{
Hans Boehm7e202972016-07-12 18:05:49 -0700286 int32_t heapId = mHeapId.load(memory_order_acquire);
287 if (heapId == -1) {
Marco Nelissen097ca272014-11-14 08:01:01 -0800288 sp<IBinder> binder(IInterface::asBinder(const_cast<BpMemoryHeap*>(this)));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800289 sp<BpMemoryHeap> heap(static_cast<BpMemoryHeap*>(find_heap(binder).get()));
290 heap->assertReallyMapped();
291 if (heap->mBase != MAP_FAILED) {
292 Mutex::Autolock _l(mLock);
Hans Boehm7e202972016-07-12 18:05:49 -0700293 if (mHeapId.load(memory_order_relaxed) == -1) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800294 mBase = heap->mBase;
295 mSize = heap->mSize;
Anu Sundararajan5728a922011-06-22 15:58:59 -0500296 mOffset = heap->mOffset;
Nick Kralevichec9ec7d2016-12-17 19:47:27 -0800297 int fd = fcntl(heap->mHeapId.load(memory_order_relaxed), F_DUPFD_CLOEXEC, 0);
Hans Boehm7e202972016-07-12 18:05:49 -0700298 ALOGE_IF(fd==-1, "cannot dup fd=%d",
299 heap->mHeapId.load(memory_order_relaxed));
300 mHeapId.store(fd, memory_order_release);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800301 }
302 } else {
303 // something went wrong
304 free_heap(binder);
305 }
306 }
307}
308
309void BpMemoryHeap::assertReallyMapped() const
310{
Hans Boehm7e202972016-07-12 18:05:49 -0700311 int32_t heapId = mHeapId.load(memory_order_acquire);
312 if (heapId == -1) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800313
314 // remote call without mLock held, worse case scenario, we end up
315 // calling transact() from multiple threads, but that's not a problem,
316 // only mmap below must be in the critical section.
Anu Sundararajan5728a922011-06-22 15:58:59 -0500317
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800318 Parcel data, reply;
319 data.writeInterfaceToken(IMemoryHeap::getInterfaceDescriptor());
320 status_t err = remote()->transact(HEAP_ID, data, &reply);
321 int parcel_fd = reply.readFileDescriptor();
Andy Hung5b028522018-10-22 15:29:49 -0700322 const uint64_t size64 = reply.readUint64();
323 const int64_t offset64 = reply.readInt64();
324 const uint32_t flags = reply.readUint32();
325 const size_t size = (size_t)size64;
326 const off_t offset = (off_t)offset64;
327 if (err != NO_ERROR || // failed transaction
328 size != size64 || offset != offset64) { // ILP32 size check
329 ALOGE("binder=%p transaction failed fd=%d, size=%zu, err=%d (%s)",
330 IInterface::asBinder(this).get(),
331 parcel_fd, size, err, strerror(-err));
332 return;
333 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800334
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800335 Mutex::Autolock _l(mLock);
Hans Boehm7e202972016-07-12 18:05:49 -0700336 if (mHeapId.load(memory_order_relaxed) == -1) {
Nick Kralevichec9ec7d2016-12-17 19:47:27 -0800337 int fd = fcntl(parcel_fd, F_DUPFD_CLOEXEC, 0);
Andy Hung5b028522018-10-22 15:29:49 -0700338 ALOGE_IF(fd == -1, "cannot dup fd=%d, size=%zu, err=%d (%s)",
John Eckerdal6b0b0632016-04-21 15:04:14 +0200339 parcel_fd, size, err, strerror(errno));
340
341 int access = PROT_READ;
342 if (!(flags & READ_ONLY)) {
343 access |= PROT_WRITE;
344 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800345 mRealHeap = true;
Yi Kongfdd8da92018-06-07 17:52:27 -0700346 mBase = mmap(nullptr, size, access, MAP_SHARED, fd, offset);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800347 if (mBase == MAP_FAILED) {
Andy Hung5b028522018-10-22 15:29:49 -0700348 ALOGE("cannot map BpMemoryHeap (binder=%p), size=%zu, fd=%d (%s)",
Marco Nelissen097ca272014-11-14 08:01:01 -0800349 IInterface::asBinder(this).get(), size, fd, strerror(errno));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800350 close(fd);
351 } else {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800352 mSize = size;
353 mFlags = flags;
Anu Sundararajan5728a922011-06-22 15:58:59 -0500354 mOffset = offset;
Hans Boehm7e202972016-07-12 18:05:49 -0700355 mHeapId.store(fd, memory_order_release);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800356 }
357 }
358 }
359}
360
361int BpMemoryHeap::getHeapID() const {
362 assertMapped();
Hans Boehm7e202972016-07-12 18:05:49 -0700363 // We either stored mHeapId ourselves, or loaded it with acquire semantics.
364 return mHeapId.load(memory_order_relaxed);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800365}
366
367void* BpMemoryHeap::getBase() const {
368 assertMapped();
369 return mBase;
370}
371
372size_t BpMemoryHeap::getSize() const {
373 assertMapped();
374 return mSize;
375}
376
377uint32_t BpMemoryHeap::getFlags() const {
378 assertMapped();
379 return mFlags;
380}
381
Andy Hung5b028522018-10-22 15:29:49 -0700382off_t BpMemoryHeap::getOffset() const {
Anu Sundararajan5728a922011-06-22 15:58:59 -0500383 assertMapped();
384 return mOffset;
385}
386
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800387// ---------------------------------------------------------------------------
388
389IMPLEMENT_META_INTERFACE(MemoryHeap, "android.utils.IMemoryHeap");
390
Anu Sundararajan5728a922011-06-22 15:58:59 -0500391BnMemoryHeap::BnMemoryHeap() {
Mathias Agopian83c04462009-05-22 19:00:22 -0700392}
393
Anu Sundararajan5728a922011-06-22 15:58:59 -0500394BnMemoryHeap::~BnMemoryHeap() {
Mathias Agopian83c04462009-05-22 19:00:22 -0700395}
396
Jiyong Parkb86c8662018-10-29 23:01:57 +0900397// NOLINTNEXTLINE(google-default-arguments)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800398status_t BnMemoryHeap::onTransact(
Mathias Agopian83c04462009-05-22 19:00:22 -0700399 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800400{
401 switch(code) {
402 case HEAP_ID: {
403 CHECK_INTERFACE(IMemoryHeap, data, reply);
404 reply->writeFileDescriptor(getHeapID());
Andy Hung5b028522018-10-22 15:29:49 -0700405 reply->writeUint64(getSize());
406 reply->writeInt64(getOffset());
407 reply->writeUint32(getFlags());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800408 return NO_ERROR;
409 } break;
410 default:
411 return BBinder::onTransact(code, data, reply, flags);
412 }
413}
414
415/*****************************************************************************/
416
417HeapCache::HeapCache()
418 : DeathRecipient()
419{
420}
421
422HeapCache::~HeapCache()
423{
424}
425
426void HeapCache::binderDied(const wp<IBinder>& binder)
427{
Steve Block9d453682011-12-20 16:23:08 +0000428 //ALOGD("binderDied binder=%p", binder.unsafe_get());
Anu Sundararajan5728a922011-06-22 15:58:59 -0500429 free_heap(binder);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800430}
431
Anu Sundararajan5728a922011-06-22 15:58:59 -0500432sp<IMemoryHeap> HeapCache::find_heap(const sp<IBinder>& binder)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800433{
434 Mutex::Autolock _l(mHeapCacheLock);
435 ssize_t i = mHeapCache.indexOfKey(binder);
436 if (i>=0) {
437 heap_info_t& info = mHeapCache.editValueAt(i);
Steve Block9d453682011-12-20 16:23:08 +0000438 ALOGD_IF(VERBOSE,
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800439 "found binder=%p, heap=%p, size=%zu, fd=%d, count=%d",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800440 binder.get(), info.heap.get(),
441 static_cast<BpMemoryHeap*>(info.heap.get())->mSize,
Hans Boehm7e202972016-07-12 18:05:49 -0700442 static_cast<BpMemoryHeap*>(info.heap.get())
443 ->mHeapId.load(memory_order_relaxed),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800444 info.count);
Hans Boehm7e202972016-07-12 18:05:49 -0700445 ++info.count;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800446 return info.heap;
447 } else {
448 heap_info_t info;
449 info.heap = interface_cast<IMemoryHeap>(binder);
450 info.count = 1;
Steve Block9d453682011-12-20 16:23:08 +0000451 //ALOGD("adding binder=%p, heap=%p, count=%d",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800452 // binder.get(), info.heap.get(), info.count);
453 mHeapCache.add(binder, info);
454 return info.heap;
455 }
456}
457
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800458void HeapCache::free_heap(const sp<IBinder>& binder) {
459 free_heap( wp<IBinder>(binder) );
460}
461
Anu Sundararajan5728a922011-06-22 15:58:59 -0500462void HeapCache::free_heap(const wp<IBinder>& binder)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800463{
464 sp<IMemoryHeap> rel;
465 {
466 Mutex::Autolock _l(mHeapCacheLock);
467 ssize_t i = mHeapCache.indexOfKey(binder);
468 if (i>=0) {
469 heap_info_t& info(mHeapCache.editValueAt(i));
Hans Boehm7e202972016-07-12 18:05:49 -0700470 if (--info.count == 0) {
Steve Block9d453682011-12-20 16:23:08 +0000471 ALOGD_IF(VERBOSE,
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800472 "removing binder=%p, heap=%p, size=%zu, fd=%d, count=%d",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800473 binder.unsafe_get(), info.heap.get(),
474 static_cast<BpMemoryHeap*>(info.heap.get())->mSize,
Hans Boehm7e202972016-07-12 18:05:49 -0700475 static_cast<BpMemoryHeap*>(info.heap.get())
476 ->mHeapId.load(memory_order_relaxed),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800477 info.count);
478 rel = mHeapCache.valueAt(i).heap;
479 mHeapCache.removeItemsAt(i);
480 }
481 } else {
Steve Blocke6f43dd2012-01-06 19:20:56 +0000482 ALOGE("free_heap binder=%p not found!!!", binder.unsafe_get());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800483 }
484 }
485}
486
487sp<IMemoryHeap> HeapCache::get_heap(const sp<IBinder>& binder)
488{
489 sp<IMemoryHeap> realHeap;
490 Mutex::Autolock _l(mHeapCacheLock);
491 ssize_t i = mHeapCache.indexOfKey(binder);
492 if (i>=0) realHeap = mHeapCache.valueAt(i).heap;
493 else realHeap = interface_cast<IMemoryHeap>(binder);
494 return realHeap;
495}
496
Anu Sundararajan5728a922011-06-22 15:58:59 -0500497void HeapCache::dump_heaps()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800498{
499 Mutex::Autolock _l(mHeapCacheLock);
500 int c = mHeapCache.size();
501 for (int i=0 ; i<c ; i++) {
502 const heap_info_t& info = mHeapCache.valueAt(i);
503 BpMemoryHeap const* h(static_cast<BpMemoryHeap const *>(info.heap.get()));
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800504 ALOGD("hey=%p, heap=%p, count=%d, (fd=%d, base=%p, size=%zu)",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800505 mHeapCache.keyAt(i).unsafe_get(),
Anu Sundararajan5728a922011-06-22 15:58:59 -0500506 info.heap.get(), info.count,
Hans Boehm7e202972016-07-12 18:05:49 -0700507 h->mHeapId.load(memory_order_relaxed), h->mBase, h->mSize);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800508 }
509}
510
511
512// ---------------------------------------------------------------------------
Steven Moreland61ff8492019-09-26 16:05:45 -0700513} // namespace android