X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_bufmgr.c;h=f101e735d91f7e3d68957f1d1e1bc745846bc4e6;hb=04a7544ed0fc29da57828a30057e28cf50020c37;hp=7fb555750304f816af8dc679fd1a5f5e0043bd63;hpb=7058344e94d6d604b912cb6702ef61551598193e;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c index 7fb5557..f101e73 100644 --- a/src/tbm_bufmgr.c +++ b/src/tbm_bufmgr.c @@ -36,6 +36,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "tbm_bufmgr_backend.h" #include "list.h" +#include + #ifdef DEBUG int bDebug; #endif @@ -54,7 +56,7 @@ int b_dump_queue; static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t tbm_bufmgr_lock = PTHREAD_MUTEX_INITIALIZER; static __thread tbm_error_e tbm_last_error = TBM_ERROR_NONE; - +static double scale_factor = 0; static void _tbm_bufmgr_mutex_unlock(void); //#define TBM_BUFMGR_INIT_TIME @@ -104,6 +106,7 @@ _tbm_set_last_result(tbm_error_e err) tbm_last_error = err; } +/* LCOV_EXCL_START */ static bool _tbm_bufmgr_mutex_init(void) { @@ -113,7 +116,7 @@ _tbm_bufmgr_mutex_init(void) return true; if (pthread_mutex_init(&tbm_bufmgr_lock, NULL)) { - TBM_LOG_E("fail: tbm_bufmgr mutex init\n"); + TBM_LOG_E("fail: Cannot pthread_mutex_init for tbm_bufmgr_lock.\n"); return false; } @@ -125,8 +128,10 @@ _tbm_bufmgr_mutex_init(void) static void _tbm_bufmgr_mutex_lock(void) { - if (!_tbm_bufmgr_mutex_init()) + if (!_tbm_bufmgr_mutex_init()) { + TBM_LOG_E("fail: _tbm_bufmgr_mutex_init()\n"); return; + } pthread_mutex_lock(&tbm_bufmgr_lock); } @@ -166,7 +171,6 @@ _tbm_flag_to_str(int f) return str; } -/* LCOV_EXCL_START */ static void _tbm_util_check_bo_cnt(tbm_bufmgr bufmgr) { @@ -193,7 +197,7 @@ _tbm_util_get_max_surface_size(int *w, int *h) *w = 0; *h = 0; - if (gBufMgr == NULL || !LIST_IS_EMPTY(&gBufMgr->surf_list)) + if (gBufMgr == NULL || LIST_IS_EMPTY(&gBufMgr->surf_list)) return count; LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link) { @@ -239,12 +243,12 @@ _tbm_util_get_appname_from_pid(long pid, char *str) fp = fopen(fn_cmdline, "r"); if (fp == 0) { - fprintf(stderr, "cannot file open %s\n", fn_cmdline); + TBM_LOG_E("cannot file open %s\n", fn_cmdline); return; } if (!fgets(cmdline, 255, fp)) { - fprintf(stderr, "fail to get appname for pid(%ld)\n", pid); + TBM_LOG_E("fail to get appname for pid(%ld)\n", pid); fclose(fp); return; } @@ -283,8 +287,12 @@ tbm_user_data tbm_user_data *user_data; user_data = calloc(1, sizeof(tbm_user_data)); - if (!user_data) + if (!user_data) { + /* LCOV_EXCL_START */ + TBM_LOG_E("fail to allocate an user_date\n"); return NULL; + /* LCOV_EXCL_STOP */ + } user_data->key = key; user_data->free_func = data_free_func; @@ -423,21 +431,25 @@ _tbm_bo_unlock(tbm_bo bo) static int _tbm_bo_is_valid(tbm_bo bo) { - tbm_bo old_data; + tbm_bo old_data = NULL; if (bo == NULL || gBufMgr == NULL) { TBM_LOG_E("error: bo is NULL or tbm_bufmgr was deinited\n"); return 0; } - if (LIST_IS_EMPTY(&gBufMgr->bo_list)) + if (LIST_IS_EMPTY(&gBufMgr->bo_list)) { + TBM_LOG_E("error: gBufMgr->bo_list is EMPTY.\n"); return 0; + } LIST_FOR_EACH_ENTRY(old_data, &gBufMgr->bo_list, item_link) { if (old_data == bo) return 1; } + TBM_LOG_E("error: No valid bo(%p).\n", bo); + return 0; } @@ -610,10 +622,15 @@ tbm_bufmgr_init(int fd) } else bTrace = 0; #endif - /* LCOV_EXCL_STOP */ pthread_mutex_lock(&gLock); + if (fd >= 0) { + TBM_LOG_W("!!!!!WARNING:: The tbm_bufmgr_init DOSE NOT use argument fd ANYMORE.\n"); + TBM_LOG_W("!!!!!WARNING:: IT WILL BE CHANGED like tbm_bufmgr_init(int fd) --> tbm_bufmgr_init(void).\n"); + } + + /* initialize buffer manager */ if (gBufMgr) { gBufMgr->ref_count++; @@ -637,15 +654,15 @@ tbm_bufmgr_init(int fd) /* load bufmgr priv from env */ if (!_tbm_load_module(gBufMgr, gBufMgr->fd)) { - /* LCOV_EXCL_START */ _tbm_set_last_result(TBM_BO_ERROR_LOAD_MODULE_FAILED); TBM_LOG_E("error : Fail to load bufmgr backend\n"); free(gBufMgr); gBufMgr = NULL; pthread_mutex_unlock(&gLock); return NULL; - /* LCOV_EXCL_STOP */ + } + /* LCOV_EXCL_STOP */ /* log for tbm backend_flag */ TBM_DBG("backend flag:%x:", gBufMgr->backend->flags); @@ -757,7 +774,7 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr) int tbm_bo_size(tbm_bo bo) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; int size; _tbm_bufmgr_mutex_lock(); @@ -765,8 +782,6 @@ tbm_bo_size(tbm_bo bo) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); - bufmgr = gBufMgr; - size = bufmgr->backend->bo_size(bo); TBM_TRACE("bo(%p) size(%d)\n", bo, size); @@ -796,16 +811,13 @@ tbm_bo_ref(tbm_bo bo) void tbm_bo_unref(tbm_bo bo) { - tbm_bufmgr bufmgr = NULL; - tbm_user_data *old_data = NULL, *tmp = NULL; + tbm_bufmgr bufmgr = gBufMgr; _tbm_bufmgr_mutex_lock(); TBM_BUFMGR_RETURN_IF_FAIL(gBufMgr); TBM_BUFMGR_RETURN_IF_FAIL(_tbm_bo_is_valid(bo)); - bufmgr = gBufMgr; - TBM_TRACE("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt - 1); if (bo->ref_cnt <= 0) { @@ -817,15 +829,17 @@ tbm_bo_unref(tbm_bo bo) if (bo->ref_cnt == 0) { /* destory the user_data_list */ if (!LIST_IS_EMPTY(&bo->user_data_list)) { - LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, &bo->user_data_list, item_link) { + tbm_user_data *old_data = NULL, *tmp; + + LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, + &bo->user_data_list, item_link) { TBM_DBG("free user_data\n"); user_data_delete(old_data); } } while (bo->lock_cnt > 0) { - TBM_LOG_E("error lock_cnt:%d\n", - bo->lock_cnt); + TBM_LOG_E("error lock_cnt:%d\n", bo->lock_cnt); _bo_unlock(bo); bo->lock_cnt--; } @@ -846,8 +860,8 @@ tbm_bo_unref(tbm_bo bo) tbm_bo tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) { - tbm_bo bo = NULL; - void *bo_priv = NULL; + void *bo_priv; + tbm_bo bo; _tbm_bufmgr_mutex_lock(); @@ -857,28 +871,33 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) bo = calloc(1, sizeof(struct _tbm_bo)); if (!bo) { - TBM_TRACE("error: fail to create of tbm_bo size(%d) flag(%s)\n", + /* LCOV_EXCL_START */ + TBM_LOG_E("error: fail to create of tbm_bo size(%d) flag(%s)\n", size, _tbm_flag_to_str(flags)); _tbm_set_last_result(TBM_BO_ERROR_HEAP_ALLOC_FAILED); _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } _tbm_util_check_bo_cnt(bufmgr); - bufmgr->bo_cnt++; bo->bufmgr = bufmgr; bo_priv = bufmgr->backend->bo_alloc(bo, size, flags); if (!bo_priv) { - TBM_TRACE("error: fail to create of tbm_bo size(%d) flag(%s)\n", + /* LCOV_EXCL_START */ + TBM_LOG_E("error: fail to create of tbm_bo size(%d) flag(%s)\n", size, _tbm_flag_to_str(flags)); _tbm_set_last_result(TBM_BO_ERROR_BO_ALLOC_FAILED); free(bo); _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } + bufmgr->bo_cnt++; + bo->ref_cnt = 1; bo->flags = flags; bo->priv = bo_priv; @@ -898,10 +917,8 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) tbm_bo tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) { - tbm_bo bo = NULL; - tbm_bo bo2 = NULL; - tbm_bo tmp = NULL; - void *bo_priv = NULL; + void *bo_priv; + tbm_bo bo; _tbm_bufmgr_mutex_lock(); @@ -909,32 +926,40 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL); if (!bufmgr->backend->bo_import) { + /* LCOV_EXCL_START */ _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } _tbm_util_check_bo_cnt(bufmgr); bo = calloc(1, sizeof(struct _tbm_bo)); if (!bo) { - TBM_TRACE("error: fail to import of tbm_bo by key(%d)\n", key); + /* LCOV_EXCL_START */ + TBM_LOG_E("error: fail to import of tbm_bo by key(%d)\n", key); _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } bo->bufmgr = bufmgr; bo_priv = bufmgr->backend->bo_import(bo, key); if (!bo_priv) { - TBM_TRACE("error: fail to import of tbm_bo by key(%d)\n", key); + /* LCOV_EXCL_START */ + TBM_LOG_E("error: fail to import of tbm_bo by key(%d)\n", key); _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FAILED); free(bo); _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { - LIST_FOR_EACH_ENTRY_SAFE(bo2, tmp, &bufmgr->bo_list, item_link) { + tbm_bo bo2 = NULL; + + LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { if (bo2->priv == bo_priv) { TBM_TRACE("find bo(%p) ref(%d) key(%d) flag(%s) in list\n", bo2, bo2->ref_cnt, key, @@ -972,10 +997,8 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) tbm_bo tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) { - tbm_bo bo = NULL; - tbm_bo bo2 = NULL; - tbm_bo tmp = NULL; - void *bo_priv = NULL; + void *bo_priv; + tbm_bo bo; _tbm_bufmgr_mutex_lock(); @@ -983,32 +1006,40 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL); if (!bufmgr->backend->bo_import_fd) { + /* LCOV_EXCL_START */ _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } _tbm_util_check_bo_cnt(bufmgr); bo = calloc(1, sizeof(struct _tbm_bo)); if (!bo) { - TBM_TRACE("error: fail to import tbm_bo by tbm_fd(%d)\n", fd); + /* LCOV_EXCL_START */ + TBM_LOG_E("error: fail to import tbm_bo by tbm_fd(%d)\n", fd); _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } bo->bufmgr = bufmgr; bo_priv = bufmgr->backend->bo_import_fd(bo, fd); if (!bo_priv) { - TBM_TRACE("error: fail to import tbm_bo by tbm_fd(%d)\n", fd); + /* LCOV_EXCL_START */ + TBM_LOG_E("error: fail to import tbm_bo by tbm_fd(%d)\n", fd); _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FD_FAILED); free(bo); _tbm_bufmgr_mutex_unlock(); return NULL; + /* LCOV_EXCL_STOP */ } if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { - LIST_FOR_EACH_ENTRY_SAFE(bo2, tmp, &bufmgr->bo_list, item_link) { + tbm_bo bo2 = NULL; + + LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { if (bo2->priv == bo_priv) { TBM_TRACE("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n", bo2, bo2->ref_cnt, fd, @@ -1031,7 +1062,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) else bo->flags = TBM_BO_DEFAULT; - TBM_TRACE("import bo(%p) ref(%d) fd(%d) flag(%s)in list\n", + TBM_TRACE("import bo(%p) ref(%d) fd(%d) flag(%s)\n", bo, bo->ref_cnt, fd, _tbm_flag_to_str(bo->flags)); LIST_INITHEAD(&bo->user_data_list); @@ -1046,7 +1077,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) tbm_key tbm_bo_export(tbm_bo bo) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; tbm_key ret; _tbm_bufmgr_mutex_lock(); @@ -1054,22 +1085,24 @@ tbm_bo_export(tbm_bo bo) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); - bufmgr = gBufMgr; - if (!bufmgr->backend->bo_export) { + /* LCOV_EXCL_START */ _tbm_bufmgr_mutex_unlock(); return 0; + /* LCOV_EXCL_STOP */ } ret = bufmgr->backend->bo_export(bo); if (!ret) { + /* LCOV_EXCL_START */ _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FAILED); - TBM_TRACE("error: bo(%p) tbm_key(%d)\n", bo, ret); + TBM_LOG_E("error: bo(%p) tbm_key(%d)\n", bo, ret); _tbm_bufmgr_mutex_unlock(); return ret; + /* LCOV_EXCL_STOP */ } - TBM_TRACE("bo(%p) tbm_key(%d)\n", bo, ret); + TBM_TRACE("bo(%p) tbm_key(%u)\n", bo, ret); _tbm_bufmgr_mutex_unlock(); @@ -1079,27 +1112,29 @@ tbm_bo_export(tbm_bo bo) tbm_fd tbm_bo_export_fd(tbm_bo bo) { - tbm_bufmgr bufmgr = NULL; - int ret; + tbm_bufmgr bufmgr = gBufMgr; + tbm_fd ret; _tbm_bufmgr_mutex_lock(); TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), -1); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1); - bufmgr = gBufMgr; - if (!bufmgr->backend->bo_export_fd) { + /* LCOV_EXCL_START */ _tbm_bufmgr_mutex_unlock(); return -1; + /* LCOV_EXCL_STOP */ } ret = bufmgr->backend->bo_export_fd(bo); if (ret < 0) { + /* LCOV_EXCL_START */ _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FD_FAILED); - TBM_TRACE("error: bo(%p) tbm_fd(%d)\n", bo, ret); + TBM_LOG_E("error: bo(%p) tbm_fd(%d)\n", bo, ret); _tbm_bufmgr_mutex_unlock(); return ret; + /* LCOV_EXCL_STOP */ } TBM_TRACE("bo(%p) tbm_fd(%d)\n", bo, ret); @@ -1112,7 +1147,7 @@ tbm_bo_export_fd(tbm_bo bo) tbm_bo_handle tbm_bo_get_handle(tbm_bo bo, int device) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; tbm_bo_handle bo_handle; _tbm_bufmgr_mutex_lock(); @@ -1120,14 +1155,14 @@ tbm_bo_get_handle(tbm_bo bo, int device) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), (tbm_bo_handle) NULL); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL); - bufmgr = gBufMgr; - bo_handle = bufmgr->backend->bo_get_handle(bo, device); if (bo_handle.ptr == NULL) { + /* LCOV_EXCL_START */ _tbm_set_last_result(TBM_BO_ERROR_GET_HANDLE_FAILED); - TBM_TRACE("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr); + TBM_LOG_E("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr); _tbm_bufmgr_mutex_unlock(); return (tbm_bo_handle) NULL; + /* LCOV_EXCL_STOP */ } TBM_TRACE("bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr); @@ -1140,7 +1175,7 @@ tbm_bo_get_handle(tbm_bo bo, int device) tbm_bo_handle tbm_bo_map(tbm_bo bo, int device, int opt) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; tbm_bo_handle bo_handle; _tbm_bufmgr_mutex_lock(); @@ -1148,22 +1183,22 @@ tbm_bo_map(tbm_bo bo, int device, int opt) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), (tbm_bo_handle) NULL); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL); - bufmgr = gBufMgr; - if (!_tbm_bo_lock(bo, device, opt)) { _tbm_set_last_result(TBM_BO_ERROR_LOCK_FAILED); - TBM_TRACE("error: fail to lock bo:%p)\n", bo); + TBM_LOG_E("error: fail to lock bo:%p)\n", bo); _tbm_bufmgr_mutex_unlock(); return (tbm_bo_handle) NULL; } bo_handle = bufmgr->backend->bo_map(bo, device, opt); if (bo_handle.ptr == NULL) { + /* LCOV_EXCL_START */ _tbm_set_last_result(TBM_BO_ERROR_MAP_FAILED); - TBM_TRACE("error: fail to map bo:%p\n", bo); + TBM_LOG_E("error: fail to map bo:%p\n", bo); _tbm_bo_unlock(bo); _tbm_bufmgr_mutex_unlock(); return (tbm_bo_handle) NULL; + /* LCOV_EXCL_STOP */ } /* increase the map_count */ @@ -1179,7 +1214,7 @@ tbm_bo_map(tbm_bo bo, int device, int opt) int tbm_bo_unmap(tbm_bo bo) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; int ret; _tbm_bufmgr_mutex_lock(); @@ -1187,14 +1222,14 @@ tbm_bo_unmap(tbm_bo bo) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); - bufmgr = gBufMgr; - ret = bufmgr->backend->bo_unmap(bo); if (!ret) { - TBM_TRACE("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt); + /* LCOV_EXCL_START */ + TBM_LOG_E("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt); _tbm_set_last_result(TBM_BO_ERROR_UNMAP_FAILED); _tbm_bufmgr_mutex_unlock(); return ret; + /* LCOV_EXCL_STOP */ } /* decrease the map_count */ @@ -1212,7 +1247,7 @@ tbm_bo_unmap(tbm_bo bo) int tbm_bo_swap(tbm_bo bo1, tbm_bo bo2) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; void *temp; _tbm_bufmgr_mutex_lock(); @@ -1221,13 +1256,11 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2) TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0); - bufmgr = gBufMgr; - TBM_TRACE("before: bo1(%p) bo2(%p)\n", bo1, bo2); if (bufmgr->backend->bo_size(bo1) != bufmgr->backend->bo_size(bo2)) { _tbm_set_last_result(TBM_BO_ERROR_SWAP_FAILED); - TBM_TRACE("error: bo1(%p) bo2(%p)\n", bo1, bo2); + TBM_LOG_E("error: bo1(%p) bo2(%p)\n", bo1, bo2); _tbm_bufmgr_mutex_unlock(); return 0; } @@ -1246,17 +1279,15 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2) int tbm_bo_locked(tbm_bo bo) { - tbm_bufmgr bufmgr = NULL; + tbm_bufmgr bufmgr = gBufMgr; _tbm_bufmgr_mutex_lock(); TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); - bufmgr = gBufMgr; - if (bufmgr->lock_type == LOCK_TRY_NEVER) { - TBM_TRACE("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt); + TBM_LOG_E("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt); _tbm_bufmgr_mutex_unlock(); return 0; } @@ -1294,7 +1325,7 @@ tbm_bo_add_user_data(tbm_bo bo, unsigned long key, data = user_data_create(key, data_free_func); if (!data) { - TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key); + TBM_LOG_E("error: bo(%p) key(%lu)\n", bo, key); _tbm_bufmgr_mutex_unlock(); return 0; } @@ -1333,7 +1364,6 @@ tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data) if (old_data->data && old_data->free_func) old_data->free_func(old_data->data); - old_data->data = data; TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data); @@ -1379,7 +1409,7 @@ tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data) int tbm_bo_delete_user_data(tbm_bo bo, unsigned long key) { - tbm_user_data *old_data = (void *)0; + tbm_user_data *old_data; _tbm_bufmgr_mutex_lock(); @@ -1411,14 +1441,14 @@ tbm_bo_delete_user_data(tbm_bo bo, unsigned long key) unsigned int tbm_bufmgr_get_capability(tbm_bufmgr bufmgr) { - int capabilities = TBM_BUFMGR_CAPABILITY_NONE; + unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE; _tbm_bufmgr_mutex_lock(); TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), TBM_BUFMGR_CAPABILITY_NONE); TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, TBM_BUFMGR_CAPABILITY_NONE); - TBM_TRACE("tbm_bufmgr(%p) capability(%d)\n", bufmgr, bufmgr->capabilities); + TBM_TRACE("tbm_bufmgr(%p) capability(%u)\n", bufmgr, bufmgr->capabilities); capabilities = bufmgr->capabilities; @@ -1454,18 +1484,10 @@ tbm_get_last_error(void) } void -tbm_bufmgr_debug_show(tbm_bufmgr bufmgr) +tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr, char *str, int *len) { - tbm_bo bo = NULL, tmp_bo = NULL; - int bo_cnt = 0; - tbm_surface_h surf = NULL, tmp_surf = NULL; - int surf_cnt = 0; - int i; - char app_name[255] = {0,}; - unsigned int pid = 0; - char title[255] = {0,}; - char data[255] = {0,}; - tbm_surface_debug_data *debug_old_data = NULL, *debug_tmp = NULL; + char app_name[255] = {0,}, title[512] = {0,}; + tbm_surface_debug_data *debug_old_data = NULL; pthread_mutex_lock(&gLock); @@ -1475,37 +1497,45 @@ tbm_bufmgr_debug_show(tbm_bufmgr bufmgr) return; } - TBM_DEBUG("\n"); + TBM_SNPRINTF(str, len, "\n"); _tbm_util_get_appname_from_pid(getpid(), app_name); _tbm_util_get_appname_brief(app_name); - TBM_DEBUG("============TBM DEBUG: %s(%d)===========================\n", + TBM_SNPRINTF(str, len, "============TBM DEBUG: %s(%d)===========================\n", app_name, getpid()); - memset(app_name, 0x0, 255 * sizeof(char)); + 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_SAFE(debug_old_data, debug_tmp, &bufmgr->debug_key_list, item_link) { + LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) { strncat(title, " ", 3); strncat(title, debug_old_data->key, strlen(debug_old_data->key) + 1); } } - TBM_DEBUG("[tbm_surface information]\n"); - TBM_DEBUG("%s\n", title); + TBM_SNPRINTF(str, len, "[tbm_surface information]\n"); + TBM_SNPRINTF(str, len, "%s\n", title); + /* show the tbm_surface information in surf_list */ if (!LIST_IS_EMPTY(&bufmgr->surf_list)) { - char *value = NULL; + tbm_surface_h surf = NULL; + int surf_cnt = 0; + + LIST_FOR_EACH_ENTRY(surf, &bufmgr->surf_list, item_link) { + char data[512] = {0,}; + unsigned int pid; + int i; - LIST_FOR_EACH_ENTRY_SAFE(surf, tmp_surf, &bufmgr->surf_list, item_link) { pid = _tbm_surface_internal_get_debug_pid(surf); if (!pid) { /* if pid is null, set the self_pid */ pid = getpid(); } + memset(app_name, 0x0, 255 * sizeof(char)); _tbm_util_get_appname_from_pid(pid, app_name); _tbm_util_get_appname_brief(app_name); - snprintf(data, 255, "%-2d %-9p %-4d %-5d %-6d %-3d %-6d %-2d %-2d %-3d %-8s %-15s", + snprintf(data, 255, "%-2d %-9p %-4d %-5u %-6u %-3u %-6u %-2d %-2d %-3d %-8s %-15s", ++surf_cnt, surf, surf->refcnt, @@ -1520,7 +1550,9 @@ tbm_bufmgr_debug_show(tbm_bufmgr bufmgr) app_name); if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) { - LIST_FOR_EACH_ENTRY_SAFE(debug_old_data, debug_tmp, &bufmgr->debug_key_list, item_link) { + LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) { + char *value; + strncat(data, " ", 3); value = _tbm_surface_internal_get_debug_data(surf, debug_old_data->key); @@ -1530,29 +1562,29 @@ tbm_bufmgr_debug_show(tbm_bufmgr bufmgr) strncat(data, "none", 5); } } - TBM_DEBUG("%s\n", data); + TBM_SNPRINTF(str, len, "%s\n", data); for (i = 0; i < surf->num_bos; i++) { - TBM_DEBUG(" bo:%-12p %-26d%-10d\n", + TBM_SNPRINTF(str, len, " bo:%-12p %-26d%-10d\n", surf->bos[i], surf->bos[i]->ref_cnt, bufmgr->backend->bo_size(surf->bos[i]) / 1024); } - - memset(app_name, 0x0, 255 * sizeof(char)); } - } else { - TBM_DEBUG("no tbm_surfaces.\n"); - } - TBM_DEBUG("\n"); + } else + TBM_SNPRINTF(str, len, " no tbm_surfaces.\n"); + TBM_SNPRINTF(str, len, "\n"); - TBM_DEBUG("[tbm_bo information]\n"); - TBM_DEBUG("no bo refcnt size lock_cnt map_cnt flags surface\n"); + TBM_SNPRINTF(str, len, "[tbm_bo information]\n"); + TBM_SNPRINTF(str, len, "no bo refcnt size lock_cnt map_cnt flags surface\n"); /* show the tbm_bo information in bo_list */ if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { - LIST_FOR_EACH_ENTRY_SAFE(bo, tmp_bo, &bufmgr->bo_list, item_link) { - TBM_DEBUG("%-4d%-11p %-4d %-6d %-5d %-4d %-3d %-11p\n", + int bo_cnt = 0; + tbm_bo bo = NULL; + + LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) { + TBM_SNPRINTF(str, len, "%-4d%-11p %-4d %-6d %-5d %-4u %-3d %-11p\n", ++bo_cnt, bo, bo->ref_cnt, @@ -1562,17 +1594,25 @@ tbm_bufmgr_debug_show(tbm_bufmgr bufmgr) bo->flags, bo->surface); } - } else { - TBM_DEBUG("no tbm_bos.\n"); - } - TBM_DEBUG("\n"); + } else + TBM_SNPRINTF(str, len, "no tbm_bos.\n"); + TBM_SNPRINTF(str, len, "\n"); - TBM_DEBUG("===============================================================\n"); + TBM_SNPRINTF(str, len, "===============================================================\n"); pthread_mutex_unlock(&gLock); } void +tbm_bufmgr_debug_show(tbm_bufmgr bufmgr) +{ + char str[1024*4]; + int len = sizeof(str); + tbm_bufmgr_debug_tbm_info_get(bufmgr, str, &len); + TBM_DEBUG(" %s", str); +} + +void tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff) { _tbm_bufmgr_mutex_lock(); @@ -1588,31 +1628,43 @@ tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff) _tbm_bufmgr_mutex_unlock(); } +void +tbm_bufmgr_debug_dump_set_scale(double scale) +{ + pthread_mutex_lock(&gLock); + scale_factor = scale; + pthread_mutex_unlock(&gLock); +} + int tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff) { - int w = 0, h = 0; + pthread_mutex_lock(&gLock); - TBM_RETURN_VAL_IF_FAIL(path != NULL, 0); - TBM_LOG_D("path=%s count=%d onoff=%d\n", path, count, onoff); + if (onoff == 0) { + TBM_LOG_D("count=%d onoff=%d\n", count, onoff); + b_dump_queue = 0; + tbm_surface_internal_dump_end(); + } else { + int w, h; - pthread_mutex_lock(&gLock); + if (path == NULL) { + TBM_LOG_E("path is null"); + pthread_mutex_unlock(&gLock); + return 0; + } + TBM_LOG_D("path=%s count=%d onoff=%d\n", path, count, onoff); - if (onoff == 1) { if (_tbm_util_get_max_surface_size(&w, &h) == 0) { - TBM_LOG_I("No tbm_surface.\n"); + TBM_LOG_E("Fail to get tbm_surface size.\n"); pthread_mutex_unlock(&gLock); return 0; } - tbm_surface_internal_dump_start(path, w, h, count); + tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor); + scale_factor = 0; + b_dump_queue = 1; - } else if (onoff == 0) { - tbm_surface_internal_dump_end(); - b_dump_queue = 0; - } else { - pthread_mutex_unlock(&gLock); - return 0; } pthread_mutex_unlock(&gLock); @@ -1622,8 +1674,8 @@ tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff) int tbm_bufmgr_debug_dump_all(char *path) { - int w = 0, h = 0, count = 0; - tbm_surface_h surface = NULL, tmp = NULL; + int w, h, count = 0; + tbm_surface_h surface = NULL; TBM_RETURN_VAL_IF_FAIL(path != NULL, 0); TBM_LOG_D("path=%s\n", path); @@ -1632,16 +1684,16 @@ tbm_bufmgr_debug_dump_all(char *path) count = _tbm_util_get_max_surface_size(&w, &h); if (count == 0) { - TBM_LOG_I("No tbm_surface.\n"); + TBM_LOG_E("No tbm_surface.\n"); pthread_mutex_unlock(&gLock); return 1; } - tbm_surface_internal_dump_start(path, w, h, count); + tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor); + scale_factor = 0; - LIST_FOR_EACH_ENTRY_SAFE(surface, tmp, &gBufMgr->surf_list, item_link) { + LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link) tbm_surface_internal_dump_buffer(surface, "dump_all"); - } tbm_surface_internal_dump_end(); @@ -1682,14 +1734,16 @@ tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *NativeDisplay) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); if (!bufmgr->backend->bufmgr_bind_native_display) { - TBM_TRACE("error: tbm_bufmgr(%p) NativeDisplay(%p)\n", bufmgr, NativeDisplay); + TBM_TRACE("skip: tbm_bufmgr(%p) NativeDisplay(%p)\n", + bufmgr, NativeDisplay); _tbm_bufmgr_mutex_unlock(); return 1; } ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, NativeDisplay); if (!ret) { - TBM_TRACE("error: tbm_bufmgr(%p) NativeDisplay(%p)\n", bufmgr, NativeDisplay); + TBM_LOG_E("error: tbm_bufmgr(%p) NativeDisplay(%p)\n", + bufmgr, NativeDisplay); _tbm_bufmgr_mutex_unlock(); return 0; } @@ -1700,4 +1754,14 @@ tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *NativeDisplay) return 1; } + +int tbm_bufmgr_get_fd_limit(void) +{ + struct rlimit lim; + + if (getrlimit(RLIMIT_NOFILE, &lim)) + return 1024; + + return (int)lim.rlim_cur; +} /* LCOV_EXCL_STOP */