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 #ifdef TBM_BUFMGR_INIT_TIME
212 struct timeval start_tv, end_tv;
216 #ifdef TBM_BUFMGR_INIT_TIME
217 /* get the start tv */
218 gettimeofday(&start_tv, NULL);
223 /* LCOV_EXCL_START */
225 env = getenv("TBM_TRACE");
227 trace_mask = atoi(env);
228 TBM_DBG("TBM_TRACE=%s\n", env);
233 pthread_mutex_lock(&gLock);
235 _tbm_set_last_result(TBM_ERROR_NONE);
238 TBM_WRN("!!!!!WARNING:: The tbm_bufmgr_init DOSE NOT use argument fd ANYMORE.\n");
239 TBM_WRN("!!!!!WARNING:: IT WILL BE CHANGED like tbm_bufmgr_init(int fd) --> tbm_bufmgr_init(void).\n");
243 /* initialize buffer manager */
245 gBufMgr->ref_count++;
246 TBM_DBG("reuse tbm_bufmgr(%p) ref_count(%d) fd(%d)\n", gBufMgr, gBufMgr->ref_count, gBufMgr->fd);
247 pthread_mutex_unlock(&gLock);
251 TBM_DBG("bufmgr init\n");
253 /* allocate bufmgr */
254 gBufMgr = calloc(1, sizeof(struct _tbm_bufmgr));
256 TBM_ERR("error: fail to alloc bufmgr fd(%d)\n", fd);
257 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
258 pthread_mutex_unlock(&gLock);
264 /* set the display_server flag before loading the backend module */
266 TBM_INFO("The tbm_bufmgr(%p) is used by display server. Need to bind the native_display.\n", gBufMgr);
267 gBufMgr->display_server = 1;
270 /* load bufmgr priv from env */
271 gBufMgr->module = tbm_module_load(gBufMgr->fd);
272 if (!gBufMgr->module) {
273 TBM_ERR("error : Fail to load bufmgr backend\n");
274 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
277 pthread_mutex_unlock(&gLock);
282 // TODO: this is temporary. it will be removed after finishing refactoring the tbm_module.
283 _tbm_bufmgr_copy_module_data(gBufMgr, gBufMgr->module, 0);
285 /* check the essential capabilities of tbm_module */
286 gBufMgr->capabilities = tbm_module_bufmgr_get_capabilities(gBufMgr->module);
287 if (gBufMgr->capabilities == HAL_TBM_BUFMGR_CAPABILITY_NONE) {
288 TBM_ERR("The capabilities of the backend module is TBM_BUFMGR_CAPABILITY_NONE.");
289 TBM_ERR("TBM_BUFMGR_CAPABILITY_SHARE_FD is the essential capability.");
290 tbm_module_unload(gBufMgr->module);
291 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
294 pthread_mutex_unlock(&gLock);
298 if (!(gBufMgr->capabilities & HAL_TBM_BUFMGR_CAPABILITY_SHARE_FD)) {
299 TBM_ERR("The capabilities of the backend module had no TBM_BUFMGR_CAPABILITY_SHARE_FD.");
300 TBM_ERR("The tbm backend has to get TBM_BUFMGR_CAPABILITY_SHARE_FD. ");
301 tbm_module_unload(gBufMgr->module);
302 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
305 pthread_mutex_unlock(&gLock);
311 gBufMgr->ref_count = 1;
313 TBM_INFO("create tizen bufmgr:%p ref_count:%d\n",
314 gBufMgr, gBufMgr->ref_count);
316 /* setup the bo_lock_type */
317 env = getenv("BUFMGR_LOCK_TYPE");
318 if (env && !strcmp(env, "always"))
319 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS;
320 else if (env && !strcmp(env, "none"))
321 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_NEVER;
322 else if (env && !strcmp(env, "once"))
323 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_ONCE;
325 gBufMgr->bo_lock_type = TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS;
327 TBM_DBG("BUFMGR_LOCK_TYPE=%s\n", env ? env : "default:once");
329 /* intialize bo_list */
330 LIST_INITHEAD(&gBufMgr->bo_list);
332 /* intialize surf_list */
333 LIST_INITHEAD(&gBufMgr->surf_list);
335 /* intialize surf_queue_list */
336 LIST_INITHEAD(&gBufMgr->surf_queue_list);
338 /* intialize debug_key_list */
339 LIST_INITHEAD(&gBufMgr->debug_key_list);
341 #ifdef TBM_BUFMGR_INIT_TIME
343 gettimeofday(&end_tv, NULL);
344 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)));
347 pthread_mutex_unlock(&gLock);
353 tbm_bufmgr_init(int fd)
357 bufmgr = _tbm_bufmgr_init(fd, 0);
363 tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
365 TBM_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
367 _tbm_bufmgr_mutex_lock();
368 pthread_mutex_lock(&gLock);
369 _tbm_set_last_result(TBM_ERROR_NONE);
372 TBM_ERR("gBufmgr already destroy: bufmgr:%p\n", bufmgr);
373 pthread_mutex_unlock(&gLock);
374 _tbm_bufmgr_mutex_unlock();
379 if (bufmgr->ref_count > 0) {
380 TBM_DBG("reduce a ref_count(%d) of tbm_bufmgr(%p)\n", bufmgr->ref_count, bufmgr);
381 pthread_mutex_unlock(&gLock);
382 _tbm_bufmgr_mutex_unlock();
386 /* destroy bo_list */
387 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
388 tbm_bo bo = NULL, tmp;
390 LIST_FOR_EACH_ENTRY_SAFE(bo, tmp, &bufmgr->bo_list, item_link) {
391 TBM_ERR("Un-freed bo(%p, ref:%d)\n", bo, bo->ref_cnt);
394 LIST_DELINIT(&bufmgr->bo_list);
397 /* destroy surf_list */
398 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
399 tbm_surface_h surf = NULL, tmp;
401 LIST_FOR_EACH_ENTRY_SAFE(surf, tmp, &bufmgr->surf_list, item_link) {
402 TBM_ERR("Un-freed surf(%p, ref:%d)\n", surf, surf->refcnt);
403 tbm_surface_destroy(surf);
405 LIST_DELINIT(&bufmgr->surf_list);
408 tbm_module_unload(bufmgr->module);
410 // TODO: this is temporary. it will be removed after finishing refactoring the tbm_module.
411 _tbm_bufmgr_copy_module_data(bufmgr, bufmgr->module, 1);
416 TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr);
421 pthread_mutex_unlock(&gLock);
422 _tbm_bufmgr_mutex_unlock();
426 tbm_bufmgr_get_capability(tbm_bufmgr bufmgr)
428 unsigned int capabilities = TBM_BUFMGR_CAPABILITY_NONE;
430 _tbm_bufmgr_mutex_lock();
431 _tbm_set_last_result(TBM_ERROR_NONE);
433 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), TBM_BUFMGR_CAPABILITY_NONE);
434 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, TBM_BUFMGR_CAPABILITY_NONE);
436 capabilities = bufmgr->capabilities;
438 _tbm_bufmgr_mutex_unlock();
443 /* LCOV_EXCL_START */
445 tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
447 char app_name[255] = {0,}, title[512] = {0,};
448 tbm_surface_debug_data *debug_old_data = NULL;
456 pthread_mutex_lock(&gLock);
457 _tbm_set_last_result(TBM_ERROR_NONE);
459 if (!TBM_BUFMGR_IS_VALID(bufmgr) || (bufmgr != gBufMgr)) {
460 TBM_ERR("invalid bufmgr\n");
461 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
462 pthread_mutex_unlock(&gLock);
468 TBM_ERR("Fail to allocate the string.\n");
469 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
470 pthread_mutex_unlock(&gLock);
474 TBM_SNRPRINTF(str, len, c, "\n");
475 pid = syscall(SYS_getpid);
476 _tbm_util_get_appname_from_pid(pid, app_name);
477 _tbm_util_get_appname_brief(app_name);
478 TBM_SNRPRINTF(str, len, c, "===========================================TBM DEBUG: %s(%ld)===========================================\n",
481 snprintf(title, 255, "%s", "no surface refcnt width height bpp size n_b n_p flags format app_name ");
483 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
484 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
485 strncat(title, " ", MAX_SIZE_N(title));
486 strncat(title, debug_old_data->key, MAX_SIZE_N(title));
490 TBM_SNRPRINTF(str, len, c, "[tbm_surface information]\n");
491 TBM_SNRPRINTF(str, len, c, "%s\n", title);
493 /* show the tbm_surface information in surf_list */
494 if (!LIST_IS_EMPTY(&bufmgr->surf_list)) {
495 tbm_surface_h surf = NULL;
498 LIST_FOR_EACH_ENTRY(surf, &bufmgr->surf_list, item_link) {
499 char data[512] = {0,};
500 unsigned int surf_pid = 0;
503 surf_pid = _tbm_surface_internal_get_debug_pid(surf);
505 /* if pid is null, set the self_pid */
506 surf_pid = syscall(SYS_getpid);;
509 memset(app_name, 0x0, 255 * sizeof(char));
510 if (geteuid() == 0) {
511 _tbm_util_get_appname_from_pid(surf_pid, app_name);
512 _tbm_util_get_appname_brief(app_name);
514 snprintf(app_name, sizeof(app_name), "%d", surf_pid);
517 snprintf(data, 255, "%-3d %-11p %-5d %-6u %-7u %-4u %-7u %-3d %-3d %-8d %-9s %-22s",
524 surf->info.size / 1024,
528 _tbm_surface_internal_format_to_str(surf->info.format) + 11,
531 if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
532 LIST_FOR_EACH_ENTRY(debug_old_data, &bufmgr->debug_key_list, item_link) {
535 strncat(data, " ", MAX_SIZE_N(title));
537 value = _tbm_surface_internal_get_debug_data(surf, debug_old_data->key);
539 strncat(data, value, MAX_SIZE_N(title));
541 strncat(data, "none", MAX_SIZE_N(title));
544 TBM_SNRPRINTF(str, len, c, "%s\n", data);
546 for (i = 0; i < surf->num_bos; i++) {
547 if (bufmgr->use_hal_tbm) {
548 size = hal_tbm_bo_get_size((hal_tbm_bo *)surf->bos[i]->bo_data, (hal_tbm_error *)&error);
549 if (error != TBM_ERROR_NONE)
550 TBM_WRN("fail to get the size of bo.");
551 } else if (bufmgr->backend_module_data) {
552 size = bufmgr->bo_func->bo_get_size(surf->bos[i]->bo_data, &error);
553 if (error != TBM_ERROR_NONE)
554 TBM_WRN("fail to get the size of bo.");
556 size = bufmgr->backend->bo_size(surf->bos[i]);
557 TBM_SNRPRINTF(str, len, c, " bo:%-12p %-26d%-10d\n",
559 surf->bos[i]->ref_cnt,
564 TBM_SNRPRINTF(str, len, c, " no tbm_surfaces.\n");
565 TBM_SNRPRINTF(str, len, c, "\n");
567 TBM_SNRPRINTF(str, len, c, "[tbm_bo information]\n");
568 TBM_SNRPRINTF(str, len, c, "no bo refcnt size lock_cnt map_cnt flags surface name\n");
570 /* show the tbm_bo information in bo_list */
571 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
576 LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) {
577 if (bo->bufmgr->use_hal_tbm) {
578 size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
579 if (error != TBM_ERROR_NONE)
580 TBM_WRN("fail to get the size of bo.");
581 key = (tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
582 } else if (bufmgr->backend_module_data) {
583 size = bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
584 if (error != TBM_ERROR_NONE)
585 TBM_WRN("fail to get the size of bo.");
586 key = bufmgr->bo_func->bo_export_key(bo->bo_data, &error);
587 if (error != TBM_ERROR_NONE)
588 TBM_WRN("fail to get the tdm_key of bo.");
590 size = bufmgr->backend->bo_size(bo);
591 key = bufmgr->backend->bo_export(bo);
593 TBM_SNRPRINTF(str, len, c, "%-3d %-11p %-5d %-7d %-6d %-5u %-7d %-11p %-4d\n",
605 TBM_SNRPRINTF(str, len, c, "no tbm_bos.\n");
606 TBM_SNRPRINTF(str, len, c, "\n");
608 TBM_SNRPRINTF(str, len, c, "========================================================================================================\n");
610 pthread_mutex_unlock(&gLock);
616 tbm_bufmgr_debug_show(tbm_bufmgr bufmgr)
619 str = tbm_bufmgr_debug_tbm_info_get(bufmgr);
627 tbm_bufmgr_debug_trace(tbm_bufmgr bufmgr, int onoff)
629 _tbm_bufmgr_mutex_lock();
630 _tbm_set_last_result(TBM_ERROR_NONE);
632 TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
633 TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
636 TBM_LOG_D("bufmgr=%p onoff=%d\n", bufmgr, onoff);
640 _tbm_bufmgr_mutex_unlock();
644 tbm_bufmgr_debug_set_trace_mask(tbm_bufmgr bufmgr, tbm_bufmgr_debug_trace_mask mask, int set)
646 _tbm_bufmgr_mutex_lock();
647 _tbm_set_last_result(TBM_ERROR_NONE);
649 TBM_BUFMGR_RETURN_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr));
650 TBM_BUFMGR_RETURN_IF_FAIL(bufmgr == gBufMgr);
655 TBM_INFO("bufmgr=%p sets the trace_mask=%d\n", bufmgr, mask);
656 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_BO)
657 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_BO");
658 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL)
659 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL");
660 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE)
661 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE");
662 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE)
663 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE");
664 } else if (set == 0) {
667 TBM_INFO("bufmgr=%p unsets the trace_mask=%d\n", bufmgr, mask);
668 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_BO)
669 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_BO");
670 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL)
671 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_INTERNAL");
672 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE)
673 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE");
674 if (trace_mask&TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE)
675 TBM_INFO(" TBM_BUFGMR_DEBUG_TRACE_SURFACE_QUEUE");
677 TBM_WRN("set value is wrong.(set=%d)", set);
680 _tbm_bufmgr_mutex_unlock();
684 tbm_bufmgr_debug_dump_set_scale(double scale)
686 pthread_mutex_lock(&gLock);
687 _tbm_set_last_result(TBM_ERROR_NONE);
688 scale_factor = scale;
689 pthread_mutex_unlock(&gLock);
693 tbm_bufmgr_debug_get_ref_count(void)
697 pthread_mutex_lock(&gLock);
699 _tbm_set_last_result(TBM_ERROR_NONE);
701 refcnt = (gBufMgr) ? gBufMgr->ref_count : 0;
703 pthread_mutex_unlock(&gLock);
709 tbm_bufmgr_debug_queue_dump(char *path, int count, int onoff)
711 pthread_mutex_lock(&gLock);
712 _tbm_set_last_result(TBM_ERROR_NONE);
715 TBM_DBG("count=%d onoff=%d\n", count, onoff);
717 tbm_surface_internal_dump_end();
722 TBM_ERR("path is null");
723 pthread_mutex_unlock(&gLock);
726 TBM_DBG("path=%s count=%d onoff=%d\n", path, count, onoff);
728 if (_tbm_util_get_max_surface_size(&w, &h) == 0) {
729 TBM_ERR("Fail to get tbm_surface size.\n");
730 pthread_mutex_unlock(&gLock);
734 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
740 pthread_mutex_unlock(&gLock);
746 tbm_bufmgr_debug_dump_all(char *path)
749 tbm_surface_h surface = NULL;
751 pthread_mutex_lock(&gLock);
752 _tbm_set_last_result(TBM_ERROR_NONE);
755 TBM_ERR("path is null.\n");
756 pthread_mutex_unlock(&gLock);
760 TBM_DBG("path=%s\n", path);
762 count = _tbm_util_get_max_surface_size(&w, &h);
764 TBM_ERR("No tbm_surface.\n");
765 pthread_mutex_unlock(&gLock);
769 tbm_surface_internal_dump_with_scale_start(path, w, h, count, scale_factor);
772 LIST_FOR_EACH_ENTRY(surface, &gBufMgr->surf_list, item_link)
773 tbm_surface_internal_dump_buffer(surface, "dump_all");
775 tbm_surface_internal_dump_end();
777 pthread_mutex_unlock(&gLock);
782 /* internal function */
784 _tbm_bufmgr_get_bufmgr(void)
790 tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display)
795 _tbm_bufmgr_mutex_lock();
796 _tbm_set_last_result(TBM_ERROR_NONE);
798 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
800 if (bufmgr->use_hal_tbm) {
801 if (hal_tbm_backend_has_drm_device(bufmgr->hal_backend, &ret)) {
802 int fd = tbm_drm_helper_get_fd(); // this must be the auth drm_fd.(master drm_fd);
804 TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display);
805 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
806 _tbm_bufmgr_mutex_unlock();
810 // make the wayland server socket for sending the authenticated drm_fd to wayland clients.
811 if (!tbm_drm_helper_wl_auth_server_init(native_display, fd, NULL, 0)) {
812 TBM_ERR("error: tbm_drm_helper_wl_auth_server_init failed\n", bufmgr, native_display);
814 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
815 _tbm_bufmgr_mutex_unlock();
818 TBM_INFO("tbm creates a wayland socket for authentication of drm_fd.");
820 bufmgr->auth_wl_socket_created = 1;
821 bufmgr->auth_fd = fd;
823 // TODO: this duplication will be removed after refactoring tbm_module
824 bufmgr->module->auth_wl_socket_created = 1;
825 bufmgr->module->auth_fd = fd;
827 } else if (bufmgr->backend_module_data) {
828 if (!bufmgr->bufmgr_func->bufmgr_bind_native_display) {
829 TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n",
830 bufmgr, native_display);
831 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
832 _tbm_bufmgr_mutex_unlock();
836 error = bufmgr->bufmgr_func->bufmgr_bind_native_display(bufmgr->bufmgr_data, (tbm_native_display *)native_display);
837 if (error != TBM_ERROR_NONE) {
838 TBM_ERR("error: tbm_bufmgr(%p) native_display(%p) error(%d)\n",
839 bufmgr, native_display, error);
840 _tbm_set_last_result(error);
841 _tbm_bufmgr_mutex_unlock();
846 if (!bufmgr->backend->bufmgr_bind_native_display) {
847 TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n",
848 bufmgr, native_display);
849 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
850 _tbm_bufmgr_mutex_unlock();
854 ret = bufmgr->backend->bufmgr_bind_native_display(bufmgr, native_display);
856 TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n",
857 bufmgr, native_display);
858 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
859 _tbm_bufmgr_mutex_unlock();
864 TBM_INFO("tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display);
866 _tbm_bufmgr_mutex_unlock();
872 tbm_bufmgr_server_init(void)
876 bufmgr = _tbm_bufmgr_init(-1, 1);
882 tbm_bufmgr_set_bo_lock_type(tbm_bufmgr bufmgr, tbm_bufmgr_bo_lock_type bo_lock_type)
884 _tbm_bufmgr_mutex_lock();
885 _tbm_set_last_result(TBM_ERROR_NONE);
887 TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
888 TBM_BUFMGR_RETURN_VAL_IF_FAIL(bufmgr == gBufMgr, 0);
890 pthread_mutex_lock(&gLock);
891 gBufMgr->bo_lock_type = bo_lock_type;
892 pthread_mutex_unlock(&gLock);
894 TBM_INFO("The bo_lock_type of the bo is %d\n", bo_lock_type);
896 _tbm_bufmgr_mutex_unlock();
902 int tbm_bufmgr_get_fd_limit(void)
906 if (getrlimit(RLIMIT_NOFILE, &lim))
909 return (int)lim.rlim_cur;
912 tbm_bufmgr tbm_bufmgr_get(void)