mapper.cpp revision a19f21d925628239ef52c8ce392fa4ada91df6fc
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright (c) 2011 Code Aurora Forum. All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18#include <limits.h> 19#include <errno.h> 20#include <pthread.h> 21#include <unistd.h> 22#include <string.h> 23#include <stdarg.h> 24 25#include <sys/mman.h> 26#include <sys/stat.h> 27#include <sys/types.h> 28#include <sys/ioctl.h> 29#include <linux/ashmem.h> 30 31#include <cutils/log.h> 32#include <cutils/atomic.h> 33#include <cutils/ashmem.h> 34 35#include <hardware/hardware.h> 36#include <hardware/gralloc.h> 37#include <genlock.h> 38 39#include <linux/android_pmem.h> 40 41#include "gralloc_priv.h" 42#include "gr.h" 43#include "alloc_controller.h" 44#include "memalloc.h" 45 46using namespace gralloc; 47using android::sp; 48/*****************************************************************************/ 49 50// Return the type of allocator - 51// these are used for mapping/unmapping 52static sp<IMemAlloc> getAllocator(int flags) 53{ 54 sp<IMemAlloc> memalloc; 55 sp<IAllocController> alloc_ctrl = IAllocController::getInstance(true); 56 memalloc = alloc_ctrl->getAllocator(flags); 57 return memalloc; 58} 59 60static int gralloc_map(gralloc_module_t const* module, 61 buffer_handle_t handle, 62 void** vaddr) 63{ 64 private_handle_t* hnd = (private_handle_t*)handle; 65 void *mappedAddress; 66 if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) && 67 !(hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER)) { 68 size_t size = hnd->size; 69 sp<IMemAlloc> memalloc = getAllocator(hnd->flags) ; 70 int err = memalloc->map_buffer(&mappedAddress, size, 71 hnd->offset, hnd->fd); 72 if(err) { 73 ALOGE("Could not mmap handle %p, fd=%d (%s)", 74 handle, hnd->fd, strerror(errno)); 75 hnd->base = 0; 76 return -errno; 77 } 78 79 if (mappedAddress == MAP_FAILED) { 80 ALOGE("Could not mmap handle %p, fd=%d (%s)", 81 handle, hnd->fd, strerror(errno)); 82 hnd->base = 0; 83 return -errno; 84 } 85 hnd->base = intptr_t(mappedAddress) + hnd->offset; 86 //ALOGD("gralloc_map() succeeded fd=%d, off=%d, size=%d, vaddr=%p", 87 // hnd->fd, hnd->offset, hnd->size, mappedAddress); 88 } 89 *vaddr = (void*)hnd->base; 90 return 0; 91} 92 93static int gralloc_unmap(gralloc_module_t const* module, 94 buffer_handle_t handle) 95{ 96 private_handle_t* hnd = (private_handle_t*)handle; 97 if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) { 98 int err = -EINVAL; 99 void* base = (void*)hnd->base; 100 size_t size = hnd->size; 101 sp<IMemAlloc> memalloc = getAllocator(hnd->flags) ; 102 if(memalloc != NULL) 103 err = memalloc->unmap_buffer(base, size, hnd->offset); 104 if (err) { 105 ALOGE("Could not unmap memory at address %p", base); 106 } 107 } 108 hnd->base = 0; 109 return 0; 110} 111 112/*****************************************************************************/ 113 114static pthread_mutex_t sMapLock = PTHREAD_MUTEX_INITIALIZER; 115 116/*****************************************************************************/ 117 118int gralloc_register_buffer(gralloc_module_t const* module, 119 buffer_handle_t handle) 120{ 121 if (private_handle_t::validate(handle) < 0) 122 return -EINVAL; 123 124 // In this implementation, we don't need to do anything here 125 126 /* NOTE: we need to initialize the buffer as not mapped/not locked 127 * because it shouldn't when this function is called the first time 128 * in a new process. Ideally these flags shouldn't be part of the 129 * handle, but instead maintained in the kernel or at least 130 * out-of-line 131 */ 132 133 // if this handle was created in this process, then we keep it as is. 134 private_handle_t* hnd = (private_handle_t*)handle; 135 if (hnd->pid != getpid()) { 136 hnd->base = 0; 137 void *vaddr; 138 int err = gralloc_map(module, handle, &vaddr); 139 if (err) { 140 ALOGE("%s: gralloc_map failed", __FUNCTION__); 141 return err; 142 } 143 144 // Reset the genlock private fd flag in the handle 145 hnd->genlockPrivFd = -1; 146 147 // Check if there is a valid lock attached to the handle. 148 if (-1 == hnd->genlockHandle) { 149 ALOGE("%s: the lock is invalid.", __FUNCTION__); 150 gralloc_unmap(module, handle); 151 hnd->base = 0; 152 return -EINVAL; 153 } 154 155 // Attach the genlock handle 156 if (GENLOCK_NO_ERROR != genlock_attach_lock((native_handle_t *)handle)) { 157 ALOGE("%s: genlock_attach_lock failed", __FUNCTION__); 158 gralloc_unmap(module, handle); 159 hnd->base = 0; 160 return -EINVAL; 161 } 162 } 163 return 0; 164} 165 166int gralloc_unregister_buffer(gralloc_module_t const* module, 167 buffer_handle_t handle) 168{ 169 if (private_handle_t::validate(handle) < 0) 170 return -EINVAL; 171 172 /* 173 * If the buffer has been mapped during a lock operation, it's time 174 * to un-map it. It's an error to be here with a locked buffer. 175 * NOTE: the framebuffer is handled differently and is never unmapped. 176 */ 177 178 private_handle_t* hnd = (private_handle_t*)handle; 179 180 // never unmap buffers that were created in this process 181 if (hnd->pid != getpid()) { 182 if (hnd->base != 0) { 183 gralloc_unmap(module, handle); 184 } 185 hnd->base = 0; 186 // Release the genlock 187 if (-1 != hnd->genlockHandle) { 188 return genlock_release_lock((native_handle_t *)handle); 189 } else { 190 ALOGE("%s: there was no genlock attached to this buffer", __FUNCTION__); 191 return -EINVAL; 192 } 193 } 194 return 0; 195} 196 197int terminateBuffer(gralloc_module_t const* module, 198 private_handle_t* hnd) 199{ 200 /* 201 * If the buffer has been mapped during a lock operation, it's time 202 * to un-map it. It's an error to be here with a locked buffer. 203 */ 204 205 if (hnd->base != 0) { 206 // this buffer was mapped, unmap it now 207 if (hnd->flags & (private_handle_t::PRIV_FLAGS_USES_PMEM | 208 private_handle_t::PRIV_FLAGS_USES_PMEM_ADSP | 209 private_handle_t::PRIV_FLAGS_USES_ASHMEM | 210 private_handle_t::PRIV_FLAGS_USES_ION)) { 211 if (hnd->pid != getpid()) { 212 // ... unless it's a "master" pmem buffer, that is a buffer 213 // mapped in the process it's been allocated. 214 // (see gralloc_alloc_buffer()) 215 gralloc_unmap(module, hnd); 216 } 217 } else { 218 ALOGE("terminateBuffer: unmapping a non pmem/ashmem buffer flags = 0x%x", hnd->flags); 219 gralloc_unmap(module, hnd); 220 } 221 } 222 223 return 0; 224} 225 226int gralloc_lock(gralloc_module_t const* module, 227 buffer_handle_t handle, int usage, 228 int l, int t, int w, int h, 229 void** vaddr) 230{ 231 if (private_handle_t::validate(handle) < 0) 232 return -EINVAL; 233 234 int err = 0; 235 private_handle_t* hnd = (private_handle_t*)handle; 236 if (usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) { 237 if (hnd->base == 0) { 238 // we need to map for real 239 pthread_mutex_t* const lock = &sMapLock; 240 pthread_mutex_lock(lock); 241 err = gralloc_map(module, handle, vaddr); 242 pthread_mutex_unlock(lock); 243 } 244 *vaddr = (void*)hnd->base; 245 246 // Lock the buffer for read/write operation as specified. Write lock 247 // has a higher priority over read lock. 248 int lockType = 0; 249 if (usage & GRALLOC_USAGE_SW_WRITE_MASK) { 250 lockType = GENLOCK_WRITE_LOCK; 251 } else if (usage & GRALLOC_USAGE_SW_READ_MASK) { 252 lockType = GENLOCK_READ_LOCK; 253 } 254 255 int timeout = GENLOCK_MAX_TIMEOUT; 256 if (GENLOCK_NO_ERROR != genlock_lock_buffer((native_handle_t *)handle, 257 (genlock_lock_type)lockType, 258 timeout)) { 259 ALOGE("%s: genlock_lock_buffer (lockType=0x%x) failed", __FUNCTION__, 260 lockType); 261 return -EINVAL; 262 } else { 263 // Mark this buffer as locked for SW read/write operation. 264 hnd->flags |= private_handle_t::PRIV_FLAGS_SW_LOCK; 265 } 266 267 if ((usage & GRALLOC_USAGE_SW_WRITE_MASK) && 268 !(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) { 269 // Mark the buffer to be flushed after cpu read/write 270 hnd->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH; 271 } 272 } 273 return err; 274} 275 276int gralloc_unlock(gralloc_module_t const* module, 277 buffer_handle_t handle) 278{ 279 if (private_handle_t::validate(handle) < 0) 280 return -EINVAL; 281 282 private_handle_t* hnd = (private_handle_t*)handle; 283 284 if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) { 285 int err; 286 sp<IMemAlloc> memalloc = getAllocator(hnd->flags) ; 287 err = memalloc->clean_buffer((void*)hnd->base, 288 hnd->size, hnd->offset, hnd->fd); 289 ALOGE_IF(err < 0, "cannot flush handle %p (offs=%x len=%x, flags = 0x%x) err=%s\n", 290 hnd, hnd->offset, hnd->size, hnd->flags, strerror(errno)); 291 hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH; 292 } 293 294 if ((hnd->flags & private_handle_t::PRIV_FLAGS_SW_LOCK)) { 295 // Unlock the buffer. 296 if (GENLOCK_NO_ERROR != genlock_unlock_buffer((native_handle_t *)handle)) { 297 ALOGE("%s: genlock_unlock_buffer failed", __FUNCTION__); 298 return -EINVAL; 299 } else 300 hnd->flags &= ~private_handle_t::PRIV_FLAGS_SW_LOCK; 301 } 302 return 0; 303} 304 305/*****************************************************************************/ 306 307int gralloc_perform(struct gralloc_module_t const* module, 308 int operation, ... ) 309{ 310 int res = -EINVAL; 311 va_list args; 312 va_start(args, operation); 313 switch (operation) { 314 case GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER: 315 { 316 int fd = va_arg(args, int); 317 size_t size = va_arg(args, size_t); 318 size_t offset = va_arg(args, size_t); 319 void* base = va_arg(args, void*); 320 int width = va_arg(args, int); 321 int height = va_arg(args, int); 322 int format = va_arg(args, int); 323 324 native_handle_t** handle = va_arg(args, native_handle_t**); 325 int memoryFlags = va_arg(args, int); 326 private_handle_t* hnd = (private_handle_t*)native_handle_create( 327 private_handle_t::sNumFds, private_handle_t::sNumInts); 328 hnd->magic = private_handle_t::sMagic; 329 hnd->fd = fd; 330 unsigned int contigFlags = GRALLOC_USAGE_PRIVATE_ADSP_HEAP | 331 GRALLOC_USAGE_PRIVATE_UI_CONTIG_HEAP | 332 GRALLOC_USAGE_PRIVATE_SMI_HEAP; 333 334 if (memoryFlags & contigFlags) { 335 // check if the buffer is a pmem buffer 336 pmem_region region; 337 if (ioctl(fd, PMEM_GET_SIZE, ®ion) < 0) 338 hnd->flags = private_handle_t::PRIV_FLAGS_USES_ION; 339 else 340 hnd->flags = private_handle_t::PRIV_FLAGS_USES_PMEM | 341 private_handle_t::PRIV_FLAGS_DO_NOT_FLUSH; 342 } else { 343 if (memoryFlags & GRALLOC_USAGE_PRIVATE_ION) 344 hnd->flags = private_handle_t::PRIV_FLAGS_USES_ION; 345 else 346 hnd->flags = private_handle_t::PRIV_FLAGS_USES_ASHMEM; 347 } 348 349 hnd->size = size; 350 hnd->offset = offset; 351 hnd->base = intptr_t(base) + offset; 352 hnd->gpuaddr = 0; 353 hnd->width = width; 354 hnd->height = height; 355 hnd->format = format; 356 *handle = (native_handle_t *)hnd; 357 res = 0; 358 break; 359 360 } 361 default: 362 break; 363 } 364 va_end(args); 365 return res; 366} 367