X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_bufmgr.c;h=8f39d721bd3e3bafe9d35e828c27bc934112d8eb;hb=e5c10c6c0868e37c78ba5cd2bcf0fb9d05daf733;hp=ab0f840b700f8c237cc1426361c4851e5eb5767b;hpb=71008c3e0a2ae825b26af078df92ee71c0451eec;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c index ab0f840..8f39d72 100644 --- a/src/tbm_bufmgr.c +++ b/src/tbm_bufmgr.c @@ -76,6 +76,7 @@ static void _tbm_bufmgr_mutex_unlock(void); #define TBM_BUFMGR_RETURN_IF_FAIL(cond) {\ if (!(cond)) {\ TBM_ERR("'%s' failed.\n", #cond);\ + _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\ _tbm_bufmgr_mutex_unlock();\ return;\ } \ @@ -84,6 +85,7 @@ static void _tbm_bufmgr_mutex_unlock(void); #define TBM_BUFMGR_RETURN_VAL_IF_FAIL(cond, val) {\ if (!(cond)) {\ TBM_ERR("'%s' failed.\n", #cond);\ + _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\ _tbm_bufmgr_mutex_unlock();\ return val;\ } \ @@ -205,29 +207,29 @@ _tbm_util_get_appname_from_pid(long pid, char *str) static int _check_version(TBMModuleVersionInfo *data) { - int abimaj, abimin; - int vermaj, vermin; + int backend_module_major, backend_module_minor; + int tbm_backend_major, tbm_backend_minor; - abimaj = GET_ABI_MAJOR(data->abiversion); - abimin = GET_ABI_MINOR(data->abiversion); + backend_module_major = GET_ABI_MAJOR(data->abiversion); + backend_module_minor = 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); + data->vendor ? data->vendor : "UNKNOWN!", backend_module_major, backend_module_minor); - vermaj = GET_ABI_MAJOR(TBM_ABI_VERSION); - vermin = GET_ABI_MINOR(TBM_ABI_VERSION); + tbm_backend_major = GET_ABI_MAJOR(TBM_ABI_VERSION); + tbm_backend_minor = GET_ABI_MINOR(TBM_ABI_VERSION); TBM_DBG("TBM ABI version %d.%d\n", - vermaj, vermin); + tbm_backend_major, tbm_backend_minor); - if (abimaj != vermaj) { + if (backend_module_major != tbm_backend_major) { TBM_ERR("TBM module ABI major ver(%d) doesn't match the TBM's ver(%d)\n", - abimaj, vermaj); + backend_module_major, tbm_backend_major); return 0; - } else if (abimin > vermin) { + } else if (backend_module_minor > tbm_backend_minor) { TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n", - abimin, vermin); + backend_module_minor, tbm_backend_minor); return 0; } @@ -280,8 +282,8 @@ _tbm_backend_load_module(tbm_bufmgr bufmgr, const char *file) void *module_data = NULL; tbm_backend_module *backend_module_data = NULL; tbm_backend_bufmgr_data *bufmgr_data = NULL; - int abimaj, abimin; - int vermaj, vermin; + int backend_module_major, backend_module_minor; + int tbm_backend_major, tbm_backend_minor; tbm_error_e error; snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file); @@ -298,25 +300,25 @@ _tbm_backend_load_module(tbm_bufmgr bufmgr, const char *file) goto err; } - abimaj = GET_ABI_MAJOR(backend_module_data->abi_version); - abimin = GET_ABI_MINOR(backend_module_data->abi_version); + tbm_backend_major = GET_ABI_MAJOR(TBM_BACKEND_ABI_LATEST_VERSION); + tbm_backend_minor = GET_ABI_MINOR(TBM_BACKEND_ABI_LATEST_VERSION); + TBM_INFO("TBM Backend ABI version %d.%d\n", tbm_backend_major, tbm_backend_minor); - TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n", + backend_module_major = GET_ABI_MAJOR(backend_module_data->abi_version); + backend_module_minor = GET_ABI_MINOR(backend_module_data->abi_version); + + TBM_INFO("TBM module %s: vendor=\"%s\" Backend ABI version=%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); + backend_module_major, backend_module_minor); - if (abimaj > vermaj) { + if (backend_module_major > tbm_backend_major) { TBM_ERR("TBM module ABI major ver(%d) is newer than the TBM's ver(%d)\n", - abimaj, vermaj); + backend_module_major, tbm_backend_major); goto err; - } else if (abimin > vermin) { + } else if (backend_module_minor > tbm_backend_minor) { TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n", - abimin, vermin); + backend_module_minor, tbm_backend_minor); goto err; } @@ -517,6 +519,8 @@ _tbm_bufmgr_init(int fd, int server) pthread_mutex_lock(&gLock); + _tbm_set_last_result(TBM_ERROR_NONE); + if (fd >= 0) { TBM_WRN("!!!!!WARNING:: The tbm_bufmgr_init DOSE NOT use argument fd ANYMORE.\n"); TBM_WRN("!!!!!WARNING:: IT WILL BE CHANGED like tbm_bufmgr_init(int fd) --> tbm_bufmgr_init(void).\n"); @@ -526,7 +530,7 @@ _tbm_bufmgr_init(int fd, int server) /* initialize buffer manager */ if (gBufMgr) { gBufMgr->ref_count++; - TBM_INFO("reuse tbm_bufmgr(%p) ref_count(%d) fd(%d)\n", gBufMgr, gBufMgr->ref_count, gBufMgr->fd); + TBM_DBG("reuse tbm_bufmgr(%p) ref_count(%d) fd(%d)\n", gBufMgr, gBufMgr->ref_count, gBufMgr->fd); pthread_mutex_unlock(&gLock); return gBufMgr; } @@ -537,6 +541,7 @@ _tbm_bufmgr_init(int fd, int server) gBufMgr = calloc(1, sizeof(struct _tbm_bufmgr)); if (!gBufMgr) { TBM_ERR("error: fail to alloc bufmgr fd(%d)\n", fd); + _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); pthread_mutex_unlock(&gLock); return NULL; } @@ -552,6 +557,7 @@ _tbm_bufmgr_init(int fd, int server) /* load bufmgr priv from env */ if (!_tbm_load_module(gBufMgr, gBufMgr->fd)) { TBM_ERR("error : Fail to load bufmgr backend\n"); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); free(gBufMgr); gBufMgr = NULL; pthread_mutex_unlock(&gLock); @@ -618,6 +624,7 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr) _tbm_bufmgr_mutex_lock(); pthread_mutex_lock(&gLock); + _tbm_set_last_result(TBM_ERROR_NONE); if (!gBufMgr) { TBM_ERR("gBufmgr already destroy: bufmgr:%p\n", bufmgr); @@ -628,7 +635,7 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr) bufmgr->ref_count--; if (bufmgr->ref_count > 0) { - TBM_INFO("reduce a ref_count(%d) of tbm_bufmgr(%p)\n", bufmgr->ref_count, bufmgr); + TBM_DBG("reduce a ref_count(%d) of tbm_bufmgr(%p)\n", bufmgr->ref_count, bufmgr); pthread_mutex_unlock(&gLock); _tbm_bufmgr_mutex_unlock(); return; @@ -691,6 +698,7 @@ tbm_bufmgr_get_capability(tbm_bufmgr bufmgr) unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE; _tbm_bufmgr_mutex_lock(); + _tbm_set_last_result(TBM_ERROR_NONE); 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); @@ -715,9 +723,11 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) tbm_error_e error; pthread_mutex_lock(&gLock); + _tbm_set_last_result(TBM_ERROR_NONE); if (!TBM_BUFMGR_IS_VALID(bufmgr) || (bufmgr != gBufMgr)) { TBM_ERR("invalid bufmgr\n"); + _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER); pthread_mutex_unlock(&gLock); return NULL; } @@ -725,6 +735,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) str = malloc(len); if (!str) { TBM_ERR("Fail to allocate the string.\n"); + _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); pthread_mutex_unlock(&gLock); return NULL; } @@ -806,7 +817,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) TBM_SNRPRINTF(str, len, c, " bo:%-12p %-26d%-10d\n", surf->bos[i], surf->bos[i]->ref_cnt, - bufmgr->backend->bo_size(surf->bos[i]) / 1024); + size / 1024); } } } else @@ -820,14 +831,20 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { int bo_cnt = 0; tbm_bo bo = NULL; + tbm_key key = 0; LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) { 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."); - } else + key = bufmgr->bo_func->bo_export_key(bo->bo_data, &error); + if (error != TBM_ERROR_NONE) + TBM_WRN("fail to get the tdm_key of bo."); + } else { 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", ++bo_cnt, bo, @@ -837,7 +854,7 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) bo->map_cnt, bo->flags, bo->surface, - bufmgr->backend->bo_export(bo)); + key); } } else TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n"); @@ -865,6 +882,7 @@ void tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff) { _tbm_bufmgr_mutex_lock(); + _tbm_set_last_result(TBM_ERROR_NONE); TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr)); TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr); @@ -881,6 +899,7 @@ void tbm_bufmgr_debug_set_trace_mask(tbm_bufmgr bufmgr, tbm_bufmgr_debug_trace_mask mask, int set) { _tbm_bufmgr_mutex_lock(); + _tbm_set_last_result(TBM_ERROR_NONE); TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr)); TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr); @@ -920,6 +939,7 @@ void tbm_bufmgr_debug_dump_set_scale(double scale) { pthread_mutex_lock(&gLock); + _tbm_set_last_result(TBM_ERROR_NONE); scale_factor = scale; pthread_mutex_unlock(&gLock); } @@ -927,13 +947,24 @@ tbm_bufmgr_debug_dump_set_scale(double scale) int tbm_bufmgr_debug_get_ref_count(void) { - return (gBufMgr) ? gBufMgr->ref_count : 0; + int refcnt; + + pthread_mutex_lock(&gLock); + + _tbm_set_last_result(TBM_ERROR_NONE); + + refcnt = (gBufMgr) ? gBufMgr->ref_count : 0; + + pthread_mutex_unlock(&gLock); + + return refcnt; } int tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff) { pthread_mutex_lock(&gLock); + _tbm_set_last_result(TBM_ERROR_NONE); if (onoff == 0) { TBM_DBG("count=%d onoff=%d\n", count, onoff); @@ -962,6 +993,7 @@ tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff) } pthread_mutex_unlock(&gLock); + return 1; } @@ -971,16 +1003,22 @@ tbm_bufmgr_debug_dump_all(char *path) int w, h, count = 0; tbm_surface_h surface = NULL; - TBM_RETURN_VAL_IF_FAIL(path != NULL, 0); - TBM_DBG("path=%s\n", path); - pthread_mutex_lock(&gLock); + _tbm_set_last_result(TBM_ERROR_NONE); + + if (!path) { + TBM_ERR("path is null.\n"); + pthread_mutex_unlock(&gLock); + return 0; + } + + TBM_DBG("path=%s\n", path); count = _tbm_util_get_max_surface_size(&w, &h); if (count == 0) { TBM_ERR("No tbm_surface.\n"); pthread_mutex_unlock(&gLock); - return 1; + return 0; } tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor); @@ -1007,8 +1045,10 @@ 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); @@ -1016,21 +1056,25 @@ tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display) 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; } - ret = bufmgr->bufmgr_func->bufmgr_bind_native_display(bufmgr->bufmgr_data, (tbm_native_display *)native_display); - if (!ret) { - TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n", - bufmgr, native_display); + 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(); return 1; } @@ -1039,6 +1083,7 @@ tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *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; } @@ -1064,13 +1109,20 @@ tbm_bufmgr_server_init(void) int tbm_bufmgr_set_bo_lock_type(tbm_bufmgr bufmgr, tbm_bufmgr_bo_lock_type bo_lock_type) { + _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(bufmgr == gBufMgr, 0); + pthread_mutex_lock(&gLock); gBufMgr->bo_lock_type = bo_lock_type; + pthread_mutex_unlock(&gLock); TBM_INFO("The bo_lock_type of the bo is %d\n", bo_lock_type); + _tbm_bufmgr_mutex_unlock(); + return 1; }