0dd0d2944a
At some point the implementation became complicated because of SurfaceFlinger's special needs, since we are now relying on gralloc we can go back to much simpler MemoryDealer. Removed HeapInterface and AllocatorInterface, since those don't need to be paramterized anymore. Merged SimpleMemory and Allocation. Made SimplisticAllocator non virtual. Removed MemoryDealer flags (READ_ONLY, PAGE_ALIGNED) Removed a lot of unneeded code.
249 lines
6.9 KiB
C++
249 lines
6.9 KiB
C++
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "MemoryHeapPmem"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <cutils/log.h>
|
|
|
|
#include <binder/MemoryHeapPmem.h>
|
|
#include <binder/MemoryHeapBase.h>
|
|
|
|
#if HAVE_ANDROID_OS
|
|
#include <linux/android_pmem.h>
|
|
#endif
|
|
|
|
namespace android {
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
MemoryHeapPmem::MemoryPmem::MemoryPmem(const sp<MemoryHeapPmem>& heap)
|
|
: BnMemory(), mClientHeap(heap)
|
|
{
|
|
}
|
|
|
|
MemoryHeapPmem::MemoryPmem::~MemoryPmem() {
|
|
if (mClientHeap != NULL) {
|
|
mClientHeap->remove(this);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
class SubRegionMemory : public MemoryHeapPmem::MemoryPmem {
|
|
public:
|
|
SubRegionMemory(const sp<MemoryHeapPmem>& heap, ssize_t offset, size_t size);
|
|
virtual ~SubRegionMemory();
|
|
virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size) const;
|
|
private:
|
|
friend class MemoryHeapPmem;
|
|
void revoke();
|
|
size_t mSize;
|
|
ssize_t mOffset;
|
|
};
|
|
|
|
SubRegionMemory::SubRegionMemory(const sp<MemoryHeapPmem>& heap,
|
|
ssize_t offset, size_t size)
|
|
: MemoryHeapPmem::MemoryPmem(heap), mSize(size), mOffset(offset)
|
|
{
|
|
#ifndef NDEBUG
|
|
void* const start_ptr = (void*)(intptr_t(getHeap()->base()) + offset);
|
|
memset(start_ptr, 0xda, size);
|
|
#endif
|
|
|
|
#if HAVE_ANDROID_OS
|
|
if (size > 0) {
|
|
const size_t pagesize = getpagesize();
|
|
size = (size + pagesize-1) & ~(pagesize-1);
|
|
int our_fd = heap->heapID();
|
|
struct pmem_region sub = { offset, size };
|
|
int err = ioctl(our_fd, PMEM_MAP, &sub);
|
|
LOGE_IF(err<0, "PMEM_MAP failed (%s), "
|
|
"mFD=%d, sub.offset=%lu, sub.size=%lu",
|
|
strerror(errno), our_fd, sub.offset, sub.len);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
sp<IMemoryHeap> SubRegionMemory::getMemory(ssize_t* offset, size_t* size) const
|
|
{
|
|
if (offset) *offset = mOffset;
|
|
if (size) *size = mSize;
|
|
return getHeap();
|
|
}
|
|
|
|
SubRegionMemory::~SubRegionMemory()
|
|
{
|
|
revoke();
|
|
}
|
|
|
|
|
|
void SubRegionMemory::revoke()
|
|
{
|
|
// NOTE: revoke() doesn't need to be protected by a lock because it
|
|
// can only be called from MemoryHeapPmem::revoke(), which means
|
|
// that we can't be in ~SubRegionMemory(), or in ~SubRegionMemory(),
|
|
// which means MemoryHeapPmem::revoke() wouldn't have been able to
|
|
// promote() it.
|
|
|
|
#if HAVE_ANDROID_OS
|
|
if (mSize != 0) {
|
|
const sp<MemoryHeapPmem>& heap(getHeap());
|
|
int our_fd = heap->heapID();
|
|
struct pmem_region sub;
|
|
sub.offset = mOffset;
|
|
sub.len = mSize;
|
|
int err = ioctl(our_fd, PMEM_UNMAP, &sub);
|
|
LOGE_IF(err<0, "PMEM_UNMAP failed (%s), "
|
|
"mFD=%d, sub.offset=%lu, sub.size=%lu",
|
|
strerror(errno), our_fd, sub.offset, sub.len);
|
|
mSize = 0;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
MemoryHeapPmem::MemoryHeapPmem(const sp<MemoryHeapBase>& pmemHeap,
|
|
uint32_t flags)
|
|
: MemoryHeapBase()
|
|
{
|
|
char const * const device = pmemHeap->getDevice();
|
|
#if HAVE_ANDROID_OS
|
|
if (device) {
|
|
int fd = open(device, O_RDWR | (flags & NO_CACHING ? O_SYNC : 0));
|
|
LOGE_IF(fd<0, "couldn't open %s (%s)", device, strerror(errno));
|
|
if (fd >= 0) {
|
|
int err = ioctl(fd, PMEM_CONNECT, pmemHeap->heapID());
|
|
if (err < 0) {
|
|
LOGE("PMEM_CONNECT failed (%s), mFD=%d, sub-fd=%d",
|
|
strerror(errno), fd, pmemHeap->heapID());
|
|
close(fd);
|
|
} else {
|
|
// everything went well...
|
|
mParentHeap = pmemHeap;
|
|
MemoryHeapBase::init(fd,
|
|
pmemHeap->getBase(),
|
|
pmemHeap->getSize(),
|
|
pmemHeap->getFlags() | flags,
|
|
device);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
mParentHeap = pmemHeap;
|
|
MemoryHeapBase::init(
|
|
dup(pmemHeap->heapID()),
|
|
pmemHeap->getBase(),
|
|
pmemHeap->getSize(),
|
|
pmemHeap->getFlags() | flags,
|
|
device);
|
|
#endif
|
|
}
|
|
|
|
MemoryHeapPmem::~MemoryHeapPmem()
|
|
{
|
|
}
|
|
|
|
sp<IMemory> MemoryHeapPmem::mapMemory(size_t offset, size_t size)
|
|
{
|
|
sp<MemoryPmem> memory = createMemory(offset, size);
|
|
if (memory != 0) {
|
|
Mutex::Autolock _l(mLock);
|
|
mAllocations.add(memory);
|
|
}
|
|
return memory;
|
|
}
|
|
|
|
sp<MemoryHeapPmem::MemoryPmem> MemoryHeapPmem::createMemory(
|
|
size_t offset, size_t size)
|
|
{
|
|
sp<SubRegionMemory> memory;
|
|
if (heapID() > 0)
|
|
memory = new SubRegionMemory(this, offset, size);
|
|
return memory;
|
|
}
|
|
|
|
status_t MemoryHeapPmem::slap()
|
|
{
|
|
#if HAVE_ANDROID_OS
|
|
size_t size = getSize();
|
|
const size_t pagesize = getpagesize();
|
|
size = (size + pagesize-1) & ~(pagesize-1);
|
|
int our_fd = getHeapID();
|
|
struct pmem_region sub = { 0, size };
|
|
int err = ioctl(our_fd, PMEM_MAP, &sub);
|
|
LOGE_IF(err<0, "PMEM_MAP failed (%s), "
|
|
"mFD=%d, sub.offset=%lu, sub.size=%lu",
|
|
strerror(errno), our_fd, sub.offset, sub.len);
|
|
return -errno;
|
|
#else
|
|
return NO_ERROR;
|
|
#endif
|
|
}
|
|
|
|
status_t MemoryHeapPmem::unslap()
|
|
{
|
|
#if HAVE_ANDROID_OS
|
|
size_t size = getSize();
|
|
const size_t pagesize = getpagesize();
|
|
size = (size + pagesize-1) & ~(pagesize-1);
|
|
int our_fd = getHeapID();
|
|
struct pmem_region sub = { 0, size };
|
|
int err = ioctl(our_fd, PMEM_UNMAP, &sub);
|
|
LOGE_IF(err<0, "PMEM_UNMAP failed (%s), "
|
|
"mFD=%d, sub.offset=%lu, sub.size=%lu",
|
|
strerror(errno), our_fd, sub.offset, sub.len);
|
|
return -errno;
|
|
#else
|
|
return NO_ERROR;
|
|
#endif
|
|
}
|
|
|
|
void MemoryHeapPmem::revoke()
|
|
{
|
|
SortedVector< wp<MemoryPmem> > allocations;
|
|
|
|
{ // scope for lock
|
|
Mutex::Autolock _l(mLock);
|
|
allocations = mAllocations;
|
|
}
|
|
|
|
ssize_t count = allocations.size();
|
|
for (ssize_t i=0 ; i<count ; i++) {
|
|
sp<MemoryPmem> memory(allocations[i].promote());
|
|
if (memory != 0)
|
|
memory->revoke();
|
|
}
|
|
}
|
|
|
|
void MemoryHeapPmem::remove(const wp<MemoryPmem>& memory)
|
|
{
|
|
Mutex::Autolock _l(mLock);
|
|
mAllocations.remove(memory);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
}; // namespace android
|