1 /**************************************************************************
5 Copyright 2012 Samsung Electronics co., Ltd. All Rights Reserved.
7 Contact: SooChan Lim <sc1.lim@samsung.com>, Sangjin Lee <lsj119@samsung.com>
8 Boram Park <boram1288.park@samsung.com>, Changyeon Lee <cyeon.lee@samsung.com>
10 Permission is hereby granted, free of charge, to any person obtaining a
11 copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sub license, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial portions
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
25 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
26 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 **************************************************************************/
34 #include "tbm_bufmgr.h"
35 #include "tbm_bufmgr_int.h"
36 #include "tbm_bufmgr_backend.h"
39 #include <sys/resource.h>
56 static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
57 static pthread_mutex_t tbm_bufmgr_lock = PTHREAD_MUTEX_INITIALIZER;
58 static __thread tbm_error_e tbm_last_error = TBM_ERROR_NONE;
59 static double scale_factor = 0;
60 static void _tbm_bufmgr_mutex_unlock(void);
62 //#define TBM_BUFMGR_INIT_TIME
64 #define PREFIX_LIB "libtbm_"
65 #define SUFFIX_LIB ".so"
66 #define DEFAULT_LIB PREFIX_LIB"default"SUFFIX_LIB
68 /* values to indicate unspecified fields in XF86ModReqInfo. */
69 #define MAJOR_UNSPEC 0xFF
70 #define MINOR_UNSPEC 0xFF
71 #define PATCH_UNSPEC 0xFFFF
72 #define ABI_VERS_UNSPEC 0xFFFFFFFF
74 #define MODULE_VERSION_NUMERIC(maj, min, patch) \
75 ((((maj) & 0xFF) << 24) | (((min) & 0xFF) << 16) | (patch & 0xFFFF))
76 #define GET_MODULE_MAJOR_VERSION(vers) (((vers) >> 24) & 0xFF)
77 #define GET_MODULE_MINOR_VERSION(vers) (((vers) >> 16) & 0xFF)
78 #define GET_MODULE_PATCHLEVEL(vers) ((vers) & 0xFFFF)
80 #define MAX_SIZE_N(dest) (sizeof(dest) - strlen(dest) - 1)
83 #define TBM_BUFMGR_RETURN_IF_FAIL(cond) {\
85 TBM_LOG_E("'%s' failed.\n", #cond);\
86 _tbm_bufmgr_mutex_unlock();\
91 #define TBM_BUFMGR_RETURN_VAL_IF_FAIL(cond, val) {\
93 TBM_LOG_E("'%s' failed.\n", #cond);\
94 _tbm_bufmgr_mutex_unlock();\
106 _tbm_set_last_result(tbm_error_e err)
108 tbm_last_error = err;
111 /* LCOV_EXCL_START */
113 _tbm_bufmgr_mutex_init(void)
115 static bool tbm_bufmgr_mutex_init = false;
117 if (tbm_bufmgr_mutex_init)
120 if (pthread_mutex_init(&tbm_bufmgr_lock, NULL)) {
121 TBM_LOG_E("fail: Cannot pthread_mutex_init for tbm_bufmgr_lock.\n");
125 tbm_bufmgr_mutex_init = true;
131 _tbm_bufmgr_mutex_lock(void)
133 if (!_tbm_bufmgr_mutex_init()) {
134 TBM_LOG_E("fail: _tbm_bufmgr_mutex_init()\n");
138 pthread_mutex_lock(&tbm_bufmgr_lock);
142 _tbm_bufmgr_mutex_unlock(void)
144 pthread_mutex_unlock(&tbm_bufmgr_lock);
148 _tbm_flag_to_str(int f)
150 static char str[255];
152 if (f == TBM_BO_DEFAULT)
153 snprintf(str, 255, "DEFAULT");
157 if (f & TBM_BO_SCANOUT)
158 c += snprintf(&str[c], 255-c, "SCANOUT");
160 if (f & TBM_BO_NONCACHABLE) {
161 if (c >= 0 && c < 255)
162 c += snprintf(&str[c], 255-c, ", ");
164 if (c >= 0 && c < 255)
165 c += snprintf(&str[c], 255-c, "NONCACHABLE,");
169 if (c >= 0 && c < 255)
170 c += snprintf(&str[c], 255-c, ", ");
172 if (c >= 0 && c < 255)
173 c += snprintf(&str[c], 255-c, "WC");
181 _tbm_util_check_bo_cnt(tbm_bufmgr bufmgr)
183 static int last_chk_bo_cnt = 0;
185 if ((bufmgr->bo_cnt >= 500) && ((bufmgr->bo_cnt % 20) == 0) &&
186 (bufmgr->bo_cnt > last_chk_bo_cnt)) {
187 TBM_DEBUG("============TBM BO CNT DEBUG: bo_cnt=%d\n",
190 tbm_bufmgr_debug_show(bufmgr);
192 last_chk_bo_cnt = bufmgr->bo_cnt;
197 _tbm_util_get_max_surface_size(int *w, int *h)
199 tbm_surface_info_s info;
200 tbm_surface_h surface = NULL;
206 if (gBufMgr == NULL || LIST_IS_EMPTY(&gBufMgr->surf_list))
209 LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link) {
210 if (tbm_surface_get_info(surface, &info) == TBM_SURFACE_ERROR_NONE) {
214 if (*h < info.height)
223 _tbm_util_get_appname_brief(char *brief)
227 char temp[255] = {0,};
228 char *saveptr = NULL;
230 token = strtok_r(brief, delim, &saveptr);
232 while (token != NULL) {
233 memset(temp, 0x00, 255 * sizeof(char));
234 strncpy(temp, token, 254 * sizeof(char));
235 token = strtok_r(NULL, delim, &saveptr);
238 snprintf(brief, sizeof(temp), "%s", temp);
242 _tbm_util_get_appname_from_pid(long pid, char *str)
244 char fn_cmdline[255] = {0, }, cmdline[255];
248 snprintf(fn_cmdline, sizeof(fn_cmdline), "/proc/%ld/cmdline", pid);
250 fp = fopen(fn_cmdline, "r");
252 TBM_LOG_E("cannot file open %s\n", fn_cmdline);
256 if (!fgets(cmdline, 255, fp)) {
257 TBM_LOG_E("fail to get appname for pid(%ld)\n", pid);
264 len = strlen(cmdline);
266 memset(cmdline, 0x00, 255);
270 snprintf(str, sizeof(cmdline), "%s", cmdline);
275 *user_data_lookup(struct list_head *user_data_list, unsigned long key)
277 tbm_user_data *old_data = NULL;
279 if (LIST_IS_EMPTY(user_data_list))
282 LIST_FOR_EACH_ENTRY(old_data, user_data_list, item_link) {
283 if (old_data->key == key)
291 *user_data_create(unsigned long key, tbm_data_free data_free_func)
293 tbm_user_data *user_data;
295 user_data = calloc(1, sizeof(tbm_user_data));
297 /* LCOV_EXCL_START */
298 TBM_LOG_E("fail to allocate an user_date\n");
303 user_data->key = key;
304 user_data->free_func = data_free_func;
310 user_data_delete(tbm_user_data *user_data)
312 if (user_data->data && user_data->free_func)
313 user_data->free_func(user_data->data);
315 LIST_DEL(&user_data->item_link);
321 _bo_lock(tbm_bo bo, int device, int opt)
323 tbm_bufmgr bufmgr = bo->bufmgr;
326 if (bufmgr->backend->bo_lock)
327 ret = bufmgr->backend->bo_lock(bo, device, opt);
333 _bo_unlock(tbm_bo bo)
335 tbm_bufmgr bufmgr = bo->bufmgr;
337 if (bufmgr->backend->bo_unlock)
338 bufmgr->backend->bo_unlock(bo);
342 _tbm_bo_lock(tbm_bo bo, int device, int opt)
352 /* do not try to lock the bo */
353 if (bufmgr->lock_type == LOCK_TRY_NEVER)
356 if (bo->lock_cnt < 0) {
357 TBM_LOG_E("error bo:%p LOCK_CNT=%d\n",
364 switch (bufmgr->lock_type) {
366 if (bo->lock_cnt == 0) {
367 _tbm_bufmgr_mutex_unlock();
368 ret = _bo_lock(bo, device, opt);
369 _tbm_bufmgr_mutex_lock();
375 case LOCK_TRY_ALWAYS:
376 _tbm_bufmgr_mutex_unlock();
377 ret = _bo_lock(bo, device, opt);
378 _tbm_bufmgr_mutex_lock();
383 TBM_LOG_E("error bo:%p lock_type[%d] is wrong.\n",
384 bo, bufmgr->lock_type);
389 TBM_DBG_LOCK(">> LOCK bo:%p(%d->%d)\n", bo, old, bo->lock_cnt);
395 _tbm_bo_unlock(tbm_bo bo)
405 /* do not try to unlock the bo */
406 if (bufmgr->lock_type == LOCK_TRY_NEVER)
411 switch (bufmgr->lock_type) {
413 if (bo->lock_cnt > 0) {
415 if (bo->lock_cnt == 0)
419 case LOCK_TRY_ALWAYS:
420 if (bo->lock_cnt > 0) {
426 TBM_LOG_E("error bo:%p lock_type[%d] is wrong.\n",
427 bo, bufmgr->lock_type);
431 if (bo->lock_cnt < 0)
434 TBM_DBG_LOCK(">> UNLOCK bo:%p(%d->%d)\n", bo, old, bo->lock_cnt);
438 _tbm_bo_is_valid(tbm_bo bo)
440 tbm_bo old_data = NULL;
442 if (bo == NULL || gBufMgr == NULL) {
443 TBM_LOG_E("error: bo is NULL or tbm_bufmgr was deinited\n");
447 if (LIST_IS_EMPTY(&gBufMgr->bo_list)) {
448 TBM_LOG_E("error: gBufMgr->bo_list is EMPTY.\n");
452 LIST_FOR_EACH_ENTRY(old_data, &gBufMgr->bo_list, item_link) {
457 TBM_LOG_E("error: No valid bo(%p).\n", bo);
463 _tbm_bo_free(tbm_bo bo)
465 tbm_bufmgr bufmgr = bo->bufmgr;
467 /* destory the user_data_list */
468 if (!LIST_IS_EMPTY(&bo->user_data_list)) {
469 tbm_user_data *old_data = NULL, *tmp;
471 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp,
472 &bo->user_data_list, item_link) {
473 TBM_DBG("free user_data\n");
474 user_data_delete(old_data);
478 while (bo->lock_cnt > 0) {
479 TBM_LOG_E("error lock_cnt:%d\n", bo->lock_cnt);
484 /* call the bo_free */
485 bufmgr->backend->bo_free(bo);
488 LIST_DEL(&bo->item_link);
494 /* LCOV_EXCL_START */
496 _check_version(TBMModuleVersionInfo *data)
501 abimaj = GET_ABI_MAJOR(data->abiversion);
502 abimin = GET_ABI_MINOR(data->abiversion);
504 TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n",
505 data->modname ? data->modname : "UNKNOWN!",
506 data->vendor ? data->vendor : "UNKNOWN!", abimaj, abimin);
508 vermaj = GET_ABI_MAJOR(TBM_ABI_VERSION);
509 vermin = GET_ABI_MINOR(TBM_ABI_VERSION);
511 TBM_DBG("TBM ABI version %d.%d\n",
514 if (abimaj != vermaj) {
515 TBM_LOG_E("TBM module ABI major ver(%d) doesn't match the TBM's ver(%d)\n",
518 } else if (abimin > vermin) {
519 TBM_LOG_E("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n",
528 _tbm_bufmgr_load_module(tbm_bufmgr bufmgr, int fd, const char *file)
530 char path[PATH_MAX] = {0, };
531 TBMModuleVersionInfo *vers;
532 TBMModuleData *initdata;
536 snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
538 module_data = dlopen(path, RTLD_LAZY);
540 TBM_LOG_E("failed to load module: %s(%s)\n", dlerror(), file);
544 initdata = dlsym(module_data, "tbmModuleData");
546 TBM_LOG_E("Error: module does not have data object.\n");
550 vers = initdata->vers;
552 TBM_LOG_E("Error: module does not supply version information.\n");
556 init = initdata->init;
558 TBM_LOG_E("Error: module does not supply init symbol.\n");
562 if (!_check_version(vers)) {
563 TBM_LOG_E("Fail to check version.\n");
567 if (!init(bufmgr, fd)) {
568 TBM_LOG_E("Fail to init module(%s)\n", file);
572 if (!bufmgr->backend || !bufmgr->backend->priv) {
573 TBM_LOG_E("Error: module(%s) wrong operation. Check backend or backend's priv.\n", file);
577 bufmgr->module_data = module_data;
579 TBM_DBG("Success to load module(%s)\n", file);
584 dlclose(module_data);
589 _tbm_load_module(tbm_bufmgr bufmgr, int fd)
591 struct dirent **namelist;
594 /* load bufmgr priv from default lib */
595 if (_tbm_bufmgr_load_module(bufmgr, fd, DEFAULT_LIB))
598 /* load bufmgr priv from configured path */
599 n = scandir(BUFMGR_MODULE_DIR, &namelist, 0, alphasort);
601 TBM_LOG_E("no files : %s\n", BUFMGR_MODULE_DIR);
606 if (!ret && strstr(namelist[n]->d_name, PREFIX_LIB)) {
607 const char *p = strstr(namelist[n]->d_name, SUFFIX_LIB);
609 if (p && !strcmp(p, SUFFIX_LIB))
610 ret = _tbm_bufmgr_load_module(bufmgr, fd,
611 namelist[n]->d_name);
624 tbm_bufmgr_init(int fd)
626 #ifdef TBM_BUFMGR_INIT_TIME
627 struct timeval start_tv, end_tv;
631 #ifdef TBM_BUFMGR_INIT_TIME
632 /* get the start tv */
633 gettimeofday(&start_tv, NULL);
636 /* LCOV_EXCL_START */
638 env = getenv("TBM_DLOG");
641 TBM_LOG_D("TBM_DLOG=%s\n", env);
647 env = getenv("TBM_DEBUG");
650 TBM_LOG_D("TBM_DEBUG=%s\n", env);
656 env = getenv("TBM_TRACE");
659 TBM_LOG_D("TBM_TRACE=%s\n", env);
664 pthread_mutex_lock(&gLock);
667 TBM_LOG_W("!!!!!WARNING:: The tbm_bufmgr_init DOSE NOT use argument fd ANYMORE.\n");
668 TBM_LOG_W("!!!!!WARNING:: IT WILL BE CHANGED like tbm_bufmgr_init(int fd) --> tbm_bufmgr_init(void).\n");
672 /* initialize buffer manager */
674 gBufMgr->ref_count++;
675 TBM_TRACE("reuse tbm_bufmgr(%p) ref_count(%d) fd(%d)\n", gBufMgr, gBufMgr->ref_count, gBufMgr->fd);
676 pthread_mutex_unlock(&gLock);
680 TBM_DBG("bufmgr init\n");
682 /* allocate bufmgr */
683 gBufMgr = calloc(1, sizeof(struct _tbm_bufmgr));
685 _tbm_set_last_result(TBM_BO_ERROR_HEAP_ALLOC_FAILED);
686 TBM_TRACE("error: fail to alloc bufmgr fd(%d)\n", fd);
687 pthread_mutex_unlock(&gLock);
693 /* load bufmgr priv from env */
694 if (!_tbm_load_module(gBufMgr, gBufMgr->fd)) {
695 _tbm_set_last_result(TBM_BO_ERROR_LOAD_MODULE_FAILED);
696 TBM_LOG_E("error : Fail to load bufmgr backend\n");
699 pthread_mutex_unlock(&gLock);
705 /* log for tbm backend_flag */
706 TBM_DBG("backend flag:%x:", gBufMgr->backend->flags);
709 gBufMgr->ref_count = 1;
711 TBM_DBG("create tizen bufmgr:%p ref_count:%d\n",
712 gBufMgr, gBufMgr->ref_count);
714 /* setup the lock_type */
715 env = getenv("BUFMGR_LOCK_TYPE");
716 if (env && !strcmp(env, "always"))
717 gBufMgr->lock_type = LOCK_TRY_ALWAYS;
718 else if (env && !strcmp(env, "none"))
719 gBufMgr->lock_type = LOCK_TRY_NEVER;
720 else if (env && !strcmp(env, "once"))
721 gBufMgr->lock_type = LOCK_TRY_ONCE;
723 gBufMgr->lock_type = LOCK_TRY_ALWAYS;
725 TBM_DBG("BUFMGR_LOCK_TYPE=%s\n", env ? env : "default:once");
727 TBM_TRACE("create tbm_bufmgr(%p) ref_count(%d) fd(%d)\n", gBufMgr, gBufMgr->ref_count, fd);
729 /* intialize bo_list */
730 LIST_INITHEAD(&gBufMgr->bo_list);
732 /* intialize surf_list */
733 LIST_INITHEAD(&gBufMgr->surf_list);
735 /* intialize surf_queue_list */
736 LIST_INITHEAD(&gBufMgr->surf_queue_list);
738 /* intialize debug_key_list */
739 LIST_INITHEAD(&gBufMgr->debug_key_list);
741 #ifdef TBM_BUFMGR_INIT_TIME
743 gettimeofday(&end_tv, NULL);
744 TBM_LOG_I("tbm_bufmgr_init time: %ld ms", ((end_tv.tv_sec * 1000 + end_tv.tv_usec / 1000) - (start_tv.tv_sec * 1000 + start_tv.tv_usec / 1000)));
747 pthread_mutex_unlock(&gLock);
753 tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
755 TBM_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
757 _tbm_bufmgr_mutex_lock();
758 pthread_mutex_lock(&gLock);
761 TBM_LOG_E("gBufmgr already destroy: bufmgr:%p\n", bufmgr);
762 pthread_mutex_unlock(&gLock);
763 _tbm_bufmgr_mutex_unlock();
768 if (bufmgr->ref_count > 0) {
769 TBM_TRACE("reduce a ref_count(%d) of tbm_bufmgr(%p)\n", bufmgr->ref_count, bufmgr);
770 pthread_mutex_unlock(&gLock);
771 _tbm_bufmgr_mutex_unlock();
775 /* destroy bo_list */
776 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
777 tbm_bo bo = NULL, tmp;
779 LIST_FOR_EACH_ENTRY_SAFE(bo, tmp, &bufmgr->bo_list, item_link) {
780 TBM_LOG_E("Un-freed bo(%p, ref:%d)\n", bo, bo->ref_cnt);
783 LIST_DELINIT(&bufmgr->bo_list);
786 /* destroy surf_list */
787 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
788 tbm_surface_h surf = NULL, tmp;
790 LIST_FOR_EACH_ENTRY_SAFE(surf, tmp, &bufmgr->surf_list, item_link) {
791 TBM_LOG_E("Un-freed surf(%p, ref:%d)\n", surf, surf->refcnt);
792 tbm_surface_destroy(surf);
794 LIST_DELINIT(&bufmgr->surf_list);
797 /* destroy bufmgr priv */
798 bufmgr->backend->bufmgr_deinit(bufmgr->backend->priv);
799 bufmgr->backend->priv = NULL;
800 tbm_backend_free(bufmgr->backend);
801 bufmgr->backend = NULL;
803 TBM_TRACE("destroy tbm_bufmgr(%p)\n", bufmgr);
805 dlclose(bufmgr->module_data);
813 pthread_mutex_unlock(&gLock);
814 _tbm_bufmgr_mutex_unlock();
818 tbm_bo_size(tbm_bo bo)
820 tbm_bufmgr bufmgr = gBufMgr;
823 _tbm_bufmgr_mutex_lock();
825 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
826 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
828 size = bufmgr->backend->bo_size(bo);
830 TBM_TRACE("bo(%p) size(%d)\n", bo, size);
832 _tbm_bufmgr_mutex_unlock();
838 tbm_bo_ref(tbm_bo bo)
840 _tbm_bufmgr_mutex_lock();
842 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), NULL);
843 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), NULL);
847 TBM_TRACE("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt);
849 _tbm_bufmgr_mutex_unlock();
855 tbm_bo_unref(tbm_bo bo)
857 _tbm_bufmgr_mutex_lock();
859 TBM_BUFMGR_RETURN_IF_FAIL(gBufMgr);
860 TBM_BUFMGR_RETURN_IF_FAIL(_tbm_bo_is_valid(bo));
862 TBM_TRACE("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt - 1);
864 if (bo->ref_cnt <= 0) {
865 _tbm_bufmgr_mutex_unlock();
870 if (bo->ref_cnt == 0)
873 _tbm_bufmgr_mutex_unlock();
877 tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
882 _tbm_bufmgr_mutex_lock();
884 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
885 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL);
886 TBM_BUFMGR_RETURN_VAL_IF_FAIL(size > 0, NULL);
888 bo = calloc(1, sizeof(struct _tbm_bo));
890 /* LCOV_EXCL_START */
891 TBM_LOG_E("error: fail to create of tbm_bo size(%d) flag(%s)\n",
892 size, _tbm_flag_to_str(flags));
893 _tbm_set_last_result(TBM_BO_ERROR_HEAP_ALLOC_FAILED);
894 _tbm_bufmgr_mutex_unlock();
899 _tbm_util_check_bo_cnt(bufmgr);
903 bo_priv = bufmgr->backend->bo_alloc(bo, size, flags);
905 /* LCOV_EXCL_START */
906 TBM_LOG_E("error: fail to create of tbm_bo size(%d) flag(%s)\n",
907 size, _tbm_flag_to_str(flags));
908 _tbm_set_last_result(TBM_BO_ERROR_BO_ALLOC_FAILED);
910 _tbm_bufmgr_mutex_unlock();
921 TBM_TRACE("bo(%p) size(%d) refcnt(%d), flag(%s)\n", bo, size, bo->ref_cnt,
922 _tbm_flag_to_str(bo->flags));
924 LIST_INITHEAD(&bo->user_data_list);
926 LIST_ADD(&bo->item_link, &bufmgr->bo_list);
928 _tbm_bufmgr_mutex_unlock();
934 tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
939 _tbm_bufmgr_mutex_lock();
941 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
942 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL);
944 if (!bufmgr->backend->bo_import) {
945 /* LCOV_EXCL_START */
946 _tbm_bufmgr_mutex_unlock();
951 _tbm_util_check_bo_cnt(bufmgr);
953 bo = calloc(1, sizeof(struct _tbm_bo));
955 /* LCOV_EXCL_START */
956 TBM_LOG_E("error: fail to import of tbm_bo by key(%d)\n", key);
957 _tbm_bufmgr_mutex_unlock();
964 bo_priv = bufmgr->backend->bo_import(bo, key);
966 /* LCOV_EXCL_START */
967 TBM_LOG_E("error: fail to import of tbm_bo by key(%d)\n", key);
968 _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FAILED);
970 _tbm_bufmgr_mutex_unlock();
975 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
978 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
979 if (bo2->priv == bo_priv) {
980 TBM_TRACE("find bo(%p) ref(%d) key(%d) flag(%s) in list\n",
981 bo2, bo2->ref_cnt, key,
982 _tbm_flag_to_str(bo2->flags));
985 _tbm_bufmgr_mutex_unlock();
996 if (bufmgr->backend->bo_get_flags)
997 bo->flags = bufmgr->backend->bo_get_flags(bo);
999 bo->flags = TBM_BO_DEFAULT;
1001 TBM_TRACE("import new bo(%p) ref(%d) key(%d) flag(%s) in list\n",
1002 bo, bo->ref_cnt, key, _tbm_flag_to_str(bo->flags));
1004 LIST_INITHEAD(&bo->user_data_list);
1006 LIST_ADD(&bo->item_link, &bufmgr->bo_list);
1008 _tbm_bufmgr_mutex_unlock();
1014 tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
1019 _tbm_bufmgr_mutex_lock();
1021 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
1022 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL);
1024 if (!bufmgr->backend->bo_import_fd) {
1025 /* LCOV_EXCL_START */
1026 _tbm_bufmgr_mutex_unlock();
1028 /* LCOV_EXCL_STOP */
1031 _tbm_util_check_bo_cnt(bufmgr);
1033 bo = calloc(1, sizeof(struct _tbm_bo));
1035 /* LCOV_EXCL_START */
1036 TBM_LOG_E("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
1037 _tbm_bufmgr_mutex_unlock();
1039 /* LCOV_EXCL_STOP */
1042 bo->bufmgr = bufmgr;
1044 bo_priv = bufmgr->backend->bo_import_fd(bo, fd);
1046 /* LCOV_EXCL_START */
1047 TBM_LOG_E("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
1048 _tbm_set_last_result(TBM_BO_ERROR_IMPORT_FD_FAILED);
1050 _tbm_bufmgr_mutex_unlock();
1052 /* LCOV_EXCL_STOP */
1055 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
1058 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
1059 if (bo2->priv == bo_priv) {
1060 TBM_TRACE("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
1061 bo2, bo2->ref_cnt, fd,
1062 _tbm_flag_to_str(bo2->flags));
1065 _tbm_bufmgr_mutex_unlock();
1076 if (bufmgr->backend->bo_get_flags)
1077 bo->flags = bufmgr->backend->bo_get_flags(bo);
1079 bo->flags = TBM_BO_DEFAULT;
1081 TBM_TRACE("import bo(%p) ref(%d) fd(%d) flag(%s)\n",
1082 bo, bo->ref_cnt, fd, _tbm_flag_to_str(bo->flags));
1084 LIST_INITHEAD(&bo->user_data_list);
1086 LIST_ADD(&bo->item_link, &bufmgr->bo_list);
1088 _tbm_bufmgr_mutex_unlock();
1094 tbm_bo_export(tbm_bo bo)
1096 tbm_bufmgr bufmgr = gBufMgr;
1099 _tbm_bufmgr_mutex_lock();
1101 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1102 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1104 if (!bufmgr->backend->bo_export) {
1105 /* LCOV_EXCL_START */
1106 _tbm_bufmgr_mutex_unlock();
1108 /* LCOV_EXCL_STOP */
1111 ret = bufmgr->backend->bo_export(bo);
1113 /* LCOV_EXCL_START */
1114 _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FAILED);
1115 TBM_LOG_E("error: bo(%p) tbm_key(%d)\n", bo, ret);
1116 _tbm_bufmgr_mutex_unlock();
1118 /* LCOV_EXCL_STOP */
1121 TBM_TRACE("bo(%p) tbm_key(%u)\n", bo, ret);
1123 _tbm_bufmgr_mutex_unlock();
1129 tbm_bo_export_fd(tbm_bo bo)
1131 tbm_bufmgr bufmgr = gBufMgr;
1134 _tbm_bufmgr_mutex_lock();
1136 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), -1);
1137 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1);
1139 if (!bufmgr->backend->bo_export_fd) {
1140 /* LCOV_EXCL_START */
1141 _tbm_bufmgr_mutex_unlock();
1143 /* LCOV_EXCL_STOP */
1146 ret = bufmgr->backend->bo_export_fd(bo);
1148 /* LCOV_EXCL_START */
1149 _tbm_set_last_result(TBM_BO_ERROR_EXPORT_FD_FAILED);
1150 TBM_LOG_E("error: bo(%p) tbm_fd(%d)\n", bo, ret);
1151 _tbm_bufmgr_mutex_unlock();
1153 /* LCOV_EXCL_STOP */
1156 TBM_TRACE("bo(%p) tbm_fd(%d)\n", bo, ret);
1158 _tbm_bufmgr_mutex_unlock();
1164 tbm_bo_get_handle(tbm_bo bo, int device)
1166 tbm_bufmgr bufmgr = gBufMgr;
1167 tbm_bo_handle bo_handle;
1169 _tbm_bufmgr_mutex_lock();
1171 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), (tbm_bo_handle) NULL);
1172 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
1174 bo_handle = bufmgr->backend->bo_get_handle(bo, device);
1175 if (bo_handle.ptr == NULL) {
1176 /* LCOV_EXCL_START */
1177 _tbm_set_last_result(TBM_BO_ERROR_GET_HANDLE_FAILED);
1178 TBM_LOG_E("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
1179 _tbm_bufmgr_mutex_unlock();
1180 return (tbm_bo_handle) NULL;
1181 /* LCOV_EXCL_STOP */
1184 TBM_TRACE("bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
1186 _tbm_bufmgr_mutex_unlock();
1192 tbm_bo_map(tbm_bo bo, int device, int opt)
1194 tbm_bufmgr bufmgr = gBufMgr;
1195 tbm_bo_handle bo_handle;
1197 _tbm_bufmgr_mutex_lock();
1199 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), (tbm_bo_handle) NULL);
1200 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
1202 if (!_tbm_bo_lock(bo, device, opt)) {
1203 _tbm_set_last_result(TBM_BO_ERROR_LOCK_FAILED);
1204 TBM_LOG_E("error: fail to lock bo:%p)\n", bo);
1205 _tbm_bufmgr_mutex_unlock();
1206 return (tbm_bo_handle) NULL;
1209 bo_handle = bufmgr->backend->bo_map(bo, device, opt);
1210 if (bo_handle.ptr == NULL) {
1211 /* LCOV_EXCL_START */
1212 _tbm_set_last_result(TBM_BO_ERROR_MAP_FAILED);
1213 TBM_LOG_E("error: fail to map bo:%p\n", bo);
1215 _tbm_bufmgr_mutex_unlock();
1216 return (tbm_bo_handle) NULL;
1217 /* LCOV_EXCL_STOP */
1220 /* increase the map_count */
1223 TBM_TRACE("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
1225 _tbm_bufmgr_mutex_unlock();
1231 tbm_bo_unmap(tbm_bo bo)
1233 tbm_bufmgr bufmgr = gBufMgr;
1236 _tbm_bufmgr_mutex_lock();
1238 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1239 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1240 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bo->map_cnt > 0, 0);
1242 ret = bufmgr->backend->bo_unmap(bo);
1244 /* LCOV_EXCL_START */
1245 TBM_LOG_E("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
1246 _tbm_set_last_result(TBM_BO_ERROR_UNMAP_FAILED);
1247 _tbm_bufmgr_mutex_unlock();
1249 /* LCOV_EXCL_STOP */
1252 /* decrease the map_count */
1255 TBM_TRACE("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
1259 _tbm_bufmgr_mutex_unlock();
1265 tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
1267 tbm_bufmgr bufmgr = gBufMgr;
1270 _tbm_bufmgr_mutex_lock();
1272 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1273 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0);
1274 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0);
1276 TBM_TRACE("before: bo1(%p) bo2(%p)\n", bo1, bo2);
1278 if (bufmgr->backend->bo_size(bo1) != bufmgr->backend->bo_size(bo2)) {
1279 _tbm_set_last_result(TBM_BO_ERROR_SWAP_FAILED);
1280 TBM_LOG_E("error: bo1(%p) bo2(%p)\n", bo1, bo2);
1281 _tbm_bufmgr_mutex_unlock();
1285 TBM_TRACE("after: bo1(%p) bo2(%p)\n", bo1, bo2);
1288 bo1->priv = bo2->priv;
1291 _tbm_bufmgr_mutex_unlock();
1297 tbm_bo_locked(tbm_bo bo)
1299 tbm_bufmgr bufmgr = gBufMgr;
1301 _tbm_bufmgr_mutex_lock();
1303 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1304 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1306 if (bufmgr->lock_type == LOCK_TRY_NEVER) {
1307 TBM_LOG_E("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1308 _tbm_bufmgr_mutex_unlock();
1312 if (bo->lock_cnt > 0) {
1313 TBM_TRACE("error: bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1314 _tbm_bufmgr_mutex_unlock();
1318 TBM_TRACE("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1319 _tbm_bufmgr_mutex_unlock();
1325 tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
1326 tbm_data_free data_free_func)
1328 tbm_user_data *data;
1330 _tbm_bufmgr_mutex_lock();
1332 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1333 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1335 /* check if the data according to the key exist if so, return false. */
1336 data = user_data_lookup(&bo->user_data_list, key);
1338 TBM_TRACE("warning: user data already exist key(%ld)\n", key);
1339 _tbm_bufmgr_mutex_unlock();
1343 data = user_data_create(key, data_free_func);
1345 TBM_LOG_E("error: bo(%p) key(%lu)\n", bo, key);
1346 _tbm_bufmgr_mutex_unlock();
1350 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, data->data);
1352 LIST_ADD(&data->item_link, &bo->user_data_list);
1354 _tbm_bufmgr_mutex_unlock();
1360 tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
1362 tbm_user_data *old_data;
1364 _tbm_bufmgr_mutex_lock();
1366 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1367 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1369 if (LIST_IS_EMPTY(&bo->user_data_list)) {
1370 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1371 _tbm_bufmgr_mutex_unlock();
1375 old_data = user_data_lookup(&bo->user_data_list, key);
1377 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1378 _tbm_bufmgr_mutex_unlock();
1382 if (old_data->data && old_data->free_func)
1383 old_data->free_func(old_data->data);
1384 old_data->data = data;
1386 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1388 _tbm_bufmgr_mutex_unlock();
1394 tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
1396 tbm_user_data *old_data;
1398 _tbm_bufmgr_mutex_lock();
1400 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1401 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1403 if (!data || LIST_IS_EMPTY(&bo->user_data_list)) {
1404 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1405 _tbm_bufmgr_mutex_unlock();
1409 old_data = user_data_lookup(&bo->user_data_list, key);
1411 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1413 _tbm_bufmgr_mutex_unlock();
1417 *data = old_data->data;
1419 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1421 _tbm_bufmgr_mutex_unlock();
1427 tbm_bo_delete_user_data(tbm_bo bo, unsigned long key)
1429 tbm_user_data *old_data;
1431 _tbm_bufmgr_mutex_lock();
1433 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1434 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1436 if (LIST_IS_EMPTY(&bo->user_data_list)) {
1437 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1438 _tbm_bufmgr_mutex_unlock();
1442 old_data = user_data_lookup(&bo->user_data_list, key);
1444 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1445 _tbm_bufmgr_mutex_unlock();
1449 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1451 user_data_delete(old_data);
1453 _tbm_bufmgr_mutex_unlock();
1459 tbm_bufmgr_get_capability(tbm_bufmgr bufmgr)
1461 unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE;
1463 _tbm_bufmgr_mutex_lock();
1465 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), TBM_BUFMGR_CAPABILITY_NONE);
1466 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, TBM_BUFMGR_CAPABILITY_NONE);
1468 TBM_TRACE("tbm_bufmgr(%p) capability(%u)\n", bufmgr, bufmgr->capabilities);
1470 capabilities = bufmgr->capabilities;
1472 _tbm_bufmgr_mutex_unlock();
1474 return capabilities;
1478 tbm_bo_get_flags(tbm_bo bo)
1482 _tbm_bufmgr_mutex_lock();
1484 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1485 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1489 TBM_TRACE("bo(%p)\n", bo);
1491 _tbm_bufmgr_mutex_unlock();
1496 /* LCOV_EXCL_START */
1498 tbm_get_last_error(void)
1500 return tbm_last_error;
1504 tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
1506 char app_name[255] = {0,}, title[512] = {0,};
1507 tbm_surface_debug_data *debug_old_data = NULL;
1512 pthread_mutex_lock(&gLock);
1514 if (!TBM_BUFMGR_IS_VALID(bufmgr) || (bufmgr != gBufMgr)) {
1515 TBM_LOG_E("invalid bufmgr\n");
1516 pthread_mutex_unlock(&gLock);
1522 TBM_LOG_E("Fail to allocate the string.\n");
1523 pthread_mutex_unlock(&gLock);
1527 TBM_SNRPRINTF(str, len, c, "\n");
1528 _tbm_util_get_appname_from_pid(getpid(), app_name);
1529 _tbm_util_get_appname_brief(app_name);
1530 TBM_SNRPRINTF(str, len, c, "============TBM DEBUG: %s(%d)===========================\n",
1531 app_name, getpid());
1533 snprintf(title, 255, "%s", "no surface refcnt width height bpp size n_b n_p flags format app_name ");
1535 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
1536 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
1537 strncat(title, " ", MAX_SIZE_N(title));
1538 strncat(title, debug_old_data->key, MAX_SIZE_N(title));
1542 TBM_SNRPRINTF(str, len, c, "[tbm_surface information]\n");
1543 TBM_SNRPRINTF(str, len, c, "%s\n", title);
1545 /* show the tbm_surface information in surf_list */
1546 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
1547 tbm_surface_h surf = NULL;
1550 LIST_FOR_EACH_ENTRY(surf, &bufmgr->surf_list, item_link) {
1551 char data[512] = {0,};
1555 pid = _tbm_surface_internal_get_debug_pid(surf);
1557 /* if pid is null, set the self_pid */
1561 memset(app_name, 0x0, 255 * sizeof(char));
1562 _tbm_util_get_appname_from_pid(pid, app_name);
1563 _tbm_util_get_appname_brief(app_name);
1565 snprintf(data, 255, "%-2d %-9p %-4d %-5u %-6u %-3u %-6u %-2d %-2d %-3d %-8s %-15s",
1572 surf->info.size / 1024,
1576 _tbm_surface_internal_format_to_str(surf->info.format) + 11,
1579 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
1580 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
1583 strncat(data, " ", MAX_SIZE_N(title));
1585 value = _tbm_surface_internal_get_debug_data(surf, debug_old_data->key);
1587 strncat(data, value, MAX_SIZE_N(title));
1589 strncat(data, "none", MAX_SIZE_N(title));
1592 TBM_SNRPRINTF(str, len, c, "%s\n", data);
1594 for (i = 0; i < surf->num_bos; i++) {
1595 TBM_SNRPRINTF(str, len, c, " bo:%-12p %-26d%-10d\n",
1597 surf->bos[i]->ref_cnt,
1598 bufmgr->backend->bo_size(surf->bos[i]) / 1024);
1602 TBM_SNRPRINTF(str, len, c, " no tbm_surfaces.\n");
1603 TBM_SNRPRINTF(str, len, c, "\n");
1605 TBM_SNRPRINTF(str, len, c, "[tbm_bo information]\n");
1606 TBM_SNRPRINTF(str, len, c, "no bo refcnt size lock_cnt map_cnt flags surface name\n");
1608 /* show the tbm_bo information in bo_list */
1609 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
1613 LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) {
1614 TBM_SNRPRINTF(str, len, c, "%-4d%-11p %-4d %-6d %-5d %-4u %-3d %-11p %-4d\n",
1618 bufmgr->backend->bo_size(bo) / 1024,
1623 bufmgr->backend->bo_export(bo));
1626 TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n");
1627 TBM_SNRPRINTF(str, len, c, "\n");
1629 TBM_SNRPRINTF(str, len, c, "===============================================================\n");
1631 pthread_mutex_unlock(&gLock);
1637 tbm_bufmgr_debug_show(tbm_bufmgr bufmgr)
1640 str = tbm_bufmgr_debug_tbm_info_get(bufmgr);
1642 TBM_DEBUG(" %s", str);
1648 tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff)
1650 _tbm_bufmgr_mutex_lock();
1652 TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
1653 TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
1656 TBM_LOG_D("bufmgr=%p onoff=%d\n", bufmgr, onoff);
1660 _tbm_bufmgr_mutex_unlock();
1664 tbm_bufmgr_debug_dump_set_scale(double scale)
1666 pthread_mutex_lock(&gLock);
1667 scale_factor = scale;
1668 pthread_mutex_unlock(&gLock);
1672 tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff)
1674 pthread_mutex_lock(&gLock);
1677 TBM_LOG_D("count=%d onoff=%d\n", count, onoff);
1679 tbm_surface_internal_dump_end();
1684 TBM_LOG_E("path is null");
1685 pthread_mutex_unlock(&gLock);
1688 TBM_LOG_D("path=%s count=%d onoff=%d\n", path, count, onoff);
1690 if (_tbm_util_get_max_surface_size(&w, &h) == 0) {
1691 TBM_LOG_E("Fail to get tbm_surface size.\n");
1692 pthread_mutex_unlock(&gLock);
1696 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
1702 pthread_mutex_unlock(&gLock);
1707 tbm_bufmgr_debug_dump_all(char *path)
1709 int w, h, count = 0;
1710 tbm_surface_h surface = NULL;
1712 TBM_RETURN_VAL_IF_FAIL(path != NULL, 0);
1713 TBM_LOG_D("path=%s\n", path);
1715 pthread_mutex_lock(&gLock);
1717 count = _tbm_util_get_max_surface_size(&w, &h);
1719 TBM_LOG_E("No tbm_surface.\n");
1720 pthread_mutex_unlock(&gLock);
1724 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
1727 LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link)
1728 tbm_surface_internal_dump_buffer(surface, "dump_all");
1730 tbm_surface_internal_dump_end();
1732 pthread_mutex_unlock(&gLock);
1737 /* internal function */
1739 _tbm_bufmgr_get_bufmgr(void)
1745 _tbm_bo_set_surface(tbm_bo bo, tbm_surface_h surface)
1747 _tbm_bufmgr_mutex_lock();
1749 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1750 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1752 bo->surface = surface;
1754 _tbm_bufmgr_mutex_unlock();
1760 tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *NativeDisplay)
1764 _tbm_bufmgr_mutex_lock();
1766 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1768 if (!bufmgr->backend->bufmgr_bind_native_display) {
1769 TBM_TRACE("skip: tbm_bufmgr(%p) NativeDisplay(%p)\n",
1770 bufmgr, NativeDisplay);
1771 _tbm_bufmgr_mutex_unlock();
1775 ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, NativeDisplay);
1777 TBM_LOG_E("error: tbm_bufmgr(%p) NativeDisplay(%p)\n",
1778 bufmgr, NativeDisplay);
1779 _tbm_bufmgr_mutex_unlock();
1783 TBM_TRACE("tbm_bufmgr(%p) NativeDisplay(%p)\n", bufmgr, NativeDisplay);
1785 _tbm_bufmgr_mutex_unlock();
1790 int tbm_bufmgr_get_fd_limit(void)
1794 if (getrlimit(RLIMIT_NOFILE, &lim))
1797 return (int)lim.rlim_cur;
1799 /* LCOV_EXCL_STOP */