X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_bufmgr.c;h=a056c03205fd2ff30487953128675a4e5337d198;hb=e565c41f907df4ed8a2b85d304bf11cc3ba0724d;hp=2a8ec4a574625cc7f2e1d7a83e5f1734e0c71cfa;hpb=711993bf656bff44e4057c59520eca1465652999;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c index 2a8ec4a..a056c03 100644 --- a/src/tbm_bufmgr.c +++ b/src/tbm_bufmgr.c @@ -33,7 +33,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "tbm_bufmgr.h" #include "tbm_bufmgr_int.h" -#include "tbm_bufmgr_backend.h" +#include "tbm_drm_helper.h" #include "list.h" #include @@ -50,26 +50,10 @@ int b_dump_queue; static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t tbm_bufmgr_lock = PTHREAD_MUTEX_INITIALIZER; static double scale_factor = 0; -static void _tbm_bufmgr_mutex_unlock(void); +void _tbm_bufmgr_mutex_unlock(void); //#define TBM_BUFMGR_INIT_TIME -#define PREFIX_LIB "libtbm_" -#define SUFFIX_LIB ".so" -#define DEFAULT_LIB PREFIX_LIB"default"SUFFIX_LIB - -/* values to indicate unspecified fields in XF86ModReqInfo. */ -#define MAJOR_UNSPEC 0xFF -#define MINOR_UNSPEC 0xFF -#define PATCH_UNSPEC 0xFFFF -#define ABI_VERS_UNSPEC 0xFFFFFFFF - -#define MODULE_VERSION_NUMERIC(maj, min, patch) \ - ((((maj) & 0xFF) << 24) | (((min) & 0xFF) << 16) | (patch & 0xFFFF)) -#define GET_MODULE_MAJOR_VERSION(vers) (((vers) >> 24) & 0xFF) -#define GET_MODULE_MINOR_VERSION(vers) (((vers) >> 16) & 0xFF) -#define GET_MODULE_PATCHLEVEL(vers) ((vers) & 0xFFFF) - #define MAX_SIZE_N(dest) (sizeof(dest) - strlen(dest) - 1) /* check condition */ @@ -92,36 +76,41 @@ static void _tbm_bufmgr_mutex_unlock(void); } /* LCOV_EXCL_START */ -static bool -_tbm_bufmgr_mutex_init(void) -{ - static bool tbm_bufmgr_mutex_init = false; - if (tbm_bufmgr_mutex_init) - return true; +static void +_tbm_bufmgr_check_bo_cnt(tbm_bufmgr bufmgr) +{ + static int last_chk_bo_cnt = 0; - if (pthread_mutex_init(&tbm_bufmgr_lock, NULL)) { - TBM_ERR("fail: Cannot pthread_mutex_init for tbm_bufmgr_lock.\n"); - return false; + if ((bufmgr->bo_cnt >= 500) && ((bufmgr->bo_cnt % 20) == 0) && + (bufmgr->bo_cnt > last_chk_bo_cnt)) { + TBM_DBG("============TBM BO CNT DEBUG: bo_cnt=%d\n", bufmgr->bo_cnt); + tbm_bufmgr_debug_show(bufmgr); + last_chk_bo_cnt = bufmgr->bo_cnt; } +} + +static void +_tbm_bufmgr_initialize_bo(tbm_bufmgr bufmgr, tbm_bo bo, int flags) +{ + bo->bufmgr = bufmgr; + bo->flags = flags; + bo->magic = TBM_BO_MAGIC; + bo->ref_cnt = 1; - tbm_bufmgr_mutex_init = true; + LIST_INITHEAD(&bo->user_data_list); - return true; + bufmgr->bo_cnt++; + LIST_ADD(&bo->item_link, &bufmgr->bo_list); } -static void +void _tbm_bufmgr_mutex_lock(void) { - if (!_tbm_bufmgr_mutex_init()) { - TBM_ERR("fail: _tbm_bufmgr_mutex_init()\n"); - return; - } - pthread_mutex_lock(&tbm_bufmgr_lock); } -static void +void _tbm_bufmgr_mutex_unlock(void) { pthread_mutex_unlock(&tbm_bufmgr_lock); @@ -179,6 +168,8 @@ _tbm_util_get_appname_from_pid(long pid, char *str) FILE *fp; int len; + if (pid <= 0) return; + snprintf(fn_cmdline, sizeof(fn_cmdline), "/proc/%ld/cmdline", pid); fp = fopen(fn_cmdline, "r"); @@ -204,290 +195,48 @@ _tbm_util_get_appname_from_pid(long pid, char *str) snprintf(str, sizeof(cmdline), "%s", cmdline); } -static int -_check_version(TBMModuleVersionInfo *data) -{ - int abimaj, abimin; - int vermaj, vermin; - - abimaj = GET_ABI_MAJOR(data->abiversion); - abimin = GET_ABI_MINOR(data->abiversion); - - TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n", - data->modname ? data->modname : "UNKNOWN!", - data->vendor ? data->vendor : "UNKNOWN!", abimaj, abimin); - - vermaj = GET_ABI_MAJOR(TBM_ABI_VERSION); - vermin = GET_ABI_MINOR(TBM_ABI_VERSION); - - TBM_DBG("TBM ABI version %d.%d\n", - vermaj, vermin); - - if (abimaj != vermaj) { - TBM_ERR("TBM module ABI major ver(%d) doesn't match the TBM's ver(%d)\n", - abimaj, vermaj); - return 0; - } else if (abimin > vermin) { - TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n", - abimin, vermin); - return 0; - } - - return 1; -} - -static int -_tbm_backend_check_bufmgr_func(tbm_backend_bufmgr_func *bufmgr_func) -{ - TBM_RETURN_VAL_IF_FAIL(bufmgr_func, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_supported_formats, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_plane_data, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, 0); /* mandatory symbol */ - if (!bufmgr_func->bufmgr_alloc_bo_with_format) - TBM_DBG("No bufmgr_func->bufmgr_alloc_bo_with_format."); - TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_import_fd, 0); /* mandatory symbol */ - if (!bufmgr_func->bufmgr_import_key) - TBM_DBG("No bufmgr_func->bo_export_key."); - - return 1; -} - -static int -_tbm_backend_check_bufmgr_bo(tbm_backend_bo_func *bo_func) -{ - TBM_RETURN_VAL_IF_FAIL(bo_func, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_free, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_size, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_memory_types, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_handle, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_map, 0); /* mandatory symbol */ - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, 0); /* mandatory symbol */ - if (!bo_func->bo_lock) - TBM_DBG("No bo_func->bo_lock."); - if (!bo_func->bo_unlock) - TBM_DBG("No bo_func->bo_unlock."); - TBM_RETURN_VAL_IF_FAIL(bo_func->bo_export_fd, 0); /* mandatory symbol */ - if (!bo_func->bo_export_key) - TBM_INFO("No bo_func->bo_export_key."); - - return 1; -} - -static int -_tbm_backend_load_module(tbm_bufmgr bufmgr, const char *file) -{ - char path[PATH_MAX] = {0, }; - void *module_data = NULL; - tbm_backend_module *backend_module_data = NULL; - tbm_backend_bufmgr_data *bufmgr_data = NULL; - int abimaj, abimin; - int vermaj, vermin; - tbm_error_e error; - - snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file); - - module_data = dlopen(path, RTLD_LAZY); - if (!module_data) { - TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file); - return 0; - } - - backend_module_data = dlsym(module_data, "tbm_backend_module_data"); - if (!backend_module_data) { - TBM_ERR("Error: module does not have data object.\n"); - goto err; - } - - abimaj = GET_ABI_MAJOR(backend_module_data->abi_version); - abimin = GET_ABI_MINOR(backend_module_data->abi_version); - - TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n", - backend_module_data->name ? backend_module_data->name : "UNKNOWN!", - backend_module_data->vendor ? backend_module_data->vendor : "UNKNOWN!", - abimaj, abimin); - - vermaj = GET_ABI_MAJOR(TBM_BACKEND_ABI_LATEST_VERSION); - vermin = GET_ABI_MINOR(TBM_BACKEND_ABI_LATEST_VERSION); - TBM_DBG("TBM ABI version %d.%d\n", vermaj, vermin); - - if (abimaj > vermaj) { - TBM_ERR("TBM module ABI major ver(%d) is newer than the TBM's ver(%d)\n", - abimaj, vermaj); - goto err; - } else if (abimin > vermin) { - TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n", - abimin, vermin); - goto err; - } - - if (!backend_module_data->init) { - TBM_ERR("Error: module does not supply init symbol.\n"); - goto err; - } - - if (!backend_module_data->deinit) { - TBM_ERR("Error: module does not supply deinit symbol.\n"); - goto err; - } - - bufmgr_data = backend_module_data->init(bufmgr, &error); - if (!bufmgr_data) { - TBM_ERR("Fail to init module(%s)\n", file); - goto err; - } - - /* check the mandatory symbols of the backend module */ - if (!_tbm_backend_check_bufmgr_func(bufmgr->bufmgr_func)) { - TBM_ERR("Fail to check the bufmgr_func symboles."); - goto err; - } - - if (!_tbm_backend_check_bufmgr_bo(bufmgr->bo_func)) { - TBM_ERR("Fail to check the bufmgr_bo symboles."); - goto err; - } - - /* get the capability */ - bufmgr->capabilities = bufmgr->bufmgr_func->bufmgr_get_capabilities(bufmgr_data, &error); - if (bufmgr->capabilities == TBM_BUFMGR_CAPABILITY_NONE) { - TBM_ERR("The capabilities of the backend module is TBM_BUFMGR_CAPABILITY_NONE."); - TBM_ERR("TBM_BUFMGR_CAPABILITY_SHARE_FD is the essential capability."); - goto err; - } - - if (!(bufmgr->capabilities & TBM_BUFMGR_CAPABILITY_SHARE_FD)) { - TBM_ERR("The capabilities of the backend module had no TBM_BUFMGR_CAPABILITY_SHARE_FD."); - TBM_ERR("The tbm backend has to get TBM_BUFMGR_CAPABILITY_SHARE_FD. "); - goto err; - } - - bufmgr->module_data = module_data; - bufmgr->backend_module_data = backend_module_data; - bufmgr->bufmgr_data = bufmgr_data; - - TBM_DBG("Success to load module(%s)\n", file); - - return 1; - -err: - if (bufmgr_data) - bufmgr->backend_module_data->deinit(bufmgr_data); - if (module_data) - dlclose(module_data); - - return 0; -} - -static int -_tbm_bufmgr_load_module(tbm_bufmgr bufmgr, int fd, const char *file) +static void +_tbm_bufmgr_copy_module_data(tbm_bufmgr bufmgr, tbm_module *module, int reset) { - char path[PATH_MAX] = {0, }; - TBMModuleVersionInfo *vers; - TBMModuleData *initdata; - ModuleInitProc init; - void *module_data; - - snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file); - - module_data = dlopen(path, RTLD_LAZY); - if (!module_data) { - TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file); - return 0; - } - - initdata = dlsym(module_data, "tbmModuleData"); - if (!initdata) { - TBM_ERR("Error: module does not have data object.\n"); - goto err; - } - - vers = initdata->vers; - if (!vers) { - TBM_ERR("Error: module does not supply version information.\n"); - goto err; - } - - init = initdata->init; - if (!init) { - TBM_ERR("Error: module does not supply init symbol.\n"); - goto err; - } - - if (!_check_version(vers)) { - TBM_ERR("Fail to check version.\n"); - goto err; - } + if (!reset) { + bufmgr->module_data = module->module_data; + bufmgr->backend = module->backend; + + bufmgr->backend_module_data = module->backend_module_data; + bufmgr->bufmgr_data = module->bufmgr_data; + bufmgr->bufmgr_func = module->bufmgr_func; + bufmgr->bo_func = module->bo_func; + + bufmgr->use_hal_tbm = module->use_hal_tbm; + bufmgr->auth_wl_socket_created = module->auth_wl_socket_created; + bufmgr->auth_fd = module->auth_fd; + bufmgr->hal_backend = module->hal_backend; + bufmgr->hal_bufmgr = module->hal_bufmgr; + } else { + bufmgr->module_data = NULL; + bufmgr->backend = NULL; - if (!init(bufmgr, fd)) { - TBM_ERR("Fail to init module(%s)\n", file); - goto err; - } + bufmgr->backend_module_data = NULL; + bufmgr->bufmgr_data = NULL; + bufmgr->bufmgr_func = NULL; + bufmgr->bo_func = NULL; - if (!bufmgr->backend || !bufmgr->backend->priv) { - TBM_ERR("Error: module(%s) wrong operation. Check backend or backend's priv.\n", file); - goto err; + bufmgr->use_hal_tbm = 0; + bufmgr->auth_wl_socket_created = 0; + bufmgr->auth_fd = -1; + bufmgr->hal_backend = NULL; + bufmgr->hal_bufmgr = NULL; } - - bufmgr->module_data = module_data; - - TBM_DBG("Success to load module(%s)\n", file); - - return 1; - -err: - dlclose(module_data); - return 0; } -static int -_tbm_load_module(tbm_bufmgr bufmgr, int fd) -{ - struct dirent **namelist; - int ret = 0, n; - - /* try to load the new backend module */ - ret = _tbm_backend_load_module(bufmgr, DEFAULT_LIB); - if (ret) - return 1; - - /* try to load the old(deprecated) backend mdoule */ - ret = _tbm_bufmgr_load_module(bufmgr, fd, DEFAULT_LIB); - if (ret) - return 1; - - /* load bufmgr priv from configured path */ - n = scandir(BUFMGR_MODULE_DIR, &namelist, 0, alphasort); - if (n < 0) { - TBM_ERR("no files : %s\n", BUFMGR_MODULE_DIR); - return 0; - } - - while (n--) { - if (!ret && strstr(namelist[n]->d_name, PREFIX_LIB)) { - const char *p = strstr(namelist[n]->d_name, SUFFIX_LIB); - - if (p && !strcmp(p, SUFFIX_LIB)) { - ret = _tbm_backend_load_module(bufmgr, namelist[n]->d_name); - if (!ret) - ret = _tbm_bufmgr_load_module(bufmgr, fd, - namelist[n]->d_name); - } - } - - free(namelist[n]); - } - - free(namelist); - return ret; -} /* LCOV_EXCL_STOP */ static tbm_bufmgr _tbm_bufmgr_init(int fd, int server) { + tbm_error_e error = TBM_ERROR_NONE; + #ifdef TBM_BUFMGR_INIT_TIME struct timeval start_tv, end_tv; #endif @@ -498,16 +247,9 @@ _tbm_bufmgr_init(int fd, int server) gettimeofday(&start_tv, NULL); #endif - /* LCOV_EXCL_START */ -#ifdef HAVE_DLOG - env = getenv("TBM_DLOG"); - if (env) { - bDlog = atoi(env); - TBM_DBG("TBM_DLOG=%s\n", env); - } else - bDlog = 1; -#endif + bDlog = 1; + /* LCOV_EXCL_START */ #ifdef TRACE env = getenv("TBM_TRACE"); if (env) { @@ -555,7 +297,8 @@ _tbm_bufmgr_init(int fd, int server) } /* load bufmgr priv from env */ - if (!_tbm_load_module(gBufMgr, gBufMgr->fd)) { + gBufMgr->module = tbm_module_load(gBufMgr->fd); + if (!gBufMgr->module) { TBM_ERR("error : Fail to load bufmgr backend\n"); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); free(gBufMgr); @@ -564,6 +307,34 @@ _tbm_bufmgr_init(int fd, int server) return NULL; } + + // TODO: this is temporary. it will be removed after finishing refactoring the tbm_module. + _tbm_bufmgr_copy_module_data(gBufMgr, gBufMgr->module, 0); + + /* check the essential capabilities of tbm_module */ + gBufMgr->capabilities = tbm_module_bufmgr_get_capabilities(gBufMgr->module, &error); + if (gBufMgr->capabilities == TBM_BUFMGR_CAPABILITY_NONE) { + TBM_ERR("The capabilities of the backend module is TBM_BUFMGR_CAPABILITY_NONE."); + TBM_ERR("TBM_BUFMGR_CAPABILITY_SHARE_FD is the essential capability."); + tbm_module_unload(gBufMgr->module); + _tbm_set_last_result(error); + free(gBufMgr); + gBufMgr = NULL; + pthread_mutex_unlock(&gLock); + return NULL; + } + + if (!(gBufMgr->capabilities & TBM_BUFMGR_CAPABILITY_SHARE_FD)) { + TBM_ERR("The capabilities of the backend module had no TBM_BUFMGR_CAPABILITY_SHARE_FD."); + TBM_ERR("The tbm backend has to get TBM_BUFMGR_CAPABILITY_SHARE_FD. "); + tbm_module_unload(gBufMgr->module); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); + free(gBufMgr); + gBufMgr = NULL; + pthread_mutex_unlock(&gLock); + return NULL; + } + /* LCOV_EXCL_STOP */ gBufMgr->ref_count = 1; @@ -663,28 +434,16 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr) LIST_DELINIT(&bufmgr->surf_list); } - if (bufmgr->backend_module_data) { - /* deinit and backend destroys the backend func and data */ - bufmgr->backend_module_data->deinit(bufmgr->bufmgr_data); - bufmgr->bo_func = NULL; - bufmgr->bufmgr_func = NULL; - bufmgr->bufmgr_data = NULL; - bufmgr->backend_module_data = NULL; - } else { - /* destroy bufmgr priv */ - bufmgr->backend->bufmgr_deinit(bufmgr->backend->priv); - bufmgr->backend->priv = NULL; - tbm_backend_free(bufmgr->backend); - bufmgr->backend = NULL; - } - - TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr); + tbm_module_unload(bufmgr->module); - dlclose(bufmgr->module_data); + // TODO: this is temporary. it will be removed after finishing refactoring the tbm_module. + _tbm_bufmgr_copy_module_data(bufmgr, bufmgr->module, 1); if (bufmgr->fd > 0) close(bufmgr->fd); + TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr); + free(bufmgr); gBufMgr = NULL; @@ -721,6 +480,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) int c = 0; int size; tbm_error_e error; + long pid = 0; pthread_mutex_lock(&gLock); _tbm_set_last_result(TBM_ERROR_NONE); @@ -741,12 +501,13 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) } TBM_SNRPRINTF(str, len, c, "\n"); - _tbm_util_get_appname_from_pid(getpid(), app_name); + pid = syscall(SYS_getpid); + _tbm_util_get_appname_from_pid(pid, app_name); _tbm_util_get_appname_brief(app_name); - TBM_SNRPRINTF(str, len, c, "============TBM DEBUG: %s(%d)===========================\n", - app_name, getpid()); + TBM_SNRPRINTF(str, len, c, "===========================================TBM DEBUG: %s(%ld)===========================================\n", + app_name, pid); - snprintf(title, 255, "%s", "no surface refcnt width height bpp size n_b n_p flags format app_name "); + snprintf(title, 255, "%s", "no surface refcnt width height bpp size n_b n_p flags format app_name "); if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) { LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) { @@ -765,20 +526,24 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) LIST_FOR_EACH_ENTRY(surf, &bufmgr->surf_list, item_link) { char data[512] = {0,}; - unsigned int pid; + unsigned int surf_pid = 0; int i; - pid = _tbm_surface_internal_get_debug_pid(surf); - if (!pid) { + surf_pid = _tbm_surface_internal_get_debug_pid(surf); + if (!surf_pid) { /* if pid is null, set the self_pid */ - pid = getpid(); + surf_pid = syscall(SYS_getpid);; } memset(app_name, 0x0, 255 * sizeof(char)); - _tbm_util_get_appname_from_pid(pid, app_name); - _tbm_util_get_appname_brief(app_name); + if (geteuid() == 0) { + _tbm_util_get_appname_from_pid(surf_pid, app_name); + _tbm_util_get_appname_brief(app_name); + } else { + snprintf(app_name, sizeof(app_name), "%d", surf_pid); + } - snprintf(data, 255, "%-2d %-9p %-4d %-5u %-6u %-3u %-6u %-2d %-2d %-3d %-8s %-15s", + snprintf(data, 255, "%-3d %-11p %-5d %-6u %-7u %-4u %-7u %-3d %-3d %-8d %-9s %-22s", ++surf_cnt, surf, surf->refcnt, @@ -808,7 +573,11 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) TBM_SNRPRINTF(str, len, c, "%s\n", data); for (i = 0; i < surf->num_bos; i++) { - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + size = hal_tbm_bo_get_size((hal_tbm_bo *)surf->bos[i]->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) + TBM_WRN("fail to get the size of bo."); + } else if (bufmgr->backend_module_data) { size = bufmgr->bo_func->bo_get_size(surf->bos[i]->bo_data, &error); if (error != TBM_ERROR_NONE) TBM_WRN("fail to get the size of bo."); @@ -825,7 +594,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) TBM_SNRPRINTF(str, len, c, "\n"); TBM_SNRPRINTF(str, len, c, "[tbm_bo information]\n"); - TBM_SNRPRINTF(str, len, c, "no bo refcnt size lock_cnt map_cnt flags surface name\n"); + TBM_SNRPRINTF(str, len, c, "no bo refcnt size lock_cnt map_cnt flags surface name\n"); /* show the tbm_bo information in bo_list */ if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { @@ -834,7 +603,12 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) tbm_key key = 0; LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) { - if (bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) + TBM_WRN("fail to get the size of bo."); + key = (tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + } else if (bufmgr->backend_module_data) { size = bufmgr->bo_func->bo_get_size(bo->bo_data, &error); if (error != TBM_ERROR_NONE) TBM_WRN("fail to get the size of bo."); @@ -845,7 +619,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) size = bufmgr->backend->bo_size(bo); key = bufmgr->backend->bo_export(bo); } - TBM_SNRPRINTF(str, len, c, "%-4d%-11p %-4d %-6d %-5d %-4u %-3d %-11p %-4d\n", + TBM_SNRPRINTF(str, len, c, "%-3d %-11p %-5d %-7d %-6d %-5u %-7d %-11p %-4d\n", ++bo_cnt, bo, bo->ref_cnt, @@ -860,7 +634,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n"); TBM_SNRPRINTF(str, len, c, "\n"); - TBM_SNRPRINTF(str, len, c, "===============================================================\n"); + TBM_SNRPRINTF(str, len, c, "========================================================================================================\n"); pthread_mutex_unlock(&gLock); @@ -1044,49 +818,24 @@ _tbm_bufmgr_get_bufmgr(void) int tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display) { - int ret; tbm_error_e error; _tbm_bufmgr_mutex_lock(); _tbm_set_last_result(TBM_ERROR_NONE); - TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); + TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), 0); - if (bufmgr->backend_module_data) { - if (!bufmgr->bufmgr_func->bufmgr_bind_native_display) { - TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n", - bufmgr, native_display); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - _tbm_bufmgr_mutex_unlock(); - return 1; - } + error = tbm_module_bufmgr_bind_native_display(bufmgr->module, native_display); + if (error != TBM_ERROR_NONE) { + _tbm_set_last_result(error); + _tbm_bufmgr_mutex_unlock(); - error = bufmgr->bufmgr_func->bufmgr_bind_native_display(bufmgr->bufmgr_data, (tbm_native_display *)native_display); - if (error != TBM_ERROR_NONE) { - TBM_ERR("error: tbm_bufmgr(%p) native_display(%p) error(%d)\n", - bufmgr, native_display, error); - _tbm_set_last_result(error); - _tbm_bufmgr_mutex_unlock(); - return 0; - } - ret = 1; - } else { - if (!bufmgr->backend->bufmgr_bind_native_display) { - TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n", - bufmgr, native_display); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - _tbm_bufmgr_mutex_unlock(); + if (error == TBM_ERROR_NOT_SUPPORTED) { + TBM_WRN("Not supported, so skip: tbm_bufmgr(%p) native_display(%p)", bufmgr, native_display); return 1; } - ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, native_display); - if (!ret) { - TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n", - bufmgr, native_display); - _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - _tbm_bufmgr_mutex_unlock(); - return 0; - } + return 0; } TBM_INFO("tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display); @@ -1141,4 +890,271 @@ tbm_bufmgr tbm_bufmgr_get(void) { return gBufMgr; } + + +tbm_bo +tbm_bufmgr_internal_find_bo(tbm_bufmgr bufmgr, tbm_bo bo) +{ + tbm_bo bo2 = NULL; + + TBM_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), NULL); + TBM_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL); + + if (LIST_IS_EMPTY(&bufmgr->bo_list)) + return NULL; + + LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { + if (bo2->bo_data == bo->bo_data) { + return bo2; + } + } + + return NULL; +} + +tbm_bo +tbm_bufmgr_internal_alloc_bo(tbm_bufmgr bufmgr, int size, int flags, tbm_error_e *error) +{ + tbm_bo bo; + tbm_backend_bo_data *bo_data; + + _tbm_bufmgr_check_bo_cnt(bufmgr); + + bo = calloc(1, sizeof(struct _tbm_bo)); + if (!bo) { + /* LCOV_EXCL_START */ + TBM_ERR("memory allocationc failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + /* LCOV_EXCL_STOP */ + } + + bo_data = tbm_module_bufmgr_bo_alloc(bufmgr->module, bo, size, flags, error); + if (!bo_data) { + /* LCOV_EXCL_START */ + TBM_ERR("tbm_module_bufmgr_bo_alloc failed. size:%d flags:%s error:%d", size, _tbm_flag_to_str(flags), *error); + free(bo); + return NULL; + /* LCOV_EXCL_STOP */ + } + bo->bo_data = bo_data; + bo->priv = (void *)bo_data; // TODO: this will be DEPRECATED. + + _tbm_bufmgr_initialize_bo(bufmgr, bo, flags); + + return bo; +} + + +/* LCOV_EXCL_START */ + +tbm_bo +tbm_bufmgr_internal_alloc_bo_with_format(tbm_bufmgr bufmgr, int format, int bo_idx, int width, + int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error) +{ + tbm_bo bo = NULL; + + _tbm_bufmgr_mutex_lock(); + _tbm_set_last_result(TBM_ERROR_NONE); + + TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL); + + _tbm_bufmgr_check_bo_cnt(bufmgr); + + bo = calloc(1, sizeof(struct _tbm_bo)); + if (!bo) { + /* LCOV_EXCL_START */ + TBM_ERR("memory allocationc failed."); + _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); + /* LCOV_EXCL_STOP */ + goto fail; + } + + bo->bo_data = tbm_module_bufmgr_bo_alloc_with_format(bufmgr->module, format, bo_idx, width, height, bpp, flags, error); + if (!bo->bo_data) { + /* LCOV_EXCL_START */ + _tbm_set_last_result(*error); + /* LCOV_EXCL_STOP */ + goto fail; + } + + _tbm_bufmgr_initialize_bo(bufmgr, bo, flags); + + _tbm_bufmgr_mutex_unlock(); + + return bo; + +fail: + if (bo) + free(bo); + _tbm_bufmgr_mutex_unlock(); + + return NULL; +} + +tbm_bo +tbm_bufmgr_internal_alloc_bo_with_bo_data(tbm_bufmgr bufmgr, tbm_backend_bo_data *bo_data, int flags) +{ + tbm_bo bo, bo2 = NULL; + + _tbm_bufmgr_mutex_lock(); + _tbm_set_last_result(TBM_ERROR_NONE); + + TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL); + TBM_BUFMGR_RETURN_VAL_IF_FAIL(bo_data, NULL); + + _tbm_bufmgr_check_bo_cnt(bufmgr); + + bo = calloc(1, sizeof(struct _tbm_bo)); + if (!bo) { + /* LCOV_EXCL_START */ + TBM_ERR("memory allocationc failed."); + _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); + _tbm_bufmgr_mutex_unlock(); + return NULL; + /* LCOV_EXCL_STOP */ + } + bo->bo_data = bo_data; + bo->get_from_hal_surface = 1; + + // return an existed bo if the bo is already created with the same bo_data. + bo2 = tbm_bufmgr_internal_find_bo(bufmgr, bo); + if (bo2) { + bo2->ref_cnt++; + free(bo); + _tbm_bufmgr_mutex_unlock(); + return bo2; + } + + _tbm_bufmgr_initialize_bo(bufmgr, bo, flags); + + TBM_TRACE_BO("bo(%p) refcnt(%d), flag(%s)", bo, bo->ref_cnt, _tbm_flag_to_str(bo->flags)); + + _tbm_bufmgr_mutex_unlock(); + + return bo; +} + +tbm_bo +tbm_bufmgr_internal_import_bo_with_key(tbm_bufmgr bufmgr, unsigned int key, tbm_error_e *error) +{ + tbm_bo bo, bo2; + int flags; + + _tbm_bufmgr_check_bo_cnt(bufmgr); + + bo = calloc(1, sizeof(struct _tbm_bo)); + if (!bo) { + /* LCOV_EXCL_START */ + TBM_ERR("memory allocationc failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + /* LCOV_EXCL_STOP */ + } + + bo->bo_data = tbm_module_bufmgr_bo_import_key(bufmgr->module, bo, key, error); + if (!bo->bo_data) { + /* LCOV_EXCL_START */ + TBM_ERR("tbm_module_bufmgr_bo_import_key failed. tbm_key:%d", key); + free(bo); + return NULL; + /* LCOV_EXCL_STOP */ + } + + // return the existed bo2 if bo->bo_data and bo2->bo_data is the same + bo2 = tbm_bufmgr_internal_find_bo(bufmgr, bo); + if (bo2) { + TBM_TRACE_BO("find bo(%p) ref(%d) key(%d) flag(%s) in list", + bo2, bo2->ref_cnt, key, _tbm_flag_to_str(bo2->flags)); + bo2->ref_cnt++; + free(bo); + return bo2; + } + + // TODO: refactoring tbm_module_bo + if (bufmgr->use_hal_tbm) { + flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)error); + if (*error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the bo flags(memory_types)"); + flags = TBM_BO_DEFAULT; + } + } else if (bufmgr->backend_module_data) { + flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, error); + if (error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the bo flags(memory_types)"); + flags = TBM_BO_DEFAULT; + } + } else { + if (bufmgr->backend->bo_get_flags) + flags = bufmgr->backend->bo_get_flags(bo); + else + flags = TBM_BO_DEFAULT; + } + + _tbm_bufmgr_initialize_bo(bufmgr, bo, flags); + + return bo; +} + +tbm_bo +tbm_bufmgr_internal_import_bo_with_fd(tbm_bufmgr bufmgr, tbm_fd fd, tbm_error_e *error) +{ + tbm_bo bo, bo2; + int flags; + + _tbm_bufmgr_check_bo_cnt(bufmgr); + + bo = calloc(1, sizeof(struct _tbm_bo)); + if (!bo) { + /* LCOV_EXCL_START */ + TBM_ERR("memory allocationc failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + /* LCOV_EXCL_STOP */ + } + + bo->bo_data = tbm_module_bufmgr_bo_import_fd(bufmgr->module, bo, fd, error); + if (!bo->bo_data) { + /* LCOV_EXCL_START */ + TBM_ERR("tbm_module_bufmgr_bo_import_fd failed. tbm_fd:%d", fd); + free(bo); + return NULL; + /* LCOV_EXCL_STOP */ + } + + // return the existed bo2 if bo->bo_data and bo2->bo_data is the same + bo2 = tbm_bufmgr_internal_find_bo(bufmgr, bo); + if (bo2) { + TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list", + bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags)); + bo2->ref_cnt++; + free(bo); + return bo2; + } + + // TODO: refactoring tbm_module_bo + if (bufmgr->use_hal_tbm) { + flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)error); + if (error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the bo flags(memory_types)"); + flags = TBM_BO_DEFAULT; + } + } else if (bufmgr->backend_module_data) { + flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, error); + if (error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the bo flags(memory_types)"); + flags = TBM_BO_DEFAULT; + } + } else { + if (bufmgr->backend->bo_get_flags) + flags = bufmgr->backend->bo_get_flags(bo); + else + flags = TBM_BO_DEFAULT; + } + + _tbm_bufmgr_initialize_bo(bufmgr, bo, flags); + + return bo; +} + /* LCOV_EXCL_STOP */