1/*
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 "MemoryHeapBase"
18
19#include <stdlib.h>
20#include <stdint.h>
21#include <unistd.h>
22#include <fcntl.h>
23#include <errno.h>
24#include <sys/types.h>
25#include <sys/stat.h>
26#include <sys/ioctl.h>
27
28#include <cutils/log.h>
29#include <cutils/ashmem.h>
30#include <cutils/atomic.h>
31
32#include <binder/MemoryHeapBase.h>
33
34#ifdef HAVE_ANDROID_OS
35#include <linux/android_pmem.h>
36#endif
37
38
39namespace android {
40
41// ---------------------------------------------------------------------------
42
43MemoryHeapBase::MemoryHeapBase()
44    : mFD(-1), mSize(0), mBase(MAP_FAILED),
45      mDevice(NULL), mNeedUnmap(false), mOffset(0)
46{
47}
48
49MemoryHeapBase::MemoryHeapBase(size_t size, uint32_t flags, char const * name)
50    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),
51      mDevice(0), mNeedUnmap(false), mOffset(0)
52{
53    const size_t pagesize = getpagesize();
54    size = ((size + pagesize-1) & ~(pagesize-1));
55    int fd = ashmem_create_region(name == NULL ? "MemoryHeapBase" : name, size);
56    ALOGE_IF(fd<0, "error creating ashmem region: %s", strerror(errno));
57    if (fd >= 0) {
58        if (mapfd(fd, size) == NO_ERROR) {
59            if (flags & READ_ONLY) {
60                ashmem_set_prot_region(fd, PROT_READ);
61            }
62        }
63    }
64}
65
66MemoryHeapBase::MemoryHeapBase(const char* device, size_t size, uint32_t flags)
67    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),
68      mDevice(0), mNeedUnmap(false), mOffset(0)
69{
70    int open_flags = O_RDWR;
71    if (flags & NO_CACHING)
72        open_flags |= O_SYNC;
73
74    int fd = open(device, open_flags);
75    ALOGE_IF(fd<0, "error opening %s: %s", device, strerror(errno));
76    if (fd >= 0) {
77        const size_t pagesize = getpagesize();
78        size = ((size + pagesize-1) & ~(pagesize-1));
79        if (mapfd(fd, size) == NO_ERROR) {
80            mDevice = device;
81        }
82    }
83}
84
85MemoryHeapBase::MemoryHeapBase(int fd, size_t size, uint32_t flags, uint32_t offset)
86    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),
87      mDevice(0), mNeedUnmap(false), mOffset(0)
88{
89    const size_t pagesize = getpagesize();
90    size = ((size + pagesize-1) & ~(pagesize-1));
91    mapfd(dup(fd), size, offset);
92}
93
94status_t MemoryHeapBase::init(int fd, void *base, int size, int flags, const char* device)
95{
96    if (mFD != -1) {
97        return INVALID_OPERATION;
98    }
99    mFD = fd;
100    mBase = base;
101    mSize = size;
102    mFlags = flags;
103    mDevice = device;
104    return NO_ERROR;
105}
106
107status_t MemoryHeapBase::mapfd(int fd, size_t size, uint32_t offset)
108{
109    if (size == 0) {
110        // try to figure out the size automatically
111#ifdef HAVE_ANDROID_OS
112        // first try the PMEM ioctl
113        pmem_region reg;
114        int err = ioctl(fd, PMEM_GET_TOTAL_SIZE, &reg);
115        if (err == 0)
116            size = reg.len;
117#endif
118        if (size == 0) { // try fstat
119            struct stat sb;
120            if (fstat(fd, &sb) == 0)
121                size = sb.st_size;
122        }
123        // if it didn't work, let mmap() fail.
124    }
125
126    if ((mFlags & DONT_MAP_LOCALLY) == 0) {
127        void* base = (uint8_t*)mmap(0, size,
128                PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset);
129        if (base == MAP_FAILED) {
130            ALOGE("mmap(fd=%d, size=%u) failed (%s)",
131                    fd, uint32_t(size), strerror(errno));
132            close(fd);
133            return -errno;
134        }
135        //ALOGD("mmap(fd=%d, base=%p, size=%lu)", fd, base, size);
136        mBase = base;
137        mNeedUnmap = true;
138    } else  {
139        mBase = 0; // not MAP_FAILED
140        mNeedUnmap = false;
141    }
142    mFD = fd;
143    mSize = size;
144    mOffset = offset;
145    return NO_ERROR;
146}
147
148MemoryHeapBase::~MemoryHeapBase()
149{
150    dispose();
151}
152
153void MemoryHeapBase::dispose()
154{
155    int fd = android_atomic_or(-1, &mFD);
156    if (fd >= 0) {
157        if (mNeedUnmap) {
158            //ALOGD("munmap(fd=%d, base=%p, size=%lu)", fd, mBase, mSize);
159            munmap(mBase, mSize);
160        }
161        mBase = 0;
162        mSize = 0;
163        close(fd);
164    }
165}
166
167int MemoryHeapBase::getHeapID() const {
168    return mFD;
169}
170
171void* MemoryHeapBase::getBase() const {
172    return mBase;
173}
174
175size_t MemoryHeapBase::getSize() const {
176    return mSize;
177}
178
179uint32_t MemoryHeapBase::getFlags() const {
180    return mFlags;
181}
182
183const char* MemoryHeapBase::getDevice() const {
184    return mDevice;
185}
186
187uint32_t MemoryHeapBase::getOffset() const {
188    return mOffset;
189}
190
191// ---------------------------------------------------------------------------
192}; // namespace android
193