use macro to debug mutex lock

Change-Id: I7dd7d6d4674444068009c8d2288b4ff5a1daa828

diff --git a/include/tdm_log.h b/include/tdm_log.h
index 451bbf8..1952e2a 100644 (file)
--- a/include/tdm_log.h
+++ b/include/tdm_log.h
@@ -52,7 +52,6 @@ extern "C" {
  * @endcode
  */
 extern int tdm_debug;
-extern int tdm_debug_buffer;
 
 //#define TDM_CONFIG_DLOG
 #ifdef TDM_CONFIG_DLOG

diff --git a/src/tdm.c b/src/tdm.c
index 1a02ef1..58c781a 100644 (file)
--- a/src/tdm.c
+++ b/src/tdm.c
@@ -461,11 +461,11 @@ tdm_display_update(tdm_display *dpy)
        TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 
        private_display = dpy;
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        ret = _tdm_display_update_internal(private_display, 1);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -475,6 +475,7 @@ tdm_display_update(tdm_display *dpy)
 
 int tdm_debug;
 int tdm_debug_buffer;
+int tdm_debug_mutex;
 
 static tdm_private_display *g_private_display;
 static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
@@ -697,11 +698,11 @@ tdm_display_init(tdm_error *error)
        const char *debug;
        tdm_error ret;
 
-       pthread_mutex_lock(&gLock);
+       _pthread_mutex_lock(&gLock);
 
        if (g_private_display) {
                g_private_display->init_count++;
-               pthread_mutex_unlock(&gLock);
+               _pthread_mutex_unlock(&gLock);
                if (error)
                        *error = TDM_ERROR_NONE;
                return g_private_display;
@@ -715,6 +716,10 @@ tdm_display_init(tdm_error *error)
        if (debug && (strstr(debug, "1")))
                tdm_debug_buffer = 1;
 
+       debug = getenv("TDM_DEBUG_MUTEX");
+       if (debug && (strstr(debug, "1")))
+               tdm_debug_mutex = 1;
+
        private_display = calloc(1, sizeof(tdm_private_display));
        if (!private_display) {
                ret = TDM_ERROR_OUT_OF_MEMORY;
@@ -745,7 +750,7 @@ tdm_display_init(tdm_error *error)
        if (error)
                *error = TDM_ERROR_NONE;
 
-       pthread_mutex_unlock(&gLock);
+       _pthread_mutex_unlock(&gLock);
 
        return (tdm_display *)private_display;
 
@@ -760,7 +765,7 @@ failed_alloc:
        tdm_debug_buffer = 0;
        if (error)
                *error = ret;
-       pthread_mutex_unlock(&gLock);
+       _pthread_mutex_unlock(&gLock);
        return NULL;
 }
 
@@ -772,22 +777,22 @@ tdm_display_deinit(tdm_display *dpy)
        if (!private_display)
                return;
 
-       pthread_mutex_lock(&gLock);
+       _pthread_mutex_lock(&gLock);
 
        private_display->init_count--;
        if (private_display->init_count > 0) {
-               pthread_mutex_unlock(&gLock);
+               _pthread_mutex_unlock(&gLock);
                return;
        }
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        _tdm_display_destroy_private_display(private_display);
        _tdm_display_unload_module(private_display);
 
        tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        pthread_mutex_destroy(&private_display->lock);
        free(private_display);
@@ -795,6 +800,6 @@ tdm_display_deinit(tdm_display *dpy)
        tdm_debug = 0;
        tdm_debug_buffer = 0;
 
-       pthread_mutex_unlock(&gLock);
+       _pthread_mutex_unlock(&gLock);
 }
 

diff --git a/src/tdm_backend.c b/src/tdm_backend.c
index 8f34672..9dfa2d1 100644 (file)
--- a/src/tdm_backend.c
+++ b/src/tdm_backend.c
@@ -78,9 +78,9 @@ tdm_backend_register_func_display(tdm_display *dpy,
        if (_check_abi_version(module, 1, 1) < 0)
                return TDM_ERROR_BAD_MODULE;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        private_display->func_display = *func_display;
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return TDM_ERROR_NONE;
 }
@@ -99,9 +99,9 @@ tdm_backend_register_func_output(tdm_display *dpy, tdm_func_output *func_output)
        if (_check_abi_version(module, 1, 1) < 0)
                return TDM_ERROR_BAD_MODULE;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        private_display->func_output = *func_output;
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return TDM_ERROR_NONE;
 }
@@ -120,9 +120,9 @@ tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer)
        if (_check_abi_version(module, 1, 1) < 0)
                return TDM_ERROR_BAD_MODULE;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        private_display->func_layer = *func_layer;
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return TDM_ERROR_NONE;
 }
@@ -135,10 +135,10 @@ tdm_backend_register_func_pp(tdm_display *dpy, tdm_func_pp *func_pp)
        if (!func_pp)
                return TDM_ERROR_NONE;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        private_display->capabilities |= TDM_DISPLAY_CAPABILITY_PP;
        private_display->func_pp = *func_pp;
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return TDM_ERROR_NONE;
 }
@@ -152,10 +152,10 @@ tdm_backend_register_func_capture(tdm_display *dpy,
        if (!func_capture)
                return TDM_ERROR_NONE;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        private_display->capabilities |= TDM_DISPLAY_CAPABILITY_CAPTURE;
        private_display->func_capture = *func_capture;
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return TDM_ERROR_NONE;
 }

diff --git a/src/tdm_capture.c b/src/tdm_capture.c
index a68739d..014d082 100644 (file)
--- a/src/tdm_capture.c
+++ b/src/tdm_capture.c
@@ -97,16 +97,16 @@ _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer,
 
        ret = pthread_mutex_trylock(&private_display->lock);
        if (ret == 0)
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
        else  if (ret == EBUSY) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                lock_after_cb_done = 1;
        }
 
        tdm_buffer_unref_backend(buffer);
 
        if (lock_after_cb_done)
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
 }
 
 INTERN tdm_private_capture *
@@ -240,9 +240,9 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture)
 
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->pending_buffer_list, link) {
                        LIST_DEL(&b->link);
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(b->buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
        }
 
@@ -252,9 +252,9 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture)
 
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->buffer_list, link) {
                        LIST_DEL(&b->link);
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(b->buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
        }
 
@@ -272,9 +272,9 @@ tdm_capture_destroy(tdm_capture *capture)
 
        private_display = private_capture->private_display;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        tdm_capture_destroy_internal(private_capture);
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 }
 
 EXTERN tdm_error
@@ -284,17 +284,17 @@ tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info)
 
        TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!func_capture->capture_set_info) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_capture->capture_set_info(private_capture->capture_backend, info);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -306,16 +306,16 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer)
 
        TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!func_capture->capture_attach) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = _tdm_capture_check_if_exist(private_capture, buffer);
        if (ret != TDM_ERROR_NONE) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return ret;
        }
 
@@ -334,7 +334,7 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer)
                }
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -346,10 +346,10 @@ tdm_capture_commit(tdm_capture *capture)
 
        CAPTURE_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!func_capture->capture_commit) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
@@ -367,7 +367,7 @@ tdm_capture_commit(tdm_capture *capture)
                        LIST_DEL(&b->link);
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }

diff --git a/src/tdm_display.c b/src/tdm_display.c
index cbcf675..9e3106f 100644 (file)
--- a/src/tdm_display.c
+++ b/src/tdm_display.c
@@ -109,11 +109,11 @@ tdm_display_get_capabilities(tdm_display *dpy,
 
        TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *capabilities = private_display->capabilities;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -126,17 +126,17 @@ tdm_display_get_pp_capabilities(tdm_display *dpy,
 
        TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
                TDM_ERR("no pp capability");
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NO_CAPABILITY;
        }
 
        *capabilities = private_display->caps_pp.capabilities;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -150,18 +150,18 @@ tdm_display_get_pp_available_formats(tdm_display *dpy,
        TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
                TDM_ERR("no pp capability");
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NO_CAPABILITY;
        }
 
        *formats = (const tbm_format *)private_display->caps_pp.formats;
        *count = private_display->caps_pp.format_count;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -172,11 +172,11 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 {
        DISPLAY_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
                TDM_ERR("no pp capability");
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NO_CAPABILITY;
        }
 
@@ -191,7 +191,7 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
        if (preferred_align)
                *preferred_align = private_display->caps_pp.preferred_align;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -204,17 +204,17 @@ tdm_display_get_capture_capabilities(tdm_display *dpy,
 
        TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
                TDM_ERR("no capture capability");
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NO_CAPABILITY;
        }
 
        *capabilities = private_display->caps_capture.capabilities;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -228,18 +228,18 @@ tdm_display_get_catpure_available_formats(tdm_display *dpy,
        TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
                TDM_ERR("no capture capability");
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NO_CAPABILITY;
        }
 
        *formats = (const tbm_format *)private_display->caps_capture.formats;
        *count = private_display->caps_capture.format_count;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -253,18 +253,18 @@ tdm_display_get_output_count(tdm_display *dpy, int *count)
 
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *count = 0;
        LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
        (*count)++;
 
        if (*count == 0) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -278,7 +278,7 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 
        DISPLAY_FUNC_ENTRY_ERROR();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (error)
                *error = TDM_ERROR_NONE;
@@ -286,13 +286,13 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
        i = 0;
        LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
                if (i == index) {
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        return private_output;
                }
                i++;
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return NULL;
 }
@@ -305,7 +305,7 @@ tdm_display_get_fd(tdm_display *dpy, int *fd)
 
        TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_display = &private_display->func_display;
 
@@ -316,7 +316,7 @@ tdm_display_get_fd(tdm_display *dpy, int *fd)
 
        ret = func_display->display_get_fd(private_display->bdata, fd);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -327,7 +327,7 @@ tdm_display_handle_events(tdm_display *dpy)
        tdm_func_display *func_display;
        DISPLAY_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_display = &private_display->func_display;
 
@@ -338,7 +338,7 @@ tdm_display_handle_events(tdm_display *dpy)
 
        ret = func_display->display_handle_events(private_display->bdata);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -350,11 +350,11 @@ tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 
        DISPLAY_FUNC_ENTRY_ERROR();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        pp = (tdm_pp *)tdm_pp_create_internal(private_display, error);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return pp;
 }
@@ -365,7 +365,7 @@ tdm_output_get_model_info(tdm_output *output, const char **maker,
 {
        OUTPUT_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (maker)
                *maker = private_output->caps.maker;
@@ -374,7 +374,7 @@ tdm_output_get_model_info(tdm_output *output, const char **maker,
        if (name)
                *name = private_output->caps.name;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -386,11 +386,11 @@ tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
 
        TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *status = private_output->caps.status;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -402,11 +402,11 @@ tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
 
        TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *type = private_output->caps.type;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -420,17 +420,17 @@ tdm_output_get_layer_count(tdm_output *output, int *count)
 
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *count = 0;
        LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
        (*count)++;
        if (*count == 0) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -444,20 +444,20 @@ tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
 
        OUTPUT_FUNC_ENTRY_ERROR();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (error)
                *error = TDM_ERROR_NONE;
 
        LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
                if (i == index) {
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        return private_layer;
                }
                i++;
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return NULL;
 }
@@ -471,12 +471,12 @@ tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props,
        TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *props = (const tdm_prop *)private_output->caps.props;
        *count = private_output->caps.prop_count;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -490,12 +490,12 @@ tdm_output_get_available_modes(tdm_output *output,
        TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *modes = (const tdm_output_mode *)private_output->caps.modes;
        *count = private_output->caps.mode_count;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -506,7 +506,7 @@ tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
 {
        OUTPUT_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (min_w)
                *min_w = private_output->caps.min_w;
@@ -519,7 +519,7 @@ tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
        if (preferred_align)
                *preferred_align = private_output->caps.preferred_align;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -530,14 +530,14 @@ tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth,
 {
        OUTPUT_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (mmWidth)
                *mmWidth = private_output->caps.mmWidth;
        if (mmHeight)
                *mmHeight = private_output->caps.mmHeight;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -548,11 +548,11 @@ tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
        OUTPUT_FUNC_ENTRY();
        TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *subpixel = private_output->caps.subpixel;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -563,11 +563,11 @@ tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
        OUTPUT_FUNC_ENTRY();
        TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *pipe = private_output->pipe;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -579,19 +579,19 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
        tdm_func_output *func_output;
        OUTPUT_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_set_property) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_set_property(private_output->output_backend, id,
                                               value);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -604,19 +604,19 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 
        TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_get_property) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_get_property(private_output->output_backend, id,
                                               value);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -633,10 +633,10 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
        private_display = vblank_handler->private_output->private_display;
 
        if (vblank_handler->func) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                vblank_handler->func(vblank_handler->private_output, sequence,
                                     tv_sec, tv_usec, vblank_handler->user_data);
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
        }
 
        LIST_DEL(&vblank_handler->link);
@@ -662,15 +662,15 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
                        continue;
 
                if (private_layer->showing_buffer) {
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(private_layer->showing_buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
 
                        if (private_layer->buffer_queue) {
-                               pthread_mutex_unlock(&private_display->lock);
+                               _pthread_mutex_unlock(&private_display->lock);
                                tbm_surface_queue_release(private_layer->buffer_queue,
                                                          private_layer->showing_buffer);
-                               pthread_mutex_lock(&private_display->lock);
+                               _pthread_mutex_lock(&private_display->lock);
                        }
                }
 
@@ -684,10 +684,10 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
        }
 
        if (commit_handler->func) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                commit_handler->func(private_output, sequence,
                                     tv_sec, tv_usec, commit_handler->user_data);
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
        }
 
        LIST_DEL(&commit_handler->link);
@@ -702,19 +702,19 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
        tdm_private_vblank_handler *vblank_handler;
        OUTPUT_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_wait_vblank) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
        if (!vblank_handler) {
                TDM_ERR("failed: alloc memory");
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_OUT_OF_MEMORY;
        }
 
@@ -726,7 +726,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
        ret = func_output->output_wait_vblank(private_output->output_backend, interval,
                                              sync, vblank_handler);
        if (ret != TDM_ERROR_NONE) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return ret;
        }
 
@@ -736,7 +736,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
                                _tdm_output_cb_vblank);
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -785,11 +785,11 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
 {
        OUTPUT_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        ret = _tdm_output_commit(output, sync, func, user_data);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -802,18 +802,18 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 
        TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_set_mode) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_set_mode(private_output->output_backend, mode);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -826,18 +826,18 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
 
        TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_get_mode) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_get_mode(private_output->output_backend, mode);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -853,18 +853,18 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
        else if (dpms_value > TDM_OUTPUT_DPMS_OFF)
                dpms_value = TDM_OUTPUT_DPMS_OFF;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_set_dpms) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -877,18 +877,18 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
 
        TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_output = &private_display->func_output;
 
        if (!func_output->output_get_dpms) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -900,12 +900,12 @@ tdm_output_create_capture(tdm_output *output, tdm_error *error)
 
        OUTPUT_FUNC_ENTRY_ERROR();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        capture = (tdm_capture *)tdm_capture_create_output_internal(private_output,
                        error);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return capture;
 }
@@ -917,11 +917,11 @@ tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
 
        TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *capabilities = private_layer->caps.capabilities;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -935,12 +935,12 @@ tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats,
        TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *formats = (const tbm_format *)private_layer->caps.formats;
        *count = private_layer->caps.format_count;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -954,12 +954,12 @@ tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props,
        TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *props = (const tdm_prop *)private_layer->caps.props;
        *count = private_layer->caps.prop_count;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -971,11 +971,11 @@ tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
 
        TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *zpos = private_layer->caps.zpos;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -986,18 +986,18 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        if (!func_layer->layer_set_property) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1010,18 +1010,18 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 
        TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        if (!func_layer->layer_get_property) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1034,14 +1034,14 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 
        TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_info) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
@@ -1057,7 +1057,7 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
        ret = func_layer->layer_set_info(private_layer->layer_backend, info);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1070,18 +1070,18 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 
        TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        if (!func_layer->layer_get_info) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_layer->layer_get_info(private_layer->layer_backend, info);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1095,14 +1095,14 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 
        TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
@@ -1114,9 +1114,9 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
                 * successfully, need to move to waiting_buffer.
                 */
                if (private_layer->waiting_buffer) {
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(private_layer->waiting_buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
 
                private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
@@ -1125,7 +1125,7 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
                                 private_layer, private_layer->waiting_buffer);
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1136,14 +1136,14 @@ tdm_layer_unset_buffer(tdm_layer *layer)
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        if (private_layer->waiting_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                tdm_buffer_unref_backend(private_layer->waiting_buffer);
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
                private_layer->waiting_buffer = NULL;
 
                if (tdm_debug_buffer)
@@ -1152,9 +1152,9 @@ tdm_layer_unset_buffer(tdm_layer *layer)
        }
 
        if (private_layer->showing_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                tdm_buffer_unref_backend(private_layer->showing_buffer);
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
                private_layer->showing_buffer = NULL;
 
                if (tdm_debug_buffer)
@@ -1165,14 +1165,14 @@ tdm_layer_unset_buffer(tdm_layer *layer)
        private_layer->usable = 1;
 
        if (!func_layer->layer_unset_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1186,11 +1186,11 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
        tbm_surface_h surface = NULL;
        LAYER_FUNC_ENTRY_VOID_RETURN();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
        if (!func_layer->layer_set_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return;
        }
 
@@ -1199,7 +1199,7 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
            surface == NULL) {
                TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
                        private_layer, surface);
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return;
        }
 
@@ -1208,11 +1208,11 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
 
        if (ret == TDM_ERROR_NONE) {
                if (private_layer->waiting_buffer) {
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(private_layer->waiting_buffer);
                        tbm_surface_queue_release(private_layer->buffer_queue,
                                                  private_layer->waiting_buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
 
                private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
@@ -1226,7 +1226,7 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
                        TDM_ERR("layer(%p) _tdm_output_commit() is fail", private_layer);
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 }
 
 static void
@@ -1237,19 +1237,19 @@ _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
        LAYER_FUNC_ENTRY_VOID_RETURN();
        TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (private_layer->waiting_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                tdm_buffer_unref_backend(private_layer->waiting_buffer);
                tbm_surface_queue_release(private_layer->buffer_queue,
                                          private_layer->waiting_buffer);
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
        }
 
        private_layer->buffer_queue = NULL;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 }
 
 EXTERN tdm_error
@@ -1260,29 +1260,29 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 
        TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        private_layer->usable = 0;
 
        if (!func_layer->layer_set_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        if (buffer_queue == private_layer->buffer_queue) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        if (private_layer->waiting_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                tdm_buffer_unref_backend(private_layer->waiting_buffer);
                tbm_surface_queue_release(private_layer->buffer_queue,
                                          private_layer->waiting_buffer);
                private_layer->waiting_buffer = NULL;
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
 
                if (tdm_debug_buffer)
                        TDM_INFO("layer(%p) waiting_buffer(%p)",
@@ -1296,7 +1296,7 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
        tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue,
                                         _tbm_layer_queue_destroy_cb,
                                         layer);
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1307,17 +1307,17 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer)
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        if (private_layer->waiting_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                tdm_buffer_unref_backend(private_layer->waiting_buffer);
                tbm_surface_queue_release(private_layer->buffer_queue,
                                          private_layer->waiting_buffer);
                private_layer->waiting_buffer = NULL;
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
 
                if (tdm_debug_buffer)
                        TDM_INFO("layer(%p) waiting_buffer(%p)",
@@ -1325,11 +1325,11 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer)
        }
 
        if (private_layer->showing_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                tdm_buffer_unref_backend(private_layer->showing_buffer);
                tbm_surface_queue_release(private_layer->buffer_queue,
                                          private_layer->showing_buffer);
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
                private_layer->showing_buffer = NULL;
 
                if (tdm_debug_buffer)
@@ -1343,13 +1343,13 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer)
        private_layer->usable = 1;
 
        if (!func_layer->layer_unset_buffer) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1361,11 +1361,11 @@ tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
 
        TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        *usable = private_layer->usable;
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1376,24 +1376,24 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
        tdm_func_layer *func_layer;
        LAYER_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        func_layer = &private_display->func_layer;
 
        if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
                TDM_ERR("layer(%p) is not video layer", private_layer);
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_INVALID_PARAMETER;
        }
 
        if (!func_layer->layer_set_video_pos) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -1405,12 +1405,12 @@ tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
 
        LAYER_FUNC_ENTRY_ERROR();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer,
                        error);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return capture;
 }

diff --git a/src/tdm_pp.c b/src/tdm_pp.c
index cd88f49..6e59c51 100644 (file)
--- a/src/tdm_pp.c
+++ b/src/tdm_pp.c
@@ -118,9 +118,9 @@ _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
 
        ret = pthread_mutex_trylock(&private_display->lock);
        if (ret == 0)
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
        else  if (ret == EBUSY) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                lock_after_cb_done = 1;
        }
 
@@ -128,7 +128,7 @@ _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
        tdm_buffer_unref_backend(dst);
 
        if (lock_after_cb_done)
-               pthread_mutex_lock(&private_display->lock);
+               _pthread_mutex_lock(&private_display->lock);
 }
 
 INTERN tdm_private_pp *
@@ -213,9 +213,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
 
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_pending_buffer_list, link) {
                        LIST_DEL(&b->link);
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(b->buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
        }
 
@@ -225,9 +225,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
 
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_pending_buffer_list, link) {
                        LIST_DEL(&b->link);
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(b->buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
        }
 
@@ -237,9 +237,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
 
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_buffer_list, link) {
                        LIST_DEL(&b->link);
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(b->buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
        }
 
@@ -249,9 +249,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
 
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_buffer_list, link) {
                        LIST_DEL(&b->link);
-                       pthread_mutex_unlock(&private_display->lock);
+                       _pthread_mutex_unlock(&private_display->lock);
                        tdm_buffer_unref_backend(b->buffer);
-                       pthread_mutex_lock(&private_display->lock);
+                       _pthread_mutex_lock(&private_display->lock);
                }
        }
 
@@ -269,9 +269,9 @@ tdm_pp_destroy(tdm_pp *pp)
 
        private_display = private_pp->private_display;
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
        tdm_pp_destroy_internal(private_pp);
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 }
 
 EXTERN tdm_error
@@ -281,10 +281,10 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
 
        TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!func_pp->pp_set_info) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
@@ -302,7 +302,7 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
        ret = func_pp->pp_set_info(private_pp->pp_backend, info);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -315,16 +315,16 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
        TDM_RETURN_VAL_IF_FAIL(src != NULL, TDM_ERROR_INVALID_PARAMETER);
        TDM_RETURN_VAL_IF_FAIL(dst != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!func_pp->pp_attach) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
        ret = _tdm_pp_check_if_exist(private_pp, src, dst);
        if (ret != TDM_ERROR_NONE) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return ret;
        }
 
@@ -347,7 +347,7 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
                }
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }
@@ -359,10 +359,10 @@ tdm_pp_commit(tdm_pp *pp)
 
        PP_FUNC_ENTRY();
 
-       pthread_mutex_lock(&private_display->lock);
+       _pthread_mutex_lock(&private_display->lock);
 
        if (!func_pp->pp_commit) {
-               pthread_mutex_unlock(&private_display->lock);
+               _pthread_mutex_unlock(&private_display->lock);
                return TDM_ERROR_NONE;
        }
 
@@ -388,7 +388,7 @@ tdm_pp_commit(tdm_pp *pp)
                        LIST_DEL(&b->link);
        }
 
-       pthread_mutex_unlock(&private_display->lock);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
 }

diff --git a/src/tdm_private.h b/src/tdm_private.h
index c1a34d0..15a2448 100644 (file)
--- a/src/tdm_private.h
+++ b/src/tdm_private.h
@@ -65,6 +65,9 @@ extern "C" {
  * @brief The private header file for a frontend library
  */
 
+extern int tdm_debug_buffer;
+extern int tdm_debug_mutex;
+
 #undef EXTERN
 #undef DEPRECATED
 #undef INTERN
@@ -308,6 +311,11 @@ tdm_buffer_list_get_first_entry(struct list_head *list);
 void
 tdm_buffer_list_dump(struct list_head *list);
 
+#define _pthread_mutex_lock(l) \
+    do {if (tdm_debug_mutex) TDM_INFO("mutex lock"); pthread_mutex_lock(l);} while (0)
+#define _pthread_mutex_unlock(l) \
+    do {if (tdm_debug_mutex) TDM_INFO("mutex unlock"); pthread_mutex_unlock(l);} while (0)
+
 #ifdef __cplusplus
 }
 #endif