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#include <limits.h>
18#include <errno.h>
19#include <pthread.h>
20#include <unistd.h>
21#include <string.h>
22
23#include <sys/mman.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26
27#include <cutils/log.h>
28#include <cutils/atomic.h>
29
30#include <hardware/hardware.h>
31#include <hardware/gralloc.h>
32
33#include "gralloc_priv.h"
34
35
36/*****************************************************************************/
37
38static int gralloc_map(gralloc_module_t const* /*module*/,
39        buffer_handle_t handle,
40        void** vaddr)
41{
42    private_handle_t* hnd = (private_handle_t*)handle;
43    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
44        size_t size = hnd->size;
45        void* mappedAddress = mmap(0, size,
46                PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);
47        if (mappedAddress == MAP_FAILED) {
48            ALOGE("Could not mmap %s", strerror(errno));
49            return -errno;
50        }
51        hnd->base = uintptr_t(mappedAddress) + hnd->offset;
52        //ALOGD("gralloc_map() succeeded fd=%d, off=%d, size=%d, vaddr=%p",
53        //        hnd->fd, hnd->offset, hnd->size, mappedAddress);
54    }
55    *vaddr = (void*)hnd->base;
56    return 0;
57}
58
59static int gralloc_unmap(gralloc_module_t const* /*module*/,
60        buffer_handle_t handle)
61{
62    private_handle_t* hnd = (private_handle_t*)handle;
63    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
64        void* base = (void*)hnd->base;
65        size_t size = hnd->size;
66        //ALOGD("unmapping from %p, size=%d", base, size);
67        if (munmap(base, size) < 0) {
68            ALOGE("Could not unmap %s", strerror(errno));
69        }
70    }
71    hnd->base = 0;
72    return 0;
73}
74
75/*****************************************************************************/
76
77int gralloc_register_buffer(gralloc_module_t const* module,
78        buffer_handle_t handle)
79{
80    if (private_handle_t::validate(handle) < 0)
81        return -EINVAL;
82
83    // *** WARNING WARNING WARNING ***
84    //
85    // If a buffer handle is passed from the process that allocated it to a
86    // different process, and then back to the allocator process, we will
87    // create a second mapping of the buffer. If the process reads and writes
88    // through both mappings, normal memory ordering guarantees may be
89    // violated, depending on the processor cache implementation*.
90    //
91    // If you are deriving a new gralloc implementation from this code, don't
92    // do this. A "real" gralloc should provide a single reference-counted
93    // mapping for each buffer in a process.
94    //
95    // In the current system, there is one case that needs a buffer to be
96    // registered in the same process that allocated it. The SurfaceFlinger
97    // process acts as the IGraphicBufferAlloc Binder provider, so all gralloc
98    // allocations happen in its process. After returning the buffer handle to
99    // the IGraphicBufferAlloc client, SurfaceFlinger free's its handle to the
100    // buffer (unmapping it from the SurfaceFlinger process). If
101    // SurfaceFlinger later acts as the producer end of the buffer queue the
102    // buffer belongs to, it will get a new handle to the buffer in response
103    // to IGraphicBufferProducer::requestBuffer(). Like any buffer handle
104    // received through Binder, the SurfaceFlinger process will register it.
105    // Since it already freed its original handle, it will only end up with
106    // one mapping to the buffer and there will be no problem.
107    //
108    // Currently SurfaceFlinger only acts as a buffer producer for a remote
109    // consumer when taking screenshots and when using virtual displays.
110    //
111    // Eventually, each application should be allowed to make its own gralloc
112    // allocations, solving the problem. Also, this ashmem-based gralloc
113    // should go away, replaced with a real ion-based gralloc.
114    //
115    // * Specifically, associative virtually-indexed caches are likely to have
116    //   problems. Most modern L1 caches fit that description.
117
118    private_handle_t* hnd = (private_handle_t*)handle;
119    ALOGD_IF(hnd->pid == getpid(),
120            "Registering a buffer in the process that created it. "
121            "This may cause memory ordering problems.");
122
123    void *vaddr;
124    return gralloc_map(module, handle, &vaddr);
125}
126
127int gralloc_unregister_buffer(gralloc_module_t const* module,
128        buffer_handle_t handle)
129{
130    if (private_handle_t::validate(handle) < 0)
131        return -EINVAL;
132
133    private_handle_t* hnd = (private_handle_t*)handle;
134    if (hnd->base)
135        gralloc_unmap(module, handle);
136
137    return 0;
138}
139
140int mapBuffer(gralloc_module_t const* module,
141        private_handle_t* hnd)
142{
143    void* vaddr;
144    return gralloc_map(module, hnd, &vaddr);
145}
146
147int terminateBuffer(gralloc_module_t const* module,
148        private_handle_t* hnd)
149{
150    if (hnd->base) {
151        // this buffer was mapped, unmap it now
152        gralloc_unmap(module, hnd);
153    }
154
155    return 0;
156}
157
158int gralloc_lock(gralloc_module_t const* /*module*/,
159        buffer_handle_t handle, int /*usage*/,
160        int /*l*/, int /*t*/, int /*w*/, int /*h*/,
161        void** vaddr)
162{
163    // this is called when a buffer is being locked for software
164    // access. in thin implementation we have nothing to do since
165    // not synchronization with the h/w is needed.
166    // typically this is used to wait for the h/w to finish with
167    // this buffer if relevant. the data cache may need to be
168    // flushed or invalidated depending on the usage bits and the
169    // hardware.
170
171    if (private_handle_t::validate(handle) < 0)
172        return -EINVAL;
173
174    private_handle_t* hnd = (private_handle_t*)handle;
175    *vaddr = (void*)hnd->base;
176    return 0;
177}
178
179int gralloc_unlock(gralloc_module_t const* /*module*/,
180        buffer_handle_t handle)
181{
182    // we're done with a software buffer. nothing to do in this
183    // implementation. typically this is used to flush the data cache.
184
185    if (private_handle_t::validate(handle) < 0)
186        return -EINVAL;
187    return 0;
188}
189