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_drm_helper.h"
39 #include <sys/resource.h>
50 static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
51 static pthread_mutex_t tbm_bufmgr_lock = PTHREAD_MUTEX_INITIALIZER;
52 static double scale_factor = 0;
53 void _tbm_bufmgr_mutex_unlock(void);
55 //#define TBM_BUFMGR_INIT_TIME
57 #define MAX_SIZE_N(dest) (sizeof(dest) - strlen(dest) - 1)
60 #define TBM_BUFMGR_RETURN_IF_FAIL(cond) {\
62 TBM_ERR("'%s' failed.\n", #cond);\
63 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
64 _tbm_bufmgr_mutex_unlock();\
69 #define TBM_BUFMGR_RETURN_VAL_IF_FAIL(cond, val) {\
71 TBM_ERR("'%s' failed.\n", #cond);\
72 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
73 _tbm_bufmgr_mutex_unlock();\
81 _tbm_bufmgr_mutex_lock(void)
83 pthread_mutex_lock(&tbm_bufmgr_lock);
87 _tbm_bufmgr_mutex_unlock(void)
89 pthread_mutex_unlock(&tbm_bufmgr_lock);
93 _tbm_util_get_max_surface_size(int *w, int *h)
95 tbm_surface_info_s info;
96 tbm_surface_h surface = NULL;
102 if (gBufMgr == NULL || LIST_IS_EMPTY(&gBufMgr->surf_list))
105 LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link) {
106 if (tbm_surface_get_info(surface, &info) == TBM_SURFACE_ERROR_NONE) {
110 if (*h < info.height)
119 _tbm_util_get_appname_brief(char *brief)
123 char temp[255] = {0,};
124 char *saveptr = NULL;
126 token = strtok_r(brief, delim, &saveptr);
128 while (token != NULL) {
129 memset(temp, 0x00, 255 * sizeof(char));
130 strncpy(temp, token, 254 * sizeof(char));
131 token = strtok_r(NULL, delim, &saveptr);
134 snprintf(brief, sizeof(temp), "%s", temp);
138 _tbm_util_get_appname_from_pid(long pid, char *str)
140 char fn_cmdline[255] = {0, }, cmdline[255];
144 if (pid <= 0) return;
146 snprintf(fn_cmdline, sizeof(fn_cmdline), "/proc/%ld/cmdline", pid);
148 fp = fopen(fn_cmdline, "r");
150 TBM_ERR("cannot file open %s\n", fn_cmdline);
154 if (!fgets(cmdline, 255, fp)) {
155 TBM_ERR("fail to get appname for pid(%ld)\n", pid);
162 len = strlen(cmdline);
164 memset(cmdline, 0x00, 255);
168 snprintf(str, sizeof(cmdline), "%s", cmdline);
172 _tbm_bufmgr_copy_module_data(tbm_bufmgr bufmgr, tbm_module *module, int reset)
175 bufmgr->module_data = module->module_data;
176 bufmgr->backend = module->backend;
178 bufmgr->backend_module_data = module->backend_module_data;
179 bufmgr->bufmgr_data = module->bufmgr_data;
180 bufmgr->bufmgr_func = module->bufmgr_func;
181 bufmgr->bo_func = module->bo_func;
183 bufmgr->use_hal_tbm = module->use_hal_tbm;
184 bufmgr->auth_wl_socket_created = module->auth_wl_socket_created;
185 bufmgr->auth_fd = module->auth_fd;
186 bufmgr->hal_backend = module->hal_backend;
187 bufmgr->hal_bufmgr = module->hal_bufmgr;
189 bufmgr->module_data = NULL;
190 bufmgr->backend = NULL;
192 bufmgr->backend_module_data = NULL;
193 bufmgr->bufmgr_data = NULL;
194 bufmgr->bufmgr_func = NULL;
195 bufmgr->bo_func = NULL;
197 bufmgr->use_hal_tbm = 0;
198 bufmgr->auth_wl_socket_created = 0;
199 bufmgr->auth_fd = -1;
200 bufmgr->hal_backend = NULL;
201 bufmgr->hal_bufmgr = NULL;
209 _tbm_bufmgr_init(int fd, int server)
211 tbm_error_e error = TBM_ERROR_NONE;
213 #ifdef TBM_BUFMGR_INIT_TIME
214 struct timeval start_tv, end_tv;
218 #ifdef TBM_BUFMGR_INIT_TIME
219 /* get the start tv */
220 gettimeofday(&start_tv, NULL);
225 /* LCOV_EXCL_START */
227 env = getenv("TBM_TRACE");
229 trace_mask = atoi(env);
230 TBM_DBG("TBM_TRACE=%s\n", env);
235 pthread_mutex_lock(&gLock);
237 _tbm_set_last_result(TBM_ERROR_NONE);
240 TBM_WRN("!!!!!WARNING:: The tbm_bufmgr_init DOSE NOT use argument fd ANYMORE.\n");
241 TBM_WRN("!!!!!WARNING:: IT WILL BE CHANGED like tbm_bufmgr_init(int fd) --> tbm_bufmgr_init(void).\n");
245 /* initialize buffer manager */
247 gBufMgr->ref_count++;
248 TBM_DBG("reuse tbm_bufmgr(%p) ref_count(%d) fd(%d)\n", gBufMgr, gBufMgr->ref_count, gBufMgr->fd);
249 pthread_mutex_unlock(&gLock);
253 TBM_DBG("bufmgr init\n");
255 /* allocate bufmgr */
256 gBufMgr = calloc(1, sizeof(struct _tbm_bufmgr));
258 TBM_ERR("error: fail to alloc bufmgr fd(%d)\n", fd);
259 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
260 pthread_mutex_unlock(&gLock);
266 /* set the display_server flag before loading the backend module */
268 TBM_INFO("The tbm_bufmgr(%p) is used by display server. Need to bind the native_display.\n", gBufMgr);
269 gBufMgr->display_server = 1;
272 /* load bufmgr priv from env */
273 gBufMgr->module = tbm_module_load(gBufMgr->fd);
274 if (!gBufMgr->module) {
275 TBM_ERR("error : Fail to load bufmgr backend\n");
276 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
279 pthread_mutex_unlock(&gLock);
284 // TODO: this is temporary. it will be removed after finishing refactoring the tbm_module.
285 _tbm_bufmgr_copy_module_data(gBufMgr, gBufMgr->module, 0);
287 /* check the essential capabilities of tbm_module */
288 gBufMgr->capabilities = tbm_module_bufmgr_get_capabilities(gBufMgr->module, &error);
289 if (gBufMgr->capabilities == TBM_BUFMGR_CAPABILITY_NONE) {
290 TBM_ERR("The capabilities of the backend module is TBM_BUFMGR_CAPABILITY_NONE.");
291 TBM_ERR("TBM_BUFMGR_CAPABILITY_SHARE_FD is the essential capability.");
292 tbm_module_unload(gBufMgr->module);
293 _tbm_set_last_result(error);
296 pthread_mutex_unlock(&gLock);
300 if (!(gBufMgr->capabilities & TBM_BUFMGR_CAPABILITY_SHARE_FD)) {
301 TBM_ERR("The capabilities of the backend module had no TBM_BUFMGR_CAPABILITY_SHARE_FD.");
302 TBM_ERR("The tbm backend has to get TBM_BUFMGR_CAPABILITY_SHARE_FD. ");
303 tbm_module_unload(gBufMgr->module);
304 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
307 pthread_mutex_unlock(&gLock);
313 gBufMgr->ref_count = 1;
315 TBM_INFO("create tizen bufmgr:%p ref_count:%d\n",
316 gBufMgr, gBufMgr->ref_count);
318 /* setup the bo_lock_type */
319 env = getenv("BUFMGR_LOCK_TYPE");
320 if (env && !strcmp(env, "always"))
321 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS;
322 else if (env && !strcmp(env, "none"))
323 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_NEVER;
324 else if (env && !strcmp(env, "once"))
325 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_ONCE;
327 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS;
329 TBM_DBG("BUFMGR_LOCK_TYPE=%s\n", env ? env : "default:once");
331 /* intialize bo_list */
332 LIST_INITHEAD(&gBufMgr->bo_list);
334 /* intialize surf_list */
335 LIST_INITHEAD(&gBufMgr->surf_list);
337 /* intialize surf_queue_list */
338 LIST_INITHEAD(&gBufMgr->surf_queue_list);
340 /* intialize debug_key_list */
341 LIST_INITHEAD(&gBufMgr->debug_key_list);
343 #ifdef TBM_BUFMGR_INIT_TIME
345 gettimeofday(&end_tv, NULL);
346 TBM_INFO("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)));
349 pthread_mutex_unlock(&gLock);
355 tbm_bufmgr_init(int fd)
359 bufmgr = _tbm_bufmgr_init(fd, 0);
365 tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
367 TBM_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
369 _tbm_bufmgr_mutex_lock();
370 pthread_mutex_lock(&gLock);
371 _tbm_set_last_result(TBM_ERROR_NONE);
374 TBM_ERR("gBufmgr already destroy: bufmgr:%p\n", bufmgr);
375 pthread_mutex_unlock(&gLock);
376 _tbm_bufmgr_mutex_unlock();
381 if (bufmgr->ref_count > 0) {
382 TBM_DBG("reduce a ref_count(%d) of tbm_bufmgr(%p)\n", bufmgr->ref_count, bufmgr);
383 pthread_mutex_unlock(&gLock);
384 _tbm_bufmgr_mutex_unlock();
388 /* destroy bo_list */
389 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
390 tbm_bo bo = NULL, tmp;
392 LIST_FOR_EACH_ENTRY_SAFE(bo, tmp, &bufmgr->bo_list, item_link) {
393 TBM_ERR("Un-freed bo(%p, ref:%d)\n", bo, bo->ref_cnt);
396 LIST_DELINIT(&bufmgr->bo_list);
399 /* destroy surf_list */
400 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
401 tbm_surface_h surf = NULL, tmp;
403 LIST_FOR_EACH_ENTRY_SAFE(surf, tmp, &bufmgr->surf_list, item_link) {
404 TBM_ERR("Un-freed surf(%p, ref:%d)\n", surf, surf->refcnt);
405 tbm_surface_destroy(surf);
407 LIST_DELINIT(&bufmgr->surf_list);
410 tbm_module_unload(bufmgr->module);
412 // TODO: this is temporary. it will be removed after finishing refactoring the tbm_module.
413 _tbm_bufmgr_copy_module_data(bufmgr, bufmgr->module, 1);
418 TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr);
423 pthread_mutex_unlock(&gLock);
424 _tbm_bufmgr_mutex_unlock();
428 tbm_bufmgr_get_capability(tbm_bufmgr bufmgr)
430 unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE;
432 _tbm_bufmgr_mutex_lock();
433 _tbm_set_last_result(TBM_ERROR_NONE);
435 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), TBM_BUFMGR_CAPABILITY_NONE);
436 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, TBM_BUFMGR_CAPABILITY_NONE);
438 capabilities = bufmgr->capabilities;
440 _tbm_bufmgr_mutex_unlock();
445 /* LCOV_EXCL_START */
447 tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
449 char app_name[255] = {0,}, title[512] = {0,};
450 tbm_surface_debug_data *debug_old_data = NULL;
458 pthread_mutex_lock(&gLock);
459 _tbm_set_last_result(TBM_ERROR_NONE);
461 if (!TBM_BUFMGR_IS_VALID(bufmgr) || (bufmgr != gBufMgr)) {
462 TBM_ERR("invalid bufmgr\n");
463 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
464 pthread_mutex_unlock(&gLock);
470 TBM_ERR("Fail to allocate the string.\n");
471 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
472 pthread_mutex_unlock(&gLock);
476 TBM_SNRPRINTF(str, len, c, "\n");
477 pid = syscall(SYS_getpid);
478 _tbm_util_get_appname_from_pid(pid, app_name);
479 _tbm_util_get_appname_brief(app_name);
480 TBM_SNRPRINTF(str, len, c, "===========================================TBM DEBUG: %s(%ld)===========================================\n",
483 snprintf(title, 255, "%s", "no surface refcnt width height bpp size n_b n_p flags format app_name ");
485 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
486 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
487 strncat(title, " ", MAX_SIZE_N(title));
488 strncat(title, debug_old_data->key, MAX_SIZE_N(title));
492 TBM_SNRPRINTF(str, len, c, "[tbm_surface information]\n");
493 TBM_SNRPRINTF(str, len, c, "%s\n", title);
495 /* show the tbm_surface information in surf_list */
496 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
497 tbm_surface_h surf = NULL;
500 LIST_FOR_EACH_ENTRY(surf, &bufmgr->surf_list, item_link) {
501 char data[512] = {0,};
502 unsigned int surf_pid = 0;
505 surf_pid = _tbm_surface_internal_get_debug_pid(surf);
507 /* if pid is null, set the self_pid */
508 surf_pid = syscall(SYS_getpid);;
511 memset(app_name, 0x0, 255 * sizeof(char));
512 if (geteuid() == 0) {
513 _tbm_util_get_appname_from_pid(surf_pid, app_name);
514 _tbm_util_get_appname_brief(app_name);
516 snprintf(app_name, sizeof(app_name), "%d", surf_pid);
519 snprintf(data, 255, "%-3d %-11p %-5d %-6u %-7u %-4u %-7u %-3d %-3d %-8d %-9s %-22s",
526 surf->info.size / 1024,
530 _tbm_surface_internal_format_to_str(surf->info.format) + 11,
533 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
534 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
537 strncat(data, " ", MAX_SIZE_N(title));
539 value = _tbm_surface_internal_get_debug_data(surf, debug_old_data->key);
541 strncat(data, value, MAX_SIZE_N(title));
543 strncat(data, "none", MAX_SIZE_N(title));
546 TBM_SNRPRINTF(str, len, c, "%s\n", data);
548 for (i = 0; i < surf->num_bos; i++) {
549 if (bufmgr->use_hal_tbm) {
550 size = hal_tbm_bo_get_size((hal_tbm_bo *)surf->bos[i]->bo_data, (hal_tbm_error *)&error);
551 if (error != TBM_ERROR_NONE)
552 TBM_WRN("fail to get the size of bo.");
553 } else if (bufmgr->backend_module_data) {
554 size = bufmgr->bo_func->bo_get_size(surf->bos[i]->bo_data, &error);
555 if (error != TBM_ERROR_NONE)
556 TBM_WRN("fail to get the size of bo.");
558 size = bufmgr->backend->bo_size(surf->bos[i]);
559 TBM_SNRPRINTF(str, len, c, " bo:%-12p %-26d%-10d\n",
561 surf->bos[i]->ref_cnt,
566 TBM_SNRPRINTF(str, len, c, " no tbm_surfaces.\n");
567 TBM_SNRPRINTF(str, len, c, "\n");
569 TBM_SNRPRINTF(str, len, c, "[tbm_bo information]\n");
570 TBM_SNRPRINTF(str, len, c, "no bo refcnt size lock_cnt map_cnt flags surface name\n");
572 /* show the tbm_bo information in bo_list */
573 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
578 LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) {
579 if (bo->bufmgr->use_hal_tbm) {
580 size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
581 if (error != TBM_ERROR_NONE)
582 TBM_WRN("fail to get the size of bo.");
583 key = (tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
584 } else if (bufmgr->backend_module_data) {
585 size = bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
586 if (error != TBM_ERROR_NONE)
587 TBM_WRN("fail to get the size of bo.");
588 key = bufmgr->bo_func->bo_export_key(bo->bo_data, &error);
589 if (error != TBM_ERROR_NONE)
590 TBM_WRN("fail to get the tdm_key of bo.");
592 size = bufmgr->backend->bo_size(bo);
593 key = bufmgr->backend->bo_export(bo);
595 TBM_SNRPRINTF(str, len, c, "%-3d %-11p %-5d %-7d %-6d %-5u %-7d %-11p %-4d\n",
607 TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n");
608 TBM_SNRPRINTF(str, len, c, "\n");
610 TBM_SNRPRINTF(str, len, c, "========================================================================================================\n");
612 pthread_mutex_unlock(&gLock);
618 tbm_bufmgr_debug_show(tbm_bufmgr bufmgr)
621 str = tbm_bufmgr_debug_tbm_info_get(bufmgr);
629 tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff)
631 _tbm_bufmgr_mutex_lock();
632 _tbm_set_last_result(TBM_ERROR_NONE);
634 TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
635 TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
638 TBM_LOG_D("bufmgr=%p onoff=%d\n", bufmgr, onoff);
642 _tbm_bufmgr_mutex_unlock();
646 tbm_bufmgr_debug_set_trace_mask(tbm_bufmgr bufmgr, tbm_bufmgr_debug_trace_mask mask, int set)
648 _tbm_bufmgr_mutex_lock();
649 _tbm_set_last_result(TBM_ERROR_NONE);
651 TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
652 TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
657 TBM_INFO("bufmgr=%p sets the trace_mask=%d\n", bufmgr, mask);
658 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_BO)
659 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_BO");
660 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL)
661 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL");
662 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE)
663 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE");
664 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE)
665 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE");
666 } else if (set == 0) {
669 TBM_INFO("bufmgr=%p unsets the trace_mask=%d\n", bufmgr, mask);
670 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_BO)
671 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_BO");
672 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL)
673 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL");
674 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE)
675 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE");
676 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE)
677 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE");
679 TBM_WRN("set value is wrong.(set=%d)", set);
682 _tbm_bufmgr_mutex_unlock();
686 tbm_bufmgr_debug_dump_set_scale(double scale)
688 pthread_mutex_lock(&gLock);
689 _tbm_set_last_result(TBM_ERROR_NONE);
690 scale_factor = scale;
691 pthread_mutex_unlock(&gLock);
695 tbm_bufmgr_debug_get_ref_count(void)
699 pthread_mutex_lock(&gLock);
701 _tbm_set_last_result(TBM_ERROR_NONE);
703 refcnt = (gBufMgr) ? gBufMgr->ref_count : 0;
705 pthread_mutex_unlock(&gLock);
711 tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff)
713 pthread_mutex_lock(&gLock);
714 _tbm_set_last_result(TBM_ERROR_NONE);
717 TBM_DBG("count=%d onoff=%d\n", count, onoff);
719 tbm_surface_internal_dump_end();
724 TBM_ERR("path is null");
725 pthread_mutex_unlock(&gLock);
728 TBM_DBG("path=%s count=%d onoff=%d\n", path, count, onoff);
730 if (_tbm_util_get_max_surface_size(&w, &h) == 0) {
731 TBM_ERR("Fail to get tbm_surface size.\n");
732 pthread_mutex_unlock(&gLock);
736 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
742 pthread_mutex_unlock(&gLock);
748 tbm_bufmgr_debug_dump_all(char *path)
751 tbm_surface_h surface = NULL;
753 pthread_mutex_lock(&gLock);
754 _tbm_set_last_result(TBM_ERROR_NONE);
757 TBM_ERR("path is null.\n");
758 pthread_mutex_unlock(&gLock);
762 TBM_DBG("path=%s\n", path);
764 count = _tbm_util_get_max_surface_size(&w, &h);
766 TBM_ERR("No tbm_surface.\n");
767 pthread_mutex_unlock(&gLock);
771 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
774 LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link)
775 tbm_surface_internal_dump_buffer(surface, "dump_all");
777 tbm_surface_internal_dump_end();
779 pthread_mutex_unlock(&gLock);
784 /* internal function */
786 _tbm_bufmgr_get_bufmgr(void)
792 tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display)
796 _tbm_bufmgr_mutex_lock();
797 _tbm_set_last_result(TBM_ERROR_NONE);
799 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), 0);
801 error = tbm_module_bufmgr_bind_native_display(bufmgr->module, native_display);
802 if (error != TBM_ERROR_NONE) {
803 _tbm_set_last_result(error);
804 _tbm_bufmgr_mutex_unlock();
806 if (error == TBM_ERROR_NOT_SUPPORTED) {
807 TBM_WRN("Not supported, so skip: tbm_bufmgr(%p) native_display(%p)", bufmgr, native_display);
814 TBM_INFO("tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display);
816 _tbm_bufmgr_mutex_unlock();
822 tbm_bufmgr_server_init(void)
826 bufmgr = _tbm_bufmgr_init(-1, 1);
832 tbm_bufmgr_set_bo_lock_type(tbm_bufmgr bufmgr, tbm_bufmgr_bo_lock_type bo_lock_type)
834 _tbm_bufmgr_mutex_lock();
835 _tbm_set_last_result(TBM_ERROR_NONE);
837 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
838 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, 0);
840 pthread_mutex_lock(&gLock);
841 gBufMgr->bo_lock_type = bo_lock_type;
842 pthread_mutex_unlock(&gLock);
844 TBM_INFO("The bo_lock_type of the bo is %d\n", bo_lock_type);
846 _tbm_bufmgr_mutex_unlock();
852 int tbm_bufmgr_get_fd_limit(void)
856 if (getrlimit(RLIMIT_NOFILE, &lim))
859 return (int)lim.rlim_cur;
862 tbm_bufmgr tbm_bufmgr_get(void)
869 tbm_bufmgr_internal_find_bo(tbm_bufmgr bufmgr, tbm_bo bo)
873 TBM_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), NULL);
874 TBM_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, NULL);
876 if (LIST_IS_EMPTY(&bufmgr->bo_list))
879 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
880 if (bo2->bo_data == bo->bo_data) {