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);
1241 ret = bufmgr->backend->bo_unmap(bo);
1243 /* LCOV_EXCL_START */
1244 TBM_LOG_E("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
1245 _tbm_set_last_result(TBM_BO_ERROR_UNMAP_FAILED);
1246 _tbm_bufmgr_mutex_unlock();
1248 /* LCOV_EXCL_STOP */
1251 /* decrease the map_count */
1254 TBM_TRACE("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
1258 _tbm_bufmgr_mutex_unlock();
1264 tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
1266 tbm_bufmgr bufmgr = gBufMgr;
1269 _tbm_bufmgr_mutex_lock();
1271 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1272 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0);
1273 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0);
1275 TBM_TRACE("before: bo1(%p) bo2(%p)\n", bo1, bo2);
1277 if (bufmgr->backend->bo_size(bo1) != bufmgr->backend->bo_size(bo2)) {
1278 _tbm_set_last_result(TBM_BO_ERROR_SWAP_FAILED);
1279 TBM_LOG_E("error: bo1(%p) bo2(%p)\n", bo1, bo2);
1280 _tbm_bufmgr_mutex_unlock();
1284 TBM_TRACE("after: bo1(%p) bo2(%p)\n", bo1, bo2);
1287 bo1->priv = bo2->priv;
1290 _tbm_bufmgr_mutex_unlock();
1296 tbm_bo_locked(tbm_bo bo)
1298 tbm_bufmgr bufmgr = gBufMgr;
1300 _tbm_bufmgr_mutex_lock();
1302 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1303 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1305 if (bufmgr->lock_type == LOCK_TRY_NEVER) {
1306 TBM_LOG_E("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1307 _tbm_bufmgr_mutex_unlock();
1311 if (bo->lock_cnt > 0) {
1312 TBM_TRACE("error: bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1313 _tbm_bufmgr_mutex_unlock();
1317 TBM_TRACE("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1318 _tbm_bufmgr_mutex_unlock();
1324 tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
1325 tbm_data_free data_free_func)
1327 tbm_user_data *data;
1329 _tbm_bufmgr_mutex_lock();
1331 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1332 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1334 /* check if the data according to the key exist if so, return false. */
1335 data = user_data_lookup(&bo->user_data_list, key);
1337 TBM_TRACE("warning: user data already exist key(%ld)\n", key);
1338 _tbm_bufmgr_mutex_unlock();
1342 data = user_data_create(key, data_free_func);
1344 TBM_LOG_E("error: bo(%p) key(%lu)\n", bo, key);
1345 _tbm_bufmgr_mutex_unlock();
1349 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, data->data);
1351 LIST_ADD(&data->item_link, &bo->user_data_list);
1353 _tbm_bufmgr_mutex_unlock();
1359 tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
1361 tbm_user_data *old_data;
1363 _tbm_bufmgr_mutex_lock();
1365 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1366 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1368 if (LIST_IS_EMPTY(&bo->user_data_list)) {
1369 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1370 _tbm_bufmgr_mutex_unlock();
1374 old_data = user_data_lookup(&bo->user_data_list, key);
1376 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1377 _tbm_bufmgr_mutex_unlock();
1381 if (old_data->data && old_data->free_func)
1382 old_data->free_func(old_data->data);
1383 old_data->data = data;
1385 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1387 _tbm_bufmgr_mutex_unlock();
1393 tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
1395 tbm_user_data *old_data;
1397 _tbm_bufmgr_mutex_lock();
1399 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1400 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1402 if (!data || LIST_IS_EMPTY(&bo->user_data_list)) {
1403 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1404 _tbm_bufmgr_mutex_unlock();
1408 old_data = user_data_lookup(&bo->user_data_list, key);
1410 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1412 _tbm_bufmgr_mutex_unlock();
1416 *data = old_data->data;
1418 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1420 _tbm_bufmgr_mutex_unlock();
1426 tbm_bo_delete_user_data(tbm_bo bo, unsigned long key)
1428 tbm_user_data *old_data;
1430 _tbm_bufmgr_mutex_lock();
1432 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1433 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1435 if (LIST_IS_EMPTY(&bo->user_data_list)) {
1436 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1437 _tbm_bufmgr_mutex_unlock();
1441 old_data = user_data_lookup(&bo->user_data_list, key);
1443 TBM_TRACE("error: bo(%p) key(%lu)\n", bo, key);
1444 _tbm_bufmgr_mutex_unlock();
1448 TBM_TRACE("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1450 user_data_delete(old_data);
1452 _tbm_bufmgr_mutex_unlock();
1458 tbm_bufmgr_get_capability(tbm_bufmgr bufmgr)
1460 unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE;
1462 _tbm_bufmgr_mutex_lock();
1464 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), TBM_BUFMGR_CAPABILITY_NONE);
1465 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, TBM_BUFMGR_CAPABILITY_NONE);
1467 TBM_TRACE("tbm_bufmgr(%p) capability(%u)\n", bufmgr, bufmgr->capabilities);
1469 capabilities = bufmgr->capabilities;
1471 _tbm_bufmgr_mutex_unlock();
1473 return capabilities;
1477 tbm_bo_get_flags(tbm_bo bo)
1481 _tbm_bufmgr_mutex_lock();
1483 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1484 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1488 TBM_TRACE("bo(%p)\n", bo);
1490 _tbm_bufmgr_mutex_unlock();
1495 /* LCOV_EXCL_START */
1497 tbm_get_last_error(void)
1499 return tbm_last_error;
1503 tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
1505 char app_name[255] = {0,}, title[512] = {0,};
1506 tbm_surface_debug_data *debug_old_data = NULL;
1511 pthread_mutex_lock(&gLock);
1513 if (!TBM_BUFMGR_IS_VALID(bufmgr) || (bufmgr != gBufMgr)) {
1514 TBM_LOG_E("invalid bufmgr\n");
1515 pthread_mutex_unlock(&gLock);
1521 TBM_LOG_E("Fail to allocate the string.\n");
1522 pthread_mutex_unlock(&gLock);
1526 TBM_SNRPRINTF(str, len, c, "\n");
1527 _tbm_util_get_appname_from_pid(getpid(), app_name);
1528 _tbm_util_get_appname_brief(app_name);
1529 TBM_SNRPRINTF(str, len, c, "============TBM DEBUG: %s(%d)===========================\n",
1530 app_name, getpid());
1532 snprintf(title, 255, "%s", "no surface refcnt width height bpp size n_b n_p flags format app_name ");
1534 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
1535 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
1536 strncat(title, " ", MAX_SIZE_N(title));
1537 strncat(title, debug_old_data->key, MAX_SIZE_N(title));
1541 TBM_SNRPRINTF(str, len, c, "[tbm_surface information]\n");
1542 TBM_SNRPRINTF(str, len, c, "%s\n", title);
1544 /* show the tbm_surface information in surf_list */
1545 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
1546 tbm_surface_h surf = NULL;
1549 LIST_FOR_EACH_ENTRY(surf, &bufmgr->surf_list, item_link) {
1550 char data[512] = {0,};
1554 pid = _tbm_surface_internal_get_debug_pid(surf);
1556 /* if pid is null, set the self_pid */
1560 memset(app_name, 0x0, 255 * sizeof(char));
1561 _tbm_util_get_appname_from_pid(pid, app_name);
1562 _tbm_util_get_appname_brief(app_name);
1564 snprintf(data, 255, "%-2d %-9p %-4d %-5u %-6u %-3u %-6u %-2d %-2d %-3d %-8s %-15s",
1571 surf->info.size / 1024,
1575 _tbm_surface_internal_format_to_str(surf->info.format) + 11,
1578 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
1579 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
1582 strncat(data, " ", MAX_SIZE_N(title));
1584 value = _tbm_surface_internal_get_debug_data(surf, debug_old_data->key);
1586 strncat(data, value, MAX_SIZE_N(title));
1588 strncat(data, "none", MAX_SIZE_N(title));
1591 TBM_SNRPRINTF(str, len, c, "%s\n", data);
1593 for (i = 0; i < surf->num_bos; i++) {
1594 TBM_SNRPRINTF(str, len, c, " bo:%-12p %-26d%-10d\n",
1596 surf->bos[i]->ref_cnt,
1597 bufmgr->backend->bo_size(surf->bos[i]) / 1024);
1601 TBM_SNRPRINTF(str, len, c, " no tbm_surfaces.\n");
1602 TBM_SNRPRINTF(str, len, c, "\n");
1604 TBM_SNRPRINTF(str, len, c, "[tbm_bo information]\n");
1605 TBM_SNRPRINTF(str, len, c, "no bo refcnt size lock_cnt map_cnt flags surface name\n");
1607 /* show the tbm_bo information in bo_list */
1608 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
1612 LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) {
1613 TBM_SNRPRINTF(str, len, c, "%-4d%-11p %-4d %-6d %-5d %-4u %-3d %-11p %-4d\n",
1617 bufmgr->backend->bo_size(bo) / 1024,
1622 bufmgr->backend->bo_export(bo));
1625 TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n");
1626 TBM_SNRPRINTF(str, len, c, "\n");
1628 TBM_SNRPRINTF(str, len, c, "===============================================================\n");
1630 pthread_mutex_unlock(&gLock);
1636 tbm_bufmgr_debug_show(tbm_bufmgr bufmgr)
1639 str = tbm_bufmgr_debug_tbm_info_get(bufmgr);
1641 TBM_DEBUG(" %s", str);
1647 tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff)
1649 _tbm_bufmgr_mutex_lock();
1651 TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
1652 TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
1655 TBM_LOG_D("bufmgr=%p onoff=%d\n", bufmgr, onoff);
1659 _tbm_bufmgr_mutex_unlock();
1663 tbm_bufmgr_debug_dump_set_scale(double scale)
1665 pthread_mutex_lock(&gLock);
1666 scale_factor = scale;
1667 pthread_mutex_unlock(&gLock);
1671 tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff)
1673 pthread_mutex_lock(&gLock);
1676 TBM_LOG_D("count=%d onoff=%d\n", count, onoff);
1678 tbm_surface_internal_dump_end();
1683 TBM_LOG_E("path is null");
1684 pthread_mutex_unlock(&gLock);
1687 TBM_LOG_D("path=%s count=%d onoff=%d\n", path, count, onoff);
1689 if (_tbm_util_get_max_surface_size(&w, &h) == 0) {
1690 TBM_LOG_E("Fail to get tbm_surface size.\n");
1691 pthread_mutex_unlock(&gLock);
1695 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
1701 pthread_mutex_unlock(&gLock);
1706 tbm_bufmgr_debug_dump_all(char *path)
1708 int w, h, count = 0;
1709 tbm_surface_h surface = NULL;
1711 TBM_RETURN_VAL_IF_FAIL(path != NULL, 0);
1712 TBM_LOG_D("path=%s\n", path);
1714 pthread_mutex_lock(&gLock);
1716 count = _tbm_util_get_max_surface_size(&w, &h);
1718 TBM_LOG_E("No tbm_surface.\n");
1719 pthread_mutex_unlock(&gLock);
1723 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
1726 LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link)
1727 tbm_surface_internal_dump_buffer(surface, "dump_all");
1729 tbm_surface_internal_dump_end();
1731 pthread_mutex_unlock(&gLock);
1736 /* internal function */
1738 _tbm_bufmgr_get_bufmgr(void)
1744 _tbm_bo_set_surface(tbm_bo bo, tbm_surface_h surface)
1746 _tbm_bufmgr_mutex_lock();
1748 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1749 TBM_BUFMGR_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1751 bo->surface = surface;
1753 _tbm_bufmgr_mutex_unlock();
1759 tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *NativeDisplay)
1763 _tbm_bufmgr_mutex_lock();
1765 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
1767 if (!bufmgr->backend->bufmgr_bind_native_display) {
1768 TBM_TRACE("skip: tbm_bufmgr(%p) NativeDisplay(%p)\n",
1769 bufmgr, NativeDisplay);
1770 _tbm_bufmgr_mutex_unlock();
1774 ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, NativeDisplay);
1776 TBM_LOG_E("error: tbm_bufmgr(%p) NativeDisplay(%p)\n",
1777 bufmgr, NativeDisplay);
1778 _tbm_bufmgr_mutex_unlock();
1782 TBM_TRACE("tbm_bufmgr(%p) NativeDisplay(%p)\n", bufmgr, NativeDisplay);
1784 _tbm_bufmgr_mutex_unlock();
1789 int tbm_bufmgr_get_fd_limit(void)
1793 if (getrlimit(RLIMIT_NOFILE, &lim))
1796 return (int)lim.rlim_cur;
1798 /* LCOV_EXCL_STOP */