modules/gralloc/mapper.cpp - android_hardware_libhardware - Gitiles

 /*
  * 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.
  */

 #include <limits.h>
 #include <errno.h>
 #include <pthread.h>

 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>

 #include <cutils/log.h>
 #include <cutils/atomic.h>

 #include <hardware/hardware.h>
 #include <hardware/gralloc.h>

 #include "gralloc_priv.h"

 /*****************************************************************************/

 struct mapped_buffer_t {
     intptr_t key;
     int size;
     int base;
     int refCount;

     mapped_buffer_t() { /* no init */ };
     mapped_buffer_t(private_handle_t* hnd)
         : key(intptr_t(hnd)), size(hnd->size), base(0), refCount(0) {
     }
 };

 static int compare(const mapped_buffer_t& a, const mapped_buffer_t& b) {
     if (a.key < b.key) {
         return -1;
     }
     if (a.key > b.key) {
         return 1;
     }
     return 0;
 }

 struct mapped_buffers_t {
     pthread_mutex_t mutex;
     growable_sorted_array_t<mapped_buffer_t> records;

     int map(gralloc_module_t const* module,
             buffer_handle_t handle,
             void** vaddr)
     {
         private_handle_t* hnd = (private_handle_t*)(handle);
         mapped_buffer_t key(hnd);
         //printRecord(ANDROID_LOG_DEBUG, "map", &key);
         int result = 0;
         mapped_buffer_t* record = 0;
         pthread_mutex_lock(&mutex);
         // From here to the end of the function we return by jumping to "exit"
         // so that we always unlock the mutex.

         int index = -1;
         if (!records.find(key, index)) {
             //LOGD("New item at %d", index);
             void* mappedAddress = mmap(0, hnd->size,
                     PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);
             if (mappedAddress == MAP_FAILED) {
                 result = -errno;
                 //LOGE("map failed %d", result);
                 goto exit;
             }
             key.base = intptr_t(mappedAddress);
             records.insert(index, key);
             record = records.at(index);
         } else {
             //LOGD("Found existing mapping at index %d", index);
             record = records.at(index);
             if (record->size != key.size) {
                 LOGE("Requested a new mapping at the same offset"
                      "but with a different size");
                 printRecord(ANDROID_LOG_ERROR, "old", record);
                 printRecord(ANDROID_LOG_ERROR, "new", &key);
                 result = -EINVAL;
                 goto exit;
             }
         }
         record->refCount += 1;
         hnd->base = record->base;
         *vaddr = (void*) record->base;
     exit:
         //print();
         pthread_mutex_unlock(&mutex);
         return result;
     }

     int unmap(gralloc_module_t const* module,
             buffer_handle_t handle)
     {
         mapped_buffer_t key((private_handle_t*) handle);
         //printRecord(ANDROID_LOG_DEBUG, "unmap", &key);
         int index = -1;
         int result = 0;
         mapped_buffer_t* record = 0;
         pthread_mutex_lock(&mutex);
         // From here to the end of the function we return by jumping to "exit"
         // so that we always unlock the mutex.

         if (!records.find(key, index)) {
             // This handle is not currently locked.
             //LOGE("Could not find existing mapping near %d", index);
             result = -ENOENT;
             goto exit;
         }
         record = records.at(index);
         //printRecord(ANDROID_LOG_DEBUG, "record", record);
         record->refCount -= 1;
         if (record->refCount == 0) {
             //LOGD("Unmapping...");
             if (munmap((void*)record->base, record->size) < 0) {
                 result = -errno;
                 //LOGE("Could not unmap %d", result);
             }
             records.remove(index);
             ((private_handle_t*)handle)->base = 0;
         }

     exit:
         //print();
         pthread_mutex_unlock(&mutex);
         return result;
     }

     void print() {
         char prefix[16];
         LOGD("Dumping records: count=%d size=%d", records.count, records.size);
         for(int i=0; i<records.count ; i++) {
             sprintf(prefix, "%3d", i);
             printRecord(ANDROID_LOG_DEBUG, prefix, records.at(i));
         }
     }

     void printRecord(int level, const char* what, mapped_buffer_t* record) {
         LOG_PRI(level, LOG_TAG,
           "%s: key=0x%08x, size=0x%08x, base=0x%08x refCount=%d",
            what, int(record->key), record->size,
            record->base, record->refCount);
     }
 };

 static mapped_buffers_t sMappedBuffers  = {
     mutex: PTHREAD_MUTEX_INITIALIZER
 };

 /*****************************************************************************/

 int gralloc_map(gralloc_module_t const* module,
         buffer_handle_t handle,
         void** vaddr)
 {
     if (private_handle_t::validate(handle) < 0)
         return -EINVAL;

     private_handle_t* hnd = (private_handle_t*)(handle);
     if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
         const private_module_t* m =
             reinterpret_cast<const private_module_t*>(module);
         handle = m->framebuffer;
     }

     int err = sMappedBuffers.map(module, handle, vaddr);

     if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
         *vaddr = (void*)hnd->base;
     }

     return err;
 }

 int gralloc_unmap(gralloc_module_t const* module,
         buffer_handle_t handle)
 {
     if (private_handle_t::validate(handle) < 0)
         return -EINVAL;

     private_handle_t* hnd = (private_handle_t*)(handle);
     if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
         const private_module_t* m =
             reinterpret_cast<const private_module_t*>(module);
         handle = m->framebuffer;
     }

     return sMappedBuffers.unmap(module, handle);
 }

 int gralloc_register_buffer(gralloc_module_t const* module,
         buffer_handle_t handle)
 {
     if (private_handle_t::validate(handle) < 0)
         return -EINVAL;

     // In this implementation, we don't need to do anything here

     /* FIXME: we need to initialize the buffer as not mapped/not locked
      * because it shouldn't when this function is called the first time
      * in a new process. ideally these flags shouldn't be part of the
      * handle, but instead maintained in the kernel or at least
      * out-of-line
      */
     private_handle_t* hnd = (private_handle_t*)(handle);
     hnd->base = 0;
     hnd->flags &= ~private_handle_t::PRIV_FLAGS_MAPPED;
     hnd->lockState = 0;
     hnd->writeOwner = 0;

     return 0;
 }

 int gralloc_unregister_buffer(gralloc_module_t const* module,
         buffer_handle_t handle)
 {
     if (private_handle_t::validate(handle) < 0)
         return -EINVAL;

     /*
      * If the buffer has been mapped during a lock operation, it's time
      * to unmap it. It's an error to be here with a locked buffer.
      * NOTE: the framebuffer is handled differently and is never unmapped.
      */

     private_handle_t* hnd = (private_handle_t*)(handle);

     LOGE_IF(hnd->lockState, "handle %p still locked (state=%08x)",
             hnd, hnd->lockState);

     if (hnd->flags & private_handle_t::PRIV_FLAGS_MAPPED) {
         if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
             gralloc_unmap(module, handle);
             LOGE_IF(hnd->base,
                     "handle %p still mapped at %p",
                     hnd, (void*)hnd->base);
         }
     }

     return 0;
 }

 int gralloc_lock(gralloc_module_t const* module,
         buffer_handle_t handle, int usage,
         int l, int t, int w, int h,
         void** vaddr)
 {
     if (private_handle_t::validate(handle) < 0)
         return -EINVAL;

     int err = 0;
     private_handle_t* hnd = (private_handle_t*)(handle);
     int32_t current_value, new_value;
     int retry;

     do {
         current_value = hnd->lockState;
         new_value = current_value;

         if (current_value>>31) {
             // already locked for write
             LOGE("handle %p already locked for write", handle);
             return -EBUSY;
         } else if (current_value<<1) {
             // already locked for read
             if (usage & (GRALLOC_USAGE_SW_WRITE_MASK | GRALLOC_USAGE_HW_RENDER)) {
                 LOGE("handle %p already locked for read", handle);
                 return -EBUSY;
             } else {
                 // this is not an error
                 //LOGD("%p already locked for read... count = %d",
                 //        handle, (current_value & ~(1<<31)));
             }
         }

         // not currently locked
         if (usage & (GRALLOC_USAGE_SW_WRITE_MASK | GRALLOC_USAGE_HW_RENDER)) {
             // locking for write
             new_value |= (1<<31);
         }
         new_value++;

         retry = android_atomic_cmpxchg(current_value, new_value,
                 (volatile int32_t*)&hnd->lockState);
     } while (retry);

     if (new_value>>31) {
         // locking for write, store the tid
         hnd->writeOwner = gettid();
     }

     if (usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
         if (hnd->flags & private_handle_t::PRIV_FLAGS_MAPPED) {
             *vaddr = (void*)hnd->base;
         } else {
             hnd->flags |= private_handle_t::PRIV_FLAGS_MAPPED;
             err = gralloc_map(module, handle, vaddr);
         }
     }

     return err;
 }

 int gralloc_unlock(gralloc_module_t const* module,
         buffer_handle_t handle)
 {
     if (private_handle_t::validate(handle) < 0)
         return -EINVAL;

     private_handle_t* hnd = (private_handle_t*)(handle);
     int32_t current_value, new_value;

     do {
         current_value = hnd->lockState;
         new_value = current_value;

         if (current_value>>31) {
             // locked for write
             if (hnd->writeOwner == gettid()) {
                 hnd->writeOwner = 0;
                 new_value &= ~(1<<31);
             }
         }

         if ((new_value<<1) == 0) {
             LOGE("handle %p not locked", handle);
             return -EINVAL;
         }

         new_value--;

     } while (android_atomic_cmpxchg(current_value, new_value,
             (volatile int32_t*)&hnd->lockState));


     /* FOR DEBUGGING
     if (hnd->flags & private_handle_t::PRIV_FLAGS_MAPPED) {
         if (gralloc_unmap(module, handle) == 0) {
             hnd->flags &= ~private_handle_t::PRIV_FLAGS_MAPPED;
         }
     }
      */

     return 0;
 }
	/*
	* 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.
	*/

	#include <limits.h>
	#include <errno.h>
	#include <pthread.h>

	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <sys/types.h>

	#include <cutils/log.h>
	#include <cutils/atomic.h>

	#include <hardware/hardware.h>
	#include <hardware/gralloc.h>

	#include "gralloc_priv.h"

	/*****************************************************************************/

	struct mapped_buffer_t {
	intptr_t key;
	int size;
	int base;
	int refCount;

	mapped_buffer_t() { /* no init */ };
	mapped_buffer_t(private_handle_t* hnd)
	: key(intptr_t(hnd)), size(hnd->size), base(0), refCount(0) {
	}
	};

	static int compare(const mapped_buffer_t& a, const mapped_buffer_t& b) {
	if (a.key < b.key) {
	return -1;
	}
	if (a.key > b.key) {
	return 1;
	}
	return 0;
	}

	struct mapped_buffers_t {
	pthread_mutex_t mutex;
	growable_sorted_array_t<mapped_buffer_t> records;

	int map(gralloc_module_t const* module,
	buffer_handle_t handle,
	void** vaddr)
	{
	private_handle_t* hnd = (private_handle_t*)(handle);
	mapped_buffer_t key(hnd);
	//printRecord(ANDROID_LOG_DEBUG, "map", &key);
	int result = 0;
	mapped_buffer_t* record = 0;
	pthread_mutex_lock(&mutex);
	// From here to the end of the function we return by jumping to "exit"
	// so that we always unlock the mutex.

	int index = -1;
	if (!records.find(key, index)) {
	//LOGD("New item at %d", index);
	void* mappedAddress = mmap(0, hnd->size,
	PROT_READ\|PROT_WRITE, MAP_SHARED, hnd->fd, 0);
	if (mappedAddress == MAP_FAILED) {
	result = -errno;
	//LOGE("map failed %d", result);
	goto exit;
	}
	key.base = intptr_t(mappedAddress);
	records.insert(index, key);
	record = records.at(index);
	} else {
	//LOGD("Found existing mapping at index %d", index);
	record = records.at(index);
	if (record->size != key.size) {
	LOGE("Requested a new mapping at the same offset"
	"but with a different size");
	printRecord(ANDROID_LOG_ERROR, "old", record);
	printRecord(ANDROID_LOG_ERROR, "new", &key);
	result = -EINVAL;
	goto exit;
	}
	}
	record->refCount += 1;
	hnd->base = record->base;
	vaddr = (void) record->base;
	exit:
	//print();
	pthread_mutex_unlock(&mutex);
	return result;
	}

	int unmap(gralloc_module_t const* module,
	buffer_handle_t handle)
	{
	mapped_buffer_t key((private_handle_t*) handle);
	//printRecord(ANDROID_LOG_DEBUG, "unmap", &key);
	int index = -1;
	int result = 0;
	mapped_buffer_t* record = 0;
	pthread_mutex_lock(&mutex);
	// From here to the end of the function we return by jumping to "exit"
	// so that we always unlock the mutex.

	if (!records.find(key, index)) {
	// This handle is not currently locked.
	//LOGE("Could not find existing mapping near %d", index);
	result = -ENOENT;
	goto exit;
	}
	record = records.at(index);
	//printRecord(ANDROID_LOG_DEBUG, "record", record);
	record->refCount -= 1;
	if (record->refCount == 0) {
	//LOGD("Unmapping...");
	if (munmap((void*)record->base, record->size) < 0) {
	result = -errno;
	//LOGE("Could not unmap %d", result);
	}
	records.remove(index);
	((private_handle_t*)handle)->base = 0;
	}

	exit:
	//print();
	pthread_mutex_unlock(&mutex);
	return result;
	}

	void print() {
	char prefix[16];
	LOGD("Dumping records: count=%d size=%d", records.count, records.size);
	for(int i=0; i<records.count ; i++) {
	sprintf(prefix, "%3d", i);
	printRecord(ANDROID_LOG_DEBUG, prefix, records.at(i));
	}
	}

	void printRecord(int level, const char* what, mapped_buffer_t* record) {
	LOG_PRI(level, LOG_TAG,
	"%s: key=0x%08x, size=0x%08x, base=0x%08x refCount=%d",
	what, int(record->key), record->size,
	record->base, record->refCount);
	}
	};

	static mapped_buffers_t sMappedBuffers = {
	mutex: PTHREAD_MUTEX_INITIALIZER
	};

	/*****************************************************************************/

	int gralloc_map(gralloc_module_t const* module,
	buffer_handle_t handle,
	void** vaddr)
	{
	if (private_handle_t::validate(handle) < 0)
	return -EINVAL;

	private_handle_t* hnd = (private_handle_t*)(handle);
	if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
	const private_module_t* m =
	reinterpret_cast<const private_module_t*>(module);
	handle = m->framebuffer;
	}

	int err = sMappedBuffers.map(module, handle, vaddr);

	if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
	vaddr = (void)hnd->base;
	}

	return err;
	}

	int gralloc_unmap(gralloc_module_t const* module,
	buffer_handle_t handle)
	{
	if (private_handle_t::validate(handle) < 0)
	return -EINVAL;

	private_handle_t* hnd = (private_handle_t*)(handle);
	if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
	const private_module_t* m =
	reinterpret_cast<const private_module_t*>(module);
	handle = m->framebuffer;
	}

	return sMappedBuffers.unmap(module, handle);
	}

	int gralloc_register_buffer(gralloc_module_t const* module,
	buffer_handle_t handle)
	{
	if (private_handle_t::validate(handle) < 0)
	return -EINVAL;

	// In this implementation, we don't need to do anything here

	/* FIXME: we need to initialize the buffer as not mapped/not locked
	* because it shouldn't when this function is called the first time
	* in a new process. ideally these flags shouldn't be part of the
	* handle, but instead maintained in the kernel or at least
	* out-of-line
	*/
	private_handle_t* hnd = (private_handle_t*)(handle);
	hnd->base = 0;
	hnd->flags &= ~private_handle_t::PRIV_FLAGS_MAPPED;
	hnd->lockState = 0;
	hnd->writeOwner = 0;

	return 0;
	}

	int gralloc_unregister_buffer(gralloc_module_t const* module,
	buffer_handle_t handle)
	{
	if (private_handle_t::validate(handle) < 0)
	return -EINVAL;

	/*
	* If the buffer has been mapped during a lock operation, it's time
	* to unmap it. It's an error to be here with a locked buffer.
	* NOTE: the framebuffer is handled differently and is never unmapped.
	*/

	private_handle_t* hnd = (private_handle_t*)(handle);

	LOGE_IF(hnd->lockState, "handle %p still locked (state=%08x)",
	hnd, hnd->lockState);

	if (hnd->flags & private_handle_t::PRIV_FLAGS_MAPPED) {
	if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
	gralloc_unmap(module, handle);
	LOGE_IF(hnd->base,
	"handle %p still mapped at %p",
	hnd, (void*)hnd->base);
	}
	}

	return 0;
	}

	int gralloc_lock(gralloc_module_t const* module,
	buffer_handle_t handle, int usage,
	int l, int t, int w, int h,
	void** vaddr)
	{
	if (private_handle_t::validate(handle) < 0)
	return -EINVAL;

	int err = 0;
	private_handle_t* hnd = (private_handle_t*)(handle);
	int32_t current_value, new_value;
	int retry;

	do {
	current_value = hnd->lockState;
	new_value = current_value;

	if (current_value>>31) {
	// already locked for write
	LOGE("handle %p already locked for write", handle);
	return -EBUSY;
	} else if (current_value<<1) {
	// already locked for read
	if (usage & (GRALLOC_USAGE_SW_WRITE_MASK \| GRALLOC_USAGE_HW_RENDER)) {
	LOGE("handle %p already locked for read", handle);
	return -EBUSY;
	} else {
	// this is not an error
	//LOGD("%p already locked for read... count = %d",
	// handle, (current_value & ~(1<<31)));
	}
	}

	// not currently locked
	if (usage & (GRALLOC_USAGE_SW_WRITE_MASK \| GRALLOC_USAGE_HW_RENDER)) {
	// locking for write
	new_value \|= (1<<31);
	}
	new_value++;

	retry = android_atomic_cmpxchg(current_value, new_value,
	(volatile int32_t*)&hnd->lockState);
	} while (retry);

	if (new_value>>31) {
	// locking for write, store the tid
	hnd->writeOwner = gettid();
	}

	if (usage & (GRALLOC_USAGE_SW_READ_MASK \| GRALLOC_USAGE_SW_WRITE_MASK)) {
	if (hnd->flags & private_handle_t::PRIV_FLAGS_MAPPED) {
	vaddr = (void)hnd->base;
	} else {
	hnd->flags \|= private_handle_t::PRIV_FLAGS_MAPPED;
	err = gralloc_map(module, handle, vaddr);
	}
	}

	return err;
	}

	int gralloc_unlock(gralloc_module_t const* module,
	buffer_handle_t handle)
	{
	if (private_handle_t::validate(handle) < 0)
	return -EINVAL;

	private_handle_t* hnd = (private_handle_t*)(handle);
	int32_t current_value, new_value;

	do {
	current_value = hnd->lockState;
	new_value = current_value;

	if (current_value>>31) {
	// locked for write
	if (hnd->writeOwner == gettid()) {
	hnd->writeOwner = 0;
	new_value &= ~(1<<31);
	}
	}

	if ((new_value<<1) == 0) {
	LOGE("handle %p not locked", handle);
	return -EINVAL;
	}

	new_value--;

	} while (android_atomic_cmpxchg(current_value, new_value,
	(volatile int32_t*)&hnd->lockState));


	/* FOR DEBUGGING
	if (hnd->flags & private_handle_t::PRIV_FLAGS_MAPPED) {
	if (gralloc_unmap(module, handle) == 0) {
	hnd->flags &= ~private_handle_t::PRIV_FLAGS_MAPPED;
	}
	}
	*/

	return 0;
	}