From 32c967661f56774d1071123d850ea6784decbf28 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 13 Mar 2018 16:38:41 +0900 Subject: [PATCH 01/16] utests: apply coding style Change-Id: I6e063ca7ea46a9c2c7a0113fa95d9ed1d829366a --- utests/src/ut_tdm_backend_capture.cpp | 12 ++++++------ utests/src/ut_tdm_backend_display.cpp | 4 ++-- utests/src/ut_tdm_backend_pp.cpp | 24 ++++++++++++------------ utests/src/ut_tdm_buffer.cpp | 3 ++- utests/src/ut_tdm_client.cpp | 2 +- utests/src/ut_tdm_event_loop.cpp | 3 ++- utests/src/ut_tdm_helper.cpp | 9 +++++---- utests/src/ut_tdm_hwc_window.cpp | 11 ++++++----- utests/src/ut_tdm_layer.cpp | 7 ++++--- utests/src/ut_tdm_main.cpp | 2 +- utests/src/ut_tdm_output.cpp | 4 ++-- utests/src/ut_tdm_output_hwc.cpp | 3 ++- utests/src/ut_tdm_vblank.cpp | 5 ----- 13 files changed, 45 insertions(+), 44 deletions(-) diff --git a/utests/src/ut_tdm_backend_capture.cpp b/utests/src/ut_tdm_backend_capture.cpp index 6482b4b..6604be1 100644 --- a/utests/src/ut_tdm_backend_capture.cpp +++ b/utests/src/ut_tdm_backend_capture.cpp @@ -456,7 +456,7 @@ TEST_P(TDMBackendCapture, CaptureAttach) continue; ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); @@ -541,7 +541,7 @@ TEST_P(TDMBackendCapture, CaptureNoScaleNoTransformNoCSC) continue; ASSERT_EQ(TestPrepare(o, mode->hdisplay, mode->vdisplay, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE); @@ -583,7 +583,7 @@ TEST_P(TDMBackendCapture, CaptureScaleTransformCSC) continue; ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE); @@ -632,7 +632,7 @@ TEST_P(TDMBackendCapture, CaptureAttachFewTimesInOneCommit) continue; ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, &done), TDM_ERROR_NONE); @@ -669,7 +669,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit) continue; ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); @@ -700,7 +700,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone) continue; ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, test_formats[f], - TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); + TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1), true); ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); diff --git a/utests/src/ut_tdm_backend_display.cpp b/utests/src/ut_tdm_backend_display.cpp index 1d94fb9..b69ef32 100644 --- a/utests/src/ut_tdm_backend_display.cpp +++ b/utests/src/ut_tdm_backend_display.cpp @@ -58,7 +58,7 @@ void TDMBackendBasic::SetUp(void) ASSERT_GE(output_count, 0); if (output_count > 0) { - outputs = (tdm_output**)calloc(output_count, sizeof (tdm_output*)); + outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*)); ASSERT_NE(outputs, NULL); for (int o = 0; o < output_count; o++) { @@ -394,7 +394,7 @@ retry: bool done = false; TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE, - "Check output_commit(), output_set_commit_handler()"); + "Check output_commit(), output_set_commit_handler()"); while (!done) TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, "Check display_get_fd(), display_handle_events()"); diff --git a/utests/src/ut_tdm_backend_pp.cpp b/utests/src/ut_tdm_backend_pp.cpp index d1c798c..b326f4a 100644 --- a/utests/src/ut_tdm_backend_pp.cpp +++ b/utests/src/ut_tdm_backend_pp.cpp @@ -334,8 +334,8 @@ TEST_P(TDMBackendPP, PPAttach) for (int f = 0; f < format_count; f++) { ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL), true); + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL), true); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); @@ -392,8 +392,8 @@ TEST_P(TDMBackendPP, PPNoScaleNoTransformNoCSC) ASSERT_EQ(PreparePP(), true); ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], - TDM_TRANSFORM_NORMAL), true); + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, formats[0], + TDM_TRANSFORM_NORMAL), true); ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); @@ -431,8 +431,8 @@ TEST_P(TDMBackendPP, PPScaleTransformCSC) TDM_INFO("format(%c%c%c%c) ------> format(%c%c%c%c)", FOURCC_STR(format1), FOURCC_STR(format2)); ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, format1, - TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, format2, - TDM_TRANSFORM_NORMAL), true); + TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, format2, + TDM_TRANSFORM_NORMAL), true); ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); @@ -472,8 +472,8 @@ TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) snprintf(temp, sizeof temp, "%c%c%c%c", FOURCC_STR(formats[f])); ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL), true); + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL), true); ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) @@ -499,8 +499,8 @@ TEST_P(TDMBackendPP, PPDestroyWithoutCommit) int f = 0; ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL), true); + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL), true); ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) @@ -521,8 +521,8 @@ TEST_P(TDMBackendPP, PPDestroyBeforeDone) int f = 0; ASSERT_EQ(PrepareBuffers(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], - TDM_TRANSFORM_NORMAL), true); + TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], + TDM_TRANSFORM_NORMAL), true); ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) diff --git a/utests/src/ut_tdm_buffer.cpp b/utests/src/ut_tdm_buffer.cpp index c2df7ee..3443176 100644 --- a/utests/src/ut_tdm_buffer.cpp +++ b/utests/src/ut_tdm_buffer.cpp @@ -30,7 +30,8 @@ #include "ut_tdm.h" -class TDMBuffer : public TDMDisplay { +class TDMBuffer : public TDMDisplay +{ public: tbm_surface_h buffer; TDMBuffer(); diff --git a/utests/src/ut_tdm_client.cpp b/utests/src/ut_tdm_client.cpp index 3df66c8..055dbc3 100644 --- a/utests/src/ut_tdm_client.cpp +++ b/utests/src/ut_tdm_client.cpp @@ -952,7 +952,7 @@ TEST_P(TDMClient, ClientVblankWaitFewTime) ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); - while(!done1 || !done2 || !done3) + while (!done1 || !done2 || !done3) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); diff --git a/utests/src/ut_tdm_event_loop.cpp b/utests/src/ut_tdm_event_loop.cpp index ddc3380..3fffecb 100644 --- a/utests/src/ut_tdm_event_loop.cpp +++ b/utests/src/ut_tdm_event_loop.cpp @@ -30,7 +30,8 @@ #include "ut_tdm.h" -class TDMEventLoop : public TDMDisplay { +class TDMEventLoop : public TDMDisplay +{ public: TDMEventLoop(); void SetUp(void); diff --git a/utests/src/ut_tdm_helper.cpp b/utests/src/ut_tdm_helper.cpp index e0fb1ba..815e388 100644 --- a/utests/src/ut_tdm_helper.cpp +++ b/utests/src/ut_tdm_helper.cpp @@ -30,7 +30,8 @@ #include "ut_tdm.h" -class TDMHelper : public TDMOutput { +class TDMHelper : public TDMOutput +{ public: TDMHelper(); void SetUp(void); @@ -462,7 +463,7 @@ TEST_P(TDMHelper, HelperCaptureOutput) ASSERT_NE(dump, NULL); ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE); + _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE); char filename[256]; snprintf(filename, sizeof filename, "%s.png", typeid(*this).name()); @@ -478,7 +479,7 @@ TEST_P(TDMHelper, HelperCaptureOutputNullObject) tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMHelper, HelperCaptureOutputNullOther) @@ -494,7 +495,7 @@ TEST_P(TDMHelper, HelperCaptureOutputNullOther) tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMHelper, HelperGetDisplayInformation) diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index 2a1fdf5..222bca9 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -32,7 +32,8 @@ #define HWC_WIN_NUM 5 -class TDMHwcWindow : public TDMOutput { +class TDMHwcWindow : public TDMOutput +{ public: TDMHwcWindow(); void SetUp(void); @@ -91,9 +92,9 @@ TEST_P(TDMHwcWindow, DestroyWindowFailNull) for (int o = 0; o < output_count; o++) { if (ut_tdm_output_is_hwc_enable(outputs[o])) { - /* test: hw is NULL*/ - error = tdm_output_hwc_destroy_window(outputs[o], NULL); - ASSERT_NE(TDM_ERROR_NONE, error); + /* test: hw is NULL*/ + error = tdm_output_hwc_destroy_window(outputs[o], NULL); + ASSERT_NE(TDM_ERROR_NONE, error); } } } @@ -187,7 +188,7 @@ TEST_P(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType) TDM_UT_SKIP_FLAG(has_outputs); for (int w = 0; w < hwc_count; w++) { - error = tdm_hwc_window_set_composition_type(hwc_wins[w], tdm_hwc_window_composition(TDM_COMPOSITION_NONE-1)); + error = tdm_hwc_window_set_composition_type(hwc_wins[w], tdm_hwc_window_composition(TDM_COMPOSITION_NONE - 1)); ASSERT_NE(TDM_ERROR_NONE, error); } } diff --git a/utests/src/ut_tdm_layer.cpp b/utests/src/ut_tdm_layer.cpp index 3b830a0..7c3b143 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/utests/src/ut_tdm_layer.cpp @@ -30,7 +30,8 @@ #include "ut_tdm.h" -class TDMLayer : public TDMOutput { +class TDMLayer : public TDMOutput +{ public: bool has_layers; tdm_layer **layers; @@ -52,7 +53,7 @@ TDMLayer::TDMLayer() layers = NULL; layer_count = TDM_UT_INVALID_VALUE; - for(int b = 0; b < 3; b++) + for (int b = 0; b < 3; b++) buffers[b] = NULL; buffer_queue = NULL; @@ -105,7 +106,7 @@ void TDMLayer::TearDown(void) void TDMLayer::DestroyBuffers(void) { - for(int b = 0; b < 3; b++) { + for (int b = 0; b < 3; b++) { if (buffers[b]) { tbm_surface_destroy(buffers[b]); buffers[b] = NULL; diff --git a/utests/src/ut_tdm_main.cpp b/utests/src/ut_tdm_main.cpp index b4d9f19..8ed5556 100644 --- a/utests/src/ut_tdm_main.cpp +++ b/utests/src/ut_tdm_main.cpp @@ -52,7 +52,7 @@ int main(int argc, char **argv) AllTestSuccess = RUN_ALL_TESTS() == 0 ? true : false; } catch (const ::testing::internal::GoogleTestFailureException & e) { AllTestSuccess = false; - std::cout << "GoogleTestFailureException was thrown:"<< e.what() << std::endl; + std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl; std::cout << "\n"; } diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index ab7dfa7..b038f81 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -50,7 +50,7 @@ void TDMOutput::SetUp(void) ASSERT_GE(output_count, 0); if (output_count > 0) { - outputs = (tdm_output**)calloc(output_count, sizeof (tdm_output*)); + outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*)); ASSERT_NE(outputs, NULL); for (int o = 0; o < output_count; o++) { @@ -1359,7 +1359,7 @@ TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff) ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done), TDM_ERROR_NONE); if (t == 9) ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - while(!done) + while (!done) ASSERT_EQ(tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } diff --git a/utests/src/ut_tdm_output_hwc.cpp b/utests/src/ut_tdm_output_hwc.cpp index 9b3e274..73bac1c 100644 --- a/utests/src/ut_tdm_output_hwc.cpp +++ b/utests/src/ut_tdm_output_hwc.cpp @@ -30,7 +30,8 @@ #include "ut_tdm.h" -class TDMOutputHwc : public TDMOutput { +class TDMOutputHwc : public TDMOutput +{ public: TDMOutputHwc(); void SetUp(void); diff --git a/utests/src/ut_tdm_vblank.cpp b/utests/src/ut_tdm_vblank.cpp index e72372e..c72da58 100644 --- a/utests/src/ut_tdm_vblank.cpp +++ b/utests/src/ut_tdm_vblank.cpp @@ -1080,11 +1080,6 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); -#if 0 -printf("@@@ %s(%d) cur_seq(%d) t(%d) start(%.6f) end(%.6f) diff(%.6f) (%.6f~%.6f)\n", - __FUNCTION__, __LINE__, cur_seq, t, start, end, end - start, (interval * (t - 1)), (interval * t + interval)); -#endif - /* "+ interval" consider the delay of socket communication between kernel and platform */ ASSERT_GT((end - start), (interval * (t - 1))); ASSERT_LT((end - start), (interval * t + interval)); -- 2.7.4 From 55cd0c491942a4157dc24a12c0d45453d38f1cf8 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 14:03:26 +0900 Subject: [PATCH 02/16] thread: use PTHREAD_MUTEX_INITIALIZER Change-Id: I4626eebb96b3e8524ea48737104c0df9d1b1871b --- src/tdm_thread.c | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/src/tdm_thread.c b/src/tdm_thread.c index b183c59..9679c94 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -75,7 +75,7 @@ static tdm_thread_find_object find_funcs[TDM_THREAD_CB_MAX] = {0, }; /* 0: for display thread, 1: for tdm thread */ static struct list_head cb_list[2]; -static pthread_mutex_t cb_list_lock; +static pthread_mutex_t cb_list_lock = PTHREAD_MUTEX_INITIALIZER; static void _tdm_thread_free_cb(tdm_private_thread_cb *cb); @@ -201,11 +201,6 @@ tdm_thread_init(tdm_private_loop *private_loop) for (i = 0; i < TDM_THREAD_CB_MAX; i++) find_funcs[i] = NULL; - if (pthread_mutex_init(&cb_list_lock, NULL)) { - TDM_ERR("mutex init failed: %m"); - return TDM_ERROR_OUT_OF_MEMORY; - } - LIST_INITHEAD(&cb_list[0]); LIST_INITHEAD(&cb_list[1]); @@ -299,8 +294,6 @@ tdm_thread_deinit(tdm_private_loop *private_loop) tdm_log_reset(); - pthread_mutex_destroy(&cb_list_lock); - LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list[0], link) { _tdm_thread_free_cb(cb); } -- 2.7.4 From 8ad1b4be07c629b521ef749fba2da732369449ae Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 14:05:25 +0900 Subject: [PATCH 03/16] vblank: calculating SW target time properly Change-Id: I3f72412fd9b0d23ddbd5db42bed9e6f07dda322c --- src/tdm_vblank.c | 69 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 34 insertions(+), 35 deletions(-) diff --git a/src/tdm_vblank.c b/src/tdm_vblank.c index 3b55944..263f825 100644 --- a/src/tdm_vblank.c +++ b/src/tdm_vblank.c @@ -377,19 +377,17 @@ _tdm_vblank_update_output_info(tdm_private_vblank *private_vblank) tdm_output *output = private_vblank->output; tdm_output_conn_status connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; unsigned int vrefresh = TDM_VBLANK_DEFAULT_VREFRESH; + const tdm_output_mode *mode = NULL; tdm_error ret; ret = tdm_output_get_conn_status(output, &connection); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - if (connection == TDM_OUTPUT_CONN_STATUS_MODE_SETTED) { - const tdm_output_mode *mode = NULL; - ret = tdm_output_get_mode(output, &mode); - if (ret == TDM_ERROR_NONE && mode) - vrefresh = mode->vrefresh; - else - VWR("mode not setted!!!"); - } + ret = tdm_output_get_mode(output, &mode); + if (ret == TDM_ERROR_NONE && mode) + vrefresh = mode->vrefresh; + else + VWR("mode not setted!!!"); private_vblank->connection = connection; private_vblank->vrefresh = vrefresh; @@ -1423,52 +1421,53 @@ _tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info) { tdm_private_vblank *private_vblank = wait_info->private_vblank; tdm_error ret; + double last, prev, req, curr, target; + unsigned int skip; if (private_vblank->last_type != VBLANK_EVENT_TYPE_SW) { - VIN("Use SW vblank"); + tdm_output_dpms dpms; + + tdm_output_get_dpms(private_vblank->output, &dpms); + + VIN("Use SW vblank. connection(%s), dpms(%s), vrefresh(%d), fps(%d), offset(%d)", + tdm_status_str(private_vblank->connection), tdm_dpms_str(dpms), + private_vblank->vrefresh, private_vblank->fps, private_vblank->offset); private_vblank->last_type = VBLANK_EVENT_TYPE_SW; } if (private_vblank->last_time == 0) { /* SW vblank starts from now. SW vblank doesn't need to be aligned with HW vblank. */ private_vblank->last_seq = 0; - private_vblank->last_time = tdm_helper_get_time(); + private_vblank->last_time = tdm_helper_get_time() - private_vblank->vblank_gap; /* +1 ms to call the handler ASAP at the first. no matter for SW timer. */ wait_info->target_seq = 1; - wait_info->target_time = private_vblank->last_time + 0.001; - - VDB("wait(%p) last(%.6f) target(%.6f) target sequence(%u)", - wait_info, private_vblank->last_time, wait_info->target_time, wait_info->target_seq); - } else { - double last, prev, req, curr, target; - unsigned int skip; + } - last = private_vblank->last_time; - req = wait_info->req_time; + last = private_vblank->last_time; + req = wait_info->req_time; - /* make sure that req time is bigger than last. */ - if (req < last) - req = last; + /* make sure that req time is bigger than last. */ + if (req < last) + req = last; - skip = (unsigned int)((req - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN); - prev = last + private_vblank->vblank_gap * skip; + skip = (unsigned int)((req - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN); + prev = last + private_vblank->vblank_gap * skip; - curr = tdm_helper_get_time(); - target = prev + private_vblank->vblank_gap * wait_info->interval; + curr = tdm_helper_get_time(); + target = prev + private_vblank->vblank_gap * wait_info->interval; - while (target < curr) - target += private_vblank->vblank_gap; + while (target < curr) + target += private_vblank->vblank_gap; - wait_info->target_seq = private_vblank->last_seq; - wait_info->target_seq += (unsigned int)((target - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN); + wait_info->target_seq = private_vblank->last_seq; + wait_info->target_seq += (unsigned int)((target - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN); - wait_info->target_time = target; + wait_info->target_time = target + (double)(private_vblank->offset) / 1000; - VDB("wait(%p) last(%.6f) req(%.6f) prev(%.6f) curr(%.6f) targ(%.6f,%.6f) skip(%u) targ_seq(%u)", - wait_info, last, req - last, prev - last, curr - last, - target, target - last, skip, wait_info->target_seq); - } + VDB("wait(%p) last(%.6f) req(%.6f) prev(%.6f) curr(%.6f) targ(%.6f,%.6f) skip(%u) targ_seq(%u)", + wait_info, last, req - last, prev - last, curr - last, + target, target - last, skip, wait_info->target_seq); _tdm_vblank_insert_wait(wait_info, &private_vblank->SW_wait_list); -- 2.7.4 From eb90a6a6e90e9f8b56e7dd9ffa96bd534f8a0d2e Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 16:47:32 +0900 Subject: [PATCH 04/16] layer: add more debugging log Change-Id: Ib2b40f60ce6f0180137684c13f443be55a861722 --- src/tdm_layer.c | 100 +++++++++++++++++++++++++++++--------------------------- 1 file changed, 52 insertions(+), 48 deletions(-) diff --git a/src/tdm_layer.c b/src/tdm_layer.c index df7693a..45029f5 100644 --- a/src/tdm_layer.c +++ b/src/tdm_layer.c @@ -179,7 +179,7 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value) func_layer = &private_module->func_layer; if (private_layer->usable) - TDM_INFO("layer(%d) not usable", private_layer->index); + TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->caps.zpos); private_layer->usable = 0; @@ -238,7 +238,7 @@ tdm_layer_set_info_internal(tdm_private_layer *private_layer, tdm_info_layer *in func_layer = &private_module->func_layer; if (private_layer->usable) - TDM_INFO("layer(%p) not usable", private_layer); + TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->caps.zpos); private_layer->usable = 0; @@ -254,8 +254,9 @@ tdm_layer_set_info_internal(tdm_private_layer *private_layer, tdm_info_layer *in else snprintf(fmtstr, 128, "NONE"); - TDM_INFO("layer(%p) info: src(%ux%u %u,%u %ux%u %s) dst(%u,%u %ux%u) trans(%d)", - private_layer, info->src_config.size.h, info->src_config.size.v, + TDM_INFO("layer(%p,%d) info: src(%ux%u %u,%u %ux%u %s) dst(%u,%u %ux%u) trans(%d)", + private_layer, private_layer->caps.zpos, + info->src_config.size.h, info->src_config.size.v, info->src_config.pos.x, info->src_config.pos.y, info->src_config.pos.w, info->src_config.pos.h, fmtstr, @@ -383,8 +384,8 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) private_layer->waiting_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) waiting_buffer(%p)", - private_layer, private_layer->waiting_buffer); + TDM_INFO("layer(%p,%d) waiting_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->waiting_buffer); } if (private_layer->committed_buffer) { @@ -392,8 +393,8 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) private_layer->committed_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) committed_buffer(%p)", - private_layer, private_layer->committed_buffer); + TDM_INFO("layer(%p,%d) committed_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->committed_buffer); } if (private_layer->showing_buffer) { @@ -401,8 +402,8 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) private_layer->showing_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) showing_buffer(%p)", - private_layer, private_layer->showing_buffer); + TDM_INFO("layer(%p,%d) showing_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->showing_buffer); } LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) { @@ -465,7 +466,7 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu func_layer = &private_module->func_layer; if (private_layer->usable) - TDM_INFO("layer(%p) not usable", private_layer); + TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->caps.zpos); private_layer->usable = 0; @@ -481,8 +482,8 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu if (private_layer->pending_buffer) { if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) pending_buffer(%p) skipped", - private_layer, private_layer->pending_buffer); + TDM_INFO("layer(%p,%d) pending_buffer(%p) skipped", + private_layer, private_layer->caps.zpos, private_layer->pending_buffer); if (tdm_ttrace_module & TDM_TTRACE_LAYER) { tbm_bo bo = tbm_surface_internal_get_bo(private_layer->pending_buffer, 0); @@ -496,8 +497,8 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu private_layer->pending_buffer = buffer; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) pending_buffer(%p)", - private_layer, private_layer->pending_buffer); + TDM_INFO("layer(%p,%d) pending_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->pending_buffer); if (tdm_ttrace_module & TDM_TTRACE_LAYER) { tbm_bo bo = tbm_surface_internal_get_bo(private_layer->pending_buffer, 0); @@ -538,7 +539,7 @@ tdm_layer_unset_buffer_internal(tdm_private_layer *private_layer) private_layer->usable = 1; if (private_layer->usable) - TDM_INFO("layer(%p) now usable", private_layer); + TDM_INFO("layer(%p,%d) now usable", private_layer, private_layer->caps.zpos); if (!func_layer->layer_unset_buffer) { /* LCOV_EXCL_START */ @@ -580,7 +581,8 @@ tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer * if (private_layer->fps_stamp == 0) { private_layer->fps_stamp = curr; } else if ((curr - private_layer->fps_stamp) > 1.0) { - TDM_INFO("output(%d) layer(%d) fps: %d", private_output->index, private_layer->index, private_layer->fps_count); + TDM_INFO("output(%d) layer(%p,%d) fps: %d", + private_output->index, private_layer, private_layer->caps.zpos, private_layer->fps_count); private_layer->fps_count = 0; private_layer->fps_stamp = curr; } else @@ -604,8 +606,8 @@ tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer * *committed_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) committed_buffer(%p) showing_buffer(%p)", - private_layer, *committed_buffer, + TDM_INFO("layer(%p,%d) committed_buffer(%p) showing_buffer(%p)", + private_layer, private_layer->caps.zpos, *committed_buffer, (private_layer->showing_buffer) ? private_layer->showing_buffer->buffer : NULL); } @@ -639,8 +641,8 @@ _tdm_layer_got_output_vblank(tdm_private_output *private_output, unsigned int se LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) { if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) committed. handle(%p) commited_buffer(%p)", - lm->private_layer, lm, (lm->committed_buffer) ? lm->committed_buffer->buffer : NULL); + TDM_INFO("layer(%p,%d) committed. handle(%p) commited_buffer(%p)", + lm->private_layer, lm->private_layer->caps.zpos, lm, (lm->committed_buffer) ? lm->committed_buffer->buffer : NULL); LIST_DEL(&lm->link); tdm_layer_committed(lm->private_layer, &lm->committed_buffer); @@ -742,8 +744,8 @@ _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence, private_layer->committing = 0; if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: output(%d) committed. handle(%p)", - private_layer, private_output->pipe, layer_commit_handler); + TDM_INFO("layer(%p,%d) commit: output(%d) committed. handle(%p)", + private_layer, private_layer->caps.zpos, private_output->pipe, layer_commit_handler); _pthread_mutex_lock(&private_display->lock); @@ -814,18 +816,20 @@ _tdm_layer_commit_possible(tdm_private_layer *private_layer) */ if (!LIST_IS_EMPTY(&private_output->layer_commit_handler_list)) { if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: not possible(previous commit)", private_layer); + TDM_INFO("layer(%p,%d) commit: not possible(previous commit)", + private_layer, private_layer->caps.zpos); return 0; } if (private_output->commit_per_vblank == 1 && _tdm_lauer_get_output_used_layer_count(private_output) > 1) { if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: not possible(more than 2 layers)", private_layer); + TDM_INFO("layer(%p,%d) commit: not possible(more than 2 layers)", + private_layer, private_layer->caps.zpos); return 0; } if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: possible", private_layer); + TDM_INFO("layer(%p,%d) commit: possible", private_layer, private_layer->caps.zpos); return 1; } @@ -870,8 +874,8 @@ tdm_layer_commit_pending_data(tdm_private_layer *private_layer) TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) pending_buffer(%p) committed", - private_layer, private_layer->pending_buffer); + TDM_INFO("layer(%p,%d) pending_buffer(%p) committed", + private_layer, private_layer->caps.zpos, private_layer->pending_buffer); if (ret == TDM_ERROR_NONE) { if (private_layer->waiting_buffer) @@ -880,8 +884,8 @@ tdm_layer_commit_pending_data(tdm_private_layer *private_layer) private_layer->waiting_buffer = layer_buffer; private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(private_layer->pending_buffer); if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) waiting_buffer(%p)", - private_layer, private_layer->waiting_buffer->buffer); + TDM_INFO("layer(%p,%d) waiting_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->waiting_buffer->buffer); } else tdm_layer_free_buffer(private_layer, layer_buffer); } @@ -911,7 +915,7 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da } if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: handle(%p)", private_layer, layer_commit_handler); + TDM_INFO("layer(%p,%d) commit: handle(%p)", private_layer, private_layer->caps.zpos, layer_commit_handler); LIST_INITHEAD(&layer_commit_handler->link); layer_commit_handler->private_layer = private_layer; @@ -922,13 +926,13 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da private_layer->waiting_buffer = NULL; if (private_layer->committing) - TDM_WRN("layer(%d) too many commit", private_layer->index); + TDM_WRN("layer(%p,%d) too many commit", private_layer, private_layer->caps.zpos); else private_layer->committing = 1; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) waiting_buffer(%p) committed_buffer(%p)", - private_layer, private_layer->waiting_buffer, + TDM_INFO("layer(%p,%d) waiting_buffer(%p) committed_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->waiting_buffer, (layer_commit_handler->committed_buffer) ? layer_commit_handler->committed_buffer->buffer : NULL); if (!private_output->commit_per_vblank) { @@ -939,7 +943,7 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: no commit-per-vblank", private_layer); + TDM_INFO("layer(%p,%d) commit: no commit-per-vblank", private_layer, private_layer->caps.zpos); } else { TDM_GOTO_IF_FAIL(private_output->commit_type == TDM_COMMIT_TYPE_LAYER, commit_failed); @@ -950,13 +954,13 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: output", private_layer); + TDM_INFO("layer(%p,%d) commit: output", private_layer, private_layer->caps.zpos); } else { /* add to pending_commit_handler_list. It will be commited when a vblank occurs */ LIST_ADDTAIL(&layer_commit_handler->link, &private_output->pending_commit_handler_list); if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: pending", private_layer); + TDM_INFO("layer(%p,%d) commit: pending", private_layer, private_layer->caps.zpos); } if (!private_output->vblank) { @@ -976,7 +980,7 @@ _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_da private_output->layer_waiting_vblank = 1; if (tdm_debug_module & TDM_DEBUG_COMMIT) - TDM_INFO("layer(%p) commit: wait vblank", private_layer); + TDM_INFO("layer(%p,%d) commit: wait vblank", private_layer, private_layer->caps.zpos); } } @@ -1005,7 +1009,7 @@ tdm_layer_commit_internal(tdm_private_layer *private_layer, tdm_layer_commit_han } if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) { - TDM_ERR("layer(%p)'s output(%d) dpms: %s", private_layer, private_output->pipe, + TDM_ERR("layer(%p,%d)'s output(%d) dpms: %s", private_layer, private_layer->caps.zpos, private_output->pipe, tdm_dpms_str(private_output->current_dpms_value)); return TDM_ERROR_DPMS_OFF; } @@ -1013,7 +1017,7 @@ tdm_layer_commit_internal(tdm_private_layer *private_layer, tdm_layer_commit_han /* don't call this inside of _tdm_layer_commit */ ret = tdm_layer_commit_pending_data(private_layer); if (ret != TDM_ERROR_NONE) { - TDM_ERR("layer(%p) committing pending data failed", private_layer); + TDM_ERR("layer(%p,%d) committing pending data failed", private_layer, private_layer->caps.zpos); return ret; } @@ -1115,7 +1119,7 @@ tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error) buffer = private_layer->showing_buffer->buffer; } else { _pthread_mutex_unlock(&private_display->lock); - TDM_DBG("layer(%p) showing_buffer is null", private_layer); + TDM_DBG("layer(%p,%d) showing_buffer is null", private_layer, private_layer->caps.zpos); return NULL; } _pthread_mutex_unlock(&private_display->lock); @@ -1148,8 +1152,8 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data) if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &buffer) || buffer == NULL) { /* LCOV_EXCL_START */ - TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p", - private_layer, buffer); + TDM_ERR("layer(%p,%d) tbm_surface_queue_acquire() failed surface:%p", + private_layer, private_layer->caps.zpos, buffer); _pthread_mutex_unlock(&private_display->lock); return; /* LCOV_EXCL_STOP */ @@ -1204,7 +1208,7 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) func_layer = &private_module->func_layer; if (private_layer->usable) - TDM_INFO("layer(%p) not usable", private_layer); + TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->caps.zpos); private_layer->usable = 0; @@ -1226,8 +1230,8 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) private_layer->waiting_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) - TDM_INFO("layer(%p) waiting_buffer(%p)", - private_layer, private_layer->waiting_buffer); + TDM_INFO("layer(%p,%d) waiting_buffer(%p)", + private_layer, private_layer->caps.zpos, private_layer->waiting_buffer); } private_layer->buffer_queue = buffer_queue; @@ -1277,7 +1281,7 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos) func_layer = &private_module->func_layer; if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) { - TDM_ERR("layer(%p) is not video layer", private_layer); + TDM_ERR("layer(%p,%d) is not video layer", private_layer, private_layer->caps.zpos); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_BAD_REQUEST; } @@ -1285,7 +1289,7 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos) if (!func_layer->layer_set_video_pos) { /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("not implemented!!"); + TDM_ERR("layer(%p,%d) not implemented!!", private_layer, private_layer->caps.zpos); return TDM_ERROR_NOT_IMPLEMENTED; /* LCOV_EXCL_STOP */ } -- 2.7.4 From 980c0479c0d9685fe809d873ca1d0c8877fe155e Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 16:48:17 +0900 Subject: [PATCH 05/16] thread: reset cl_list_lock when deinit Change-Id: I9999da814337a774a6ca643da915b9c11f8c914e --- src/tdm_thread.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/tdm_thread.c b/src/tdm_thread.c index 9679c94..bdc019b 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -292,6 +292,8 @@ tdm_thread_deinit(tdm_private_loop *private_loop) _pthread_mutex_unlock(&private_display->lock); pthread_join(private_loop->private_thread->event_thread, NULL); + pthread_mutex_trylock(&cb_list_lock); + pthread_mutex_unlock(&cb_list_lock); tdm_log_reset(); LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list[0], link) { -- 2.7.4 From 0eb8b0d1f0a60911f7ce4f4ea89f12e3284661c7 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 16:48:44 +0900 Subject: [PATCH 06/16] thread: remove caller_tid information when adding and removing thread_cb Change-Id: Ib5edb635cac1335a27c71fb478b88577f31f1fac --- src/tdm_thread.c | 28 +++++++++++----------------- 1 file changed, 11 insertions(+), 17 deletions(-) diff --git a/src/tdm_thread.c b/src/tdm_thread.c index bdc019b..6e891d7 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -484,7 +484,7 @@ _tdm_thread_free_cb(tdm_private_thread_cb *cb) static tdm_private_thread_cb * _tdm_thread_find_cb(struct list_head *list, void *object, tdm_thread_cb_type cb_type, - void *cb_data, tdm_thread_cb func, void *user_data, pid_t caller_tid) + void *cb_data, tdm_thread_cb func, void *user_data) { tdm_private_thread_cb *cb = NULL; @@ -493,8 +493,7 @@ _tdm_thread_find_cb(struct list_head *list, void *object, tdm_thread_cb_type cb_ cb->cb_type == cb_type && cb->cb_data == cb_data && cb->func == func && - cb->user_data == user_data && - cb->owner_tid == caller_tid) + cb->user_data == user_data) return cb; } @@ -533,7 +532,7 @@ tdm_thread_cb_add(void *object, tdm_thread_cb_type cb_type, void *cb_data, tdm_t else list = &cb_list[1]; - cb = _tdm_thread_find_cb(list, object, cb_type, cb_data, func, user_data, caller_tid); + cb = _tdm_thread_find_cb(list, object, cb_type, cb_data, func, user_data); if (cb) { pthread_mutex_unlock(&cb_list_lock); TDM_ERR("can't be added twice with same data"); @@ -569,7 +568,6 @@ INTERN void tdm_thread_cb_remove(void *object, tdm_thread_cb_type cb_type, void *cb_data, tdm_thread_cb func, void *user_data) { tdm_private_thread_cb *cb; - pid_t caller_tid; struct list_head *list; TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); @@ -577,22 +575,18 @@ tdm_thread_cb_remove(void *object, tdm_thread_cb_type cb_type, void *cb_data, td TDM_RETURN_IF_FAIL(cb_type > 0); TDM_RETURN_IF_FAIL(func != NULL); - caller_tid = syscall(SYS_gettid); - pthread_mutex_lock(&cb_list_lock); - if (tdm_thread_in_display_thread(caller_tid)) - list = &cb_list[0]; - else - list = &cb_list[1]; + list = &cb_list[0]; + cb = _tdm_thread_find_cb(list, object, cb_type, cb_data, func, user_data); + if (cb) + _tdm_thread_free_cb(cb); - cb = _tdm_thread_find_cb(list, object, cb_type, cb_data, func, user_data, caller_tid); - if (!cb) { - pthread_mutex_unlock(&cb_list_lock); - return; - } + list = &cb_list[1]; + cb = _tdm_thread_find_cb(list, object, cb_type, cb_data, func, user_data); + if (cb) + _tdm_thread_free_cb(cb); - _tdm_thread_free_cb(cb); pthread_mutex_unlock(&cb_list_lock); } -- 2.7.4 From 036d2dbb5e236625a31b38af094fa1ecfe7225a6 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 16:49:41 +0900 Subject: [PATCH 07/16] utests: correct wrong behavior Change-Id: I636ded1f8e084f626f42f3197847d9b445c9678d --- utests/src/ut_tdm_backend_display.cpp | 16 +++- utests/src/ut_tdm_backend_pp.cpp | 7 +- utests/src/ut_tdm_buffer.cpp | 6 +- utests/src/ut_tdm_client.cpp | 167 +++++++++++++++++++++------------- utests/src/ut_tdm_env.cpp | 2 +- utests/src/ut_tdm_layer.cpp | 10 +- utests/src/ut_tdm_output.cpp | 4 + 7 files changed, 136 insertions(+), 76 deletions(-) diff --git a/utests/src/ut_tdm_backend_display.cpp b/utests/src/ut_tdm_backend_display.cpp index b69ef32..7fc69a4 100644 --- a/utests/src/ut_tdm_backend_display.cpp +++ b/utests/src/ut_tdm_backend_display.cpp @@ -895,6 +895,8 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); ASSERT_NE(mode, NULL); @@ -905,7 +907,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) for (int f = 0; f < format_count; f++) { retry: - TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ @@ -963,6 +965,8 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); ASSERT_NE(mode, NULL); @@ -977,7 +981,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) int w = mode->hdisplay - diffw * (f + 1); int h = mode->vdisplay - diffh * (f + 1); retry: - TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); ASSERT_EQ(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ @@ -1125,6 +1129,8 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); + TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); ASSERT_NE(mode, NULL); @@ -1135,7 +1141,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) for (int f = 0; f < format_count; f++) { retry: - TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ @@ -1215,6 +1221,8 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) continue; } + TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l); + ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); ASSERT_NE(mode, NULL); @@ -1225,7 +1233,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) for (int f = 0; f < format_count; f++) { retry: - TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); + TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); tdm_info_layer info; diff --git a/utests/src/ut_tdm_backend_pp.cpp b/utests/src/ut_tdm_backend_pp.cpp index b326f4a..049f4ad 100644 --- a/utests/src/ut_tdm_backend_pp.cpp +++ b/utests/src/ut_tdm_backend_pp.cpp @@ -76,6 +76,9 @@ void TDMBackendPP::SetUp(void) { TDMBackendDisplay::SetUp(); + if (!ut_tdm_display_has_pp_capability(dpy)) + return; + ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE); ASSERT_GT(capabilities, 0); ASSERT_EQ(tdm_display_get_pp_available_formats(dpy, &formats, &format_count), TDM_ERROR_NONE); @@ -218,7 +221,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullObject) if (ut_tdm_display_has_pp_capability(dpy)) ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); else - ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE); ASSERT_EQ(count, TDM_UT_INVALID_VALUE); } @@ -241,7 +244,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullObject) if (ut_tdm_display_has_pp_capability(dpy)) ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); else - ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NO_CAPABILITY); + ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE); ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE); ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE); diff --git a/utests/src/ut_tdm_buffer.cpp b/utests/src/ut_tdm_buffer.cpp index 3443176..10ec508 100644 --- a/utests/src/ut_tdm_buffer.cpp +++ b/utests/src/ut_tdm_buffer.cpp @@ -72,10 +72,10 @@ ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool f TDM_UT_GOTO_IF_FAIL(buffers[b] != NULL, failed); if (fill) tdm_test_buffer_fill(buffers[b], PATTERN_SMPTE); - } - TDM_INFO("creating buffers done: width(%d) height(%d), format(%c%c%c%c) flags(%x) fill(%d), count(%d)", - width, height, FOURCC_STR(format), flags, fill, count); + TDM_INFO("creating buffer(%p) done: width(%d) height(%d), format(%c%c%c%c) flags(%x) fill(%d), count(%d)", + buffers[b], width, height, FOURCC_STR(format), flags, fill, count); + } return true; failed: diff --git a/utests/src/ut_tdm_client.cpp b/utests/src/ut_tdm_client.cpp index 055dbc3..858bc28 100644 --- a/utests/src/ut_tdm_client.cpp +++ b/utests/src/ut_tdm_client.cpp @@ -42,6 +42,7 @@ enum { TDM_UT_PIPE_MSG_NONE, TDM_UT_PIPE_MSG_REPLY, TDM_UT_PIPE_MSG_SERVER_READY, + TDM_UT_PIPE_MSG_SERVER_FAILED, TDM_UT_PIPE_MSG_DPMS_ON, TDM_UT_PIPE_MSG_DPMS_OFF, TDM_UT_PIPE_MSG_TERMINATE_SERVER, @@ -138,8 +139,6 @@ void TDMClient::SetUp(void) void TDMClient::TearDown(void) { - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); - if (vblank) tdm_client_vblank_destroy(vblank); if (client) @@ -226,17 +225,22 @@ _ut_tdm_server_set_output_dpms(tdm_display *dpy, int msg) { tdm_error ret; tdm_output *output; + tdm_output_dpms dpms; output = tdm_display_find_output(dpy, "primary", &ret); TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_dpms(output, &dpms) == TDM_ERROR_NONE); + switch (msg) { case TDM_UT_PIPE_MSG_DPMS_ON: - TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); + if (dpms != TDM_OUTPUT_DPMS_ON) + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); break; case TDM_UT_PIPE_MSG_DPMS_OFF: - TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + if (dpms != TDM_OUTPUT_DPMS_OFF) + TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); break; default: break; @@ -255,20 +259,20 @@ _ut_tdm_server_run(int *pipe_parent, int *pipe_child) int output_count = 0; dpy = tdm_display_init(&ret); - TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, done); - TDM_UT_GOTO_IF_FAIL(dpy != NULL, done); + TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(dpy != NULL, failed); - TDM_UT_GOTO_IF_FAIL(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE, done); + TDM_UT_GOTO_IF_FAIL(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE, failed); for (int o = 0; o < output_count; o++) { tdm_output *output = tdm_display_get_output(dpy, o, &ret); - TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, done); - TDM_UT_GOTO_IF_FAIL(output != NULL, done); + TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(output != NULL, failed); if (!ut_tdm_output_is_connected(output)) continue; - TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output, true) == true, done); + TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output, true) == true, failed); } TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done); @@ -323,6 +327,23 @@ _ut_tdm_server_run(int *pipe_parent, int *pipe_child) done: if (dpy) tdm_display_deinit(dpy); + return; + +failed: + TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done); + TDM_INFO("*** server failed ***"); + + if (dpy) + tdm_display_deinit(dpy); + return; + +} + +static void _ut_tdm_client_sig_handler(int sig) +{ + TDM_UT_ERR("got signal: %d", sig); + kill(TDMClient::server_pid, 9); + abort(); } static pid_t @@ -335,6 +356,8 @@ _ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child) TDM_UT_GOTO_IF_FAIL(pipe(pipe_child) == 0, failed); signal(SIGCHLD, SIG_IGN); + signal(SIGSEGV, _ut_tdm_client_sig_handler); + prctl(PR_SET_PDEATHSIG, SIGHUP); pid = fork(); @@ -554,6 +577,10 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); + + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + while (dpms != TDM_OUTPUT_DPMS_ON) + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice) @@ -628,6 +655,10 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } + + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + while (dpms != TDM_OUTPUT_DPMS_ON) + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject) @@ -1057,60 +1088,6 @@ TEST_P(TDMClient, ClientVblankWaitSeqInterval) } } -TEST_P(TDMClient, ClientVblankWaitNullObject) -{ - unsigned int cur_seq = 0; - - ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); -} - -TEST_P(TDMClient, ClientVblankWaitNullOther) -{ - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); - - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); -} - -TEST_P(TDMClient, ClientVblankWaitDpmsOff) -{ - tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); - - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); - while (dpms != TDM_OUTPUT_DPMS_OFF) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); - - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); -} - -TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) -{ - tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; - bool done; - - ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(PrepareVblank(), true); - - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); - while (dpms != TDM_OUTPUT_DPMS_OFF) - ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); - - ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); - - done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); - - while (!done) - ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); -} - TEST_P(TDMClient, ClientVblankWaitSetOffset) { bool done; @@ -1267,6 +1244,68 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) #endif +TEST_P(TDMClient, ClientVblankWaitNullObject) +{ + unsigned int cur_seq = 0; + + ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); +} + +TEST_P(TDMClient, ClientVblankWaitNullOther) +{ + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); + + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); +} + +TEST_P(TDMClient, ClientVblankWaitDpmsOff) +{ + tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; + + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); + + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + while (dpms != TDM_OUTPUT_DPMS_OFF) + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); + + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); + + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + while (dpms != TDM_OUTPUT_DPMS_ON) + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); +} + +TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) +{ + tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE; + bool done; + + ASSERT_EQ(PrepareClient(), true); + ASSERT_EQ(PrepareOutput(), true); + ASSERT_EQ(PrepareVblank(), true); + + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + while (dpms != TDM_OUTPUT_DPMS_OFF) + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + + ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); + + done = false; + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + + while (!done) + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); + + ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + while (dpms != TDM_OUTPUT_DPMS_ON) + ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); +} + #ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMClientParams, TDMClient, diff --git a/utests/src/ut_tdm_env.cpp b/utests/src/ut_tdm_env.cpp index 217c0bf..a590b68 100644 --- a/utests/src/ut_tdm_env.cpp +++ b/utests/src/ut_tdm_env.cpp @@ -61,7 +61,7 @@ void TDMEnv::SetUp(void) const char *debug = getenv("TDM_UT_DEBUG_MODULE"); if (debug && strstr(debug, "1")) - tdm_config_set_string(TDM_CONFIG_KEY_DEBUG_MODULE, "buffer,thread,event,vblank,commit,pp,capture"); + tdm_config_set_string(TDM_CONFIG_KEY_DEBUG_MODULE, "buffer,vblank,commit,pp,capture"); } void TDMEnv::TearDown(void) diff --git a/utests/src/ut_tdm_layer.cpp b/utests/src/ut_tdm_layer.cpp index 7c3b143..4d97221 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/utests/src/ut_tdm_layer.cpp @@ -30,6 +30,8 @@ #include "ut_tdm.h" +#define BORDER_SIZE 20 + class TDMLayer : public TDMOutput { public: @@ -323,8 +325,12 @@ ut_tdm_layer_fill_info(tdm_layer *layer, int w, int h, tbm_format format, tdm_in info->dst_pos.x = 0; info->dst_pos.y = 0; } else { - info->dst_pos.x = ((mode->hdisplay - w) / count) * (zpos + 1); - info->dst_pos.y = ((mode->vdisplay - h) / count) * (zpos + 1); + int x = (((int)mode->hdisplay - 2 * BORDER_SIZE - w) / count) * zpos + BORDER_SIZE; + int y = (((int)mode->vdisplay - 2 * BORDER_SIZE - h) / count) * zpos + BORDER_SIZE; + x = (x > 0) ? x : 0; + y = (y > 0) ? y : 0; + info->dst_pos.x = ((x + w) <= (int)mode->hdisplay) ? x : 0; + info->dst_pos.y = ((y + h) <= (int)mode->vdisplay) ? y : 0; } info->dst_pos.w = w; info->dst_pos.h = h; diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index b038f81..479224c 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -187,6 +187,7 @@ ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) tdm_info_layer info; tdm_layer *layer; bool done = false; + tdm_output_conn_status status; TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_is_connected(output) == true); TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_mode_setting(output) == true); @@ -215,6 +216,9 @@ ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) else TDM_UT_GOTO_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(tdm_output_get_conn_status(output, &status) == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED, failed); + while (!done) { TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed); TDM_UT_GOTO_IF_FAIL(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed); -- 2.7.4 From 75d4f368840ef4ac7adc1ae4f586f6cc9fe82f3a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 14 Mar 2018 18:38:33 +0900 Subject: [PATCH 08/16] package version up to 1.16.4 Change-Id: I4cf3f8c9cd537a105867c0713aa6e19e8d7c828f --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 829ac9a..21f462e 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.3 +Version: 1.16.4 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From a2e41c2f10500f990f5455afdce5b1e7278eef5d Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Wed, 14 Mar 2018 19:23:34 +0900 Subject: [PATCH 09/16] utest: initialize the hwc_wins Change-Id: I1a21c36e580bc33da1809e08f71e9dc13f27bbf5 --- utests/src/ut_tdm_hwc_window.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index 222bca9..b7f9be1 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -47,6 +47,7 @@ public: TDMHwcWindow::TDMHwcWindow() { + hwc_wins = NULL; hwc_count = 0; video_hwc_win = NULL; } -- 2.7.4 From ab8f6654831fbfa68e9b7a7fc99a862389299887 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 15 Mar 2018 14:28:12 +0900 Subject: [PATCH 10/16] client: reset watch_output_changes when removing all handlers Change-Id: I985579a2c5022a97d0ae7834280b22857bc484dc --- client/tdm_client.c | 1 + 1 file changed, 1 insertion(+) diff --git a/client/tdm_client.c b/client/tdm_client.c index 81998e6..1d78e39 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -935,6 +935,7 @@ tdm_client_output_remove_change_handler(tdm_client_output *output, free(h); if (LIST_IS_EMPTY(&private_output->change_handler_list)) { + private_output->watch_output_changes = 0; if (!CHECK_WL_PROTOCOL_ERROR(private_client)) { wl_tdm_output_watch_output_changes(private_output->output, 0); wl_display_roundtrip_queue(private_client->display, private_client->queue); -- 2.7.4 From f6bec662f8c95b24acc55715dc260caa2187da32 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 15 Mar 2018 14:28:56 +0900 Subject: [PATCH 11/16] utests: disable SetProperty tc not avaiable to test Change-Id: I782bdd0f4aec95421352cb4c607e1ead13ecc2ab --- utests/src/ut_tdm_layer.cpp | 18 +----------------- utests/src/ut_tdm_output.cpp | 16 +--------------- 2 files changed, 2 insertions(+), 32 deletions(-) diff --git a/utests/src/ut_tdm_layer.cpp b/utests/src/ut_tdm_layer.cpp index 4d97221..caca8eb 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/utests/src/ut_tdm_layer.cpp @@ -548,24 +548,8 @@ TEST_P(TDMLayer, LayerGetZposNullParam) ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMLayer, LayerSetProperty) +TEST_P(TDMLayer, DISABLED_LayerSetProperty) { - TDM_UT_SKIP_FLAG(has_layers); - - for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) - continue; - - const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; - int count = TDM_UT_INVALID_VALUE; - tdm_value value = {.s32 = 0}; - - ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE); - ASSERT_GE(count, 0); - - if (count > 0) - ASSERT_EQ(tdm_layer_set_property(layers[l], props[0].id, value), TDM_ERROR_NONE); - } } TEST_P(TDMLayer, LayerSetPropertyNullObject) diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index 479224c..d4bb6e1 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -820,22 +820,8 @@ TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther) ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMOutput, OutputSetProperty) +TEST_P(TDMOutput, DISABLED_OutputSetProperty) { - TDM_UT_SKIP_FLAG(has_outputs); - - for (int o = 0; o < output_count; o++) { - const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; - int count = TDM_UT_INVALID_VALUE; - tdm_value value = {.s32 = 0}; - - ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE); - ASSERT_GE(count, 0); - if (count > 0) { - ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE); - ASSERT_EQ(tdm_output_set_property(outputs[o], props[0].id, value), TDM_ERROR_NONE); - } - } } TEST_P(TDMOutput, OutputSetPropertyNullObject) -- 2.7.4 From d5e13e8d0378b735832ad6a5596b45776035ecbe Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 15 Mar 2018 14:30:23 +0900 Subject: [PATCH 12/16] utests: fix deadlock after adding change handler, have to call handle_events to dispatch events. Change-Id: Id8bc3b52508b383b5fc204bfc493d79cf172065d --- utests/src/ut_tdm_client.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/utests/src/ut_tdm_client.cpp b/utests/src/ut_tdm_client.cpp index 858bc28..e4b445b 100644 --- a/utests/src/ut_tdm_client.cpp +++ b/utests/src/ut_tdm_client.cpp @@ -579,8 +579,10 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); - while (dpms != TDM_OUTPUT_DPMS_ON) + while (dpms != TDM_OUTPUT_DPMS_ON) { + ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); + } } TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice) -- 2.7.4 From 4f0102b065f289479ae76fa6661f5969583e2085 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 15 Mar 2018 16:56:56 +0900 Subject: [PATCH 13/16] package version up to 1.16.5 Change-Id: I9052516fba6f6a7e98e22908b3a5c36f32fe67aa --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 21f462e..13b2af7 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.4 +Version: 1.16.5 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 3dab774282940b13db1792b57deaf50109d9d5e3 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 16 Mar 2018 08:35:32 +0900 Subject: [PATCH 14/16] Revert "output: seperate output-status and output-dpms change" This reverts commit dd84f199e0e855ca945bae239c152fa22147af53. Change-Id: I0aa9117c9dac6ee5664f549bcf25a51fca072efb --- src/tdm.c | 3 +- src/tdm_macro.h | 3 +- src/tdm_output.c | 98 +++++++++++++++---------------------------------- src/tdm_private_types.h | 16 +++----- src/tdm_thread.c | 13 +++---- 5 files changed, 42 insertions(+), 91 deletions(-) diff --git a/src/tdm.c b/src/tdm.c index 42387fd..c17e9fc 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -198,8 +198,7 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) { LIST_DEL(&h->link); - tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, h); - tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, h); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, h); free(h); } diff --git a/src/tdm_macro.h b/src/tdm_macro.h index acdc9f3..45bde65 100644 --- a/src/tdm_macro.h +++ b/src/tdm_macro.h @@ -244,8 +244,7 @@ static struct tdm_type_name tdm_cb_type_names[] = { { TDM_THREAD_CB_NONE, "none" }, { TDM_THREAD_CB_OUTPUT_COMMIT, "output-commit" }, { TDM_THREAD_CB_OUTPUT_VBLANK, "output-vblank" }, - { TDM_THREAD_CB_OUTPUT_STATUS, "output-status" }, - { TDM_THREAD_CB_OUTPUT_DPMS, "output-dpms" }, + { TDM_THREAD_CB_OUTPUT_CHANGE, "output-change" }, { TDM_THREAD_CB_PP_DONE, "pp-done" }, { TDM_THREAD_CB_CAPTURE_DONE, "capture-done" }, { TDM_THREAD_CB_VBLANK_SW, "vblank-sw" }, diff --git a/src/tdm_output.c b/src/tdm_output.c index 652e262..b87da84 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -146,9 +146,7 @@ tdm_output_init(tdm_private_display *private_display) { tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_COMMIT, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_VBLANK, tdm_display_find_output_stamp); - tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_STATUS, tdm_display_find_output_stamp); - tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DPMS, tdm_display_find_output_stamp); - + tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_CHANGE, tdm_display_find_output_stamp); return TDM_ERROR_NONE; } @@ -228,68 +226,34 @@ INTERN void tdm_output_thread_cb_change(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { tdm_private_output *private_output = object; + tdm_thread_cb_output_change *output_change = (tdm_thread_cb_output_change *)cb_base; tdm_private_output_change_handler *change_handler = user_data; - tdm_output_change_type type = TDM_OUTPUT_CHANGE_CONNECTION; - tdm_value value = {.u32 = 0 }; TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); assert(change_handler->owner_tid == syscall(SYS_gettid)); - if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { - tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status *)cb_base; - type = TDM_OUTPUT_CHANGE_CONNECTION; - value.u32 = output_status->status; - } else if (cb_base->type == TDM_THREAD_CB_OUTPUT_DPMS) { - tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms *)cb_base; - type = TDM_OUTPUT_CHANGE_DPMS; - value.u32 = output_dpms->dpms; - } else { - TDM_NEVER_GET_HERE(); - return; - } - _pthread_mutex_unlock(&private_display->lock); - change_handler->func(private_output, type, value, change_handler->user_data); + change_handler->func(private_output, output_change->type, output_change->value, change_handler->user_data); _pthread_mutex_lock(&private_display->lock); - } static tdm_error -_tdm_output_call_thread_cb_status(tdm_private_output *private_output, tdm_output_conn_status status) +_tdm_output_call_thread_cb_change(tdm_private_output *private_output, tdm_output_change_type type, tdm_value value) { - tdm_thread_cb_output_status output_status; + tdm_thread_cb_output_change output_change; tdm_error ret; - memset(&output_status, 0, sizeof output_status); - output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS; - output_status.base.length = sizeof output_status; - output_status.base.object_stamp = private_output->stamp; - output_status.base.data = NULL; - output_status.base.sync = 1; - output_status.status = status; + memset(&output_change, 0, sizeof output_change); + output_change.base.type = TDM_THREAD_CB_OUTPUT_CHANGE; + output_change.base.length = sizeof output_change; + output_change.base.object_stamp = private_output->stamp; + output_change.base.data = NULL; + output_change.base.sync = 1; + output_change.type = type; + output_change.value = value; - ret = tdm_thread_cb_call(private_output, &output_status.base); - TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - - return TDM_ERROR_NONE; -} - -static tdm_error -_tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_dpms dpms) -{ - tdm_thread_cb_output_dpms output_dpms; - tdm_error ret; - - memset(&output_dpms, 0, sizeof output_dpms); - output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS; - output_dpms.base.length = sizeof output_dpms; - output_dpms.base.object_stamp = private_output->stamp; - output_dpms.base.data = NULL; - output_dpms.base.sync = 0; - output_dpms.dpms = dpms; - - ret = tdm_thread_cb_call(private_output, &output_dpms.base); + ret = tdm_thread_cb_call(private_output, &output_change.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; @@ -299,6 +263,7 @@ INTERN void tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data) { tdm_private_output *private_output = user_data; + tdm_value value; tdm_error ret; TDM_RETURN_IF_FAIL(private_output); @@ -313,7 +278,9 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, private_output->caps.status = status; } - ret = _tdm_output_call_thread_cb_status(private_output, status); + value.u32 = status; + + ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_CONNECTION, value); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -321,6 +288,7 @@ INTERN void tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data) { tdm_private_output *private_output = user_data; + tdm_value value; tdm_error ret; TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(dpms)); @@ -329,7 +297,9 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_ private_output->waiting_dpms_change = 0; TDM_INFO("output(%d) dpms async '%s' done", private_output->pipe, tdm_dpms_str(dpms)); - ret = _tdm_output_call_thread_cb_dpms(private_output, dpms); + value.u32 = dpms; + + ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -362,21 +332,10 @@ tdm_output_add_change_handler(tdm_output *output, /* LCOV_EXCL_STOP */ } - ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); - if (ret != TDM_ERROR_NONE) { - /* LCOV_EXCL_START */ - TDM_ERR("tdm_thread_cb_add failed"); - free(change_handler); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_OPERATION_FAILED; - /* LCOV_EXCL_STOP */ - } - - ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler); + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("tdm_thread_cb_add failed"); - tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); free(change_handler); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OPERATION_FAILED; @@ -416,8 +375,7 @@ tdm_output_remove_change_handler(tdm_output *output, if (change_handler->func != func || change_handler->user_data != user_data) continue; - tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); - tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler); LIST_DEL(&change_handler->link); free(change_handler); @@ -1344,8 +1302,10 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) done: if (ret == TDM_ERROR_NONE) { if (private_output->current_dpms_value != dpms_value) { + tdm_value value; private_output->current_dpms_value = dpms_value; - _tdm_output_call_thread_cb_dpms(private_output, dpms_value); + value.u32 = dpms_value; + _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); TDM_INFO("output(%d) dpms '%s' done", private_output->pipe, tdm_dpms_str(dpms_value)); } } else { @@ -1486,11 +1446,13 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) /* checking with backend's value */ if (*dpms_value != private_output->current_dpms_value) { + tdm_value value; TDM_ERR("output(%d) dpms changed suddenly: %s -> %s", private_output->pipe, tdm_dpms_str(private_output->current_dpms_value), tdm_dpms_str(*dpms_value)); private_output->current_dpms_value = *dpms_value; - _tdm_output_call_thread_cb_dpms(private_output, *dpms_value); + value.u32 = *dpms_value; + _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); } return ret; diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index a5b4423..d1c132d 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -449,8 +449,7 @@ typedef enum { TDM_THREAD_CB_NONE, TDM_THREAD_CB_OUTPUT_COMMIT, TDM_THREAD_CB_OUTPUT_VBLANK, - TDM_THREAD_CB_OUTPUT_STATUS, - TDM_THREAD_CB_OUTPUT_DPMS, + TDM_THREAD_CB_OUTPUT_CHANGE, TDM_THREAD_CB_PP_DONE, TDM_THREAD_CB_CAPTURE_DONE, TDM_THREAD_CB_VBLANK_SW, @@ -462,8 +461,7 @@ typedef enum { typedef struct _tdm_thread_cb_base tdm_thread_cb_base; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_commit; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_vblank; -typedef struct _tdm_thread_cb_output_dpms tdm_thread_cb_output_dpms; -typedef struct _tdm_thread_cb_output_status tdm_thread_cb_output_status; +typedef struct _tdm_thread_cb_output_change tdm_thread_cb_output_change; typedef struct _tdm_thread_cb_pp_done tdm_thread_cb_pp_done; typedef struct _tdm_thread_cb_capture_done tdm_thread_cb_capture_done; typedef struct _tdm_thread_cb_vblank_sw tdm_thread_cb_vblank_sw; @@ -485,14 +483,10 @@ struct _tdm_thread_cb_output_vblank { unsigned int tv_usec; }; -struct _tdm_thread_cb_output_status { +struct _tdm_thread_cb_output_change { tdm_thread_cb_base base; - tdm_output_conn_status status; -}; - -struct _tdm_thread_cb_output_dpms { - tdm_thread_cb_base base; - tdm_output_dpms dpms; + tdm_output_change_type type; + tdm_value value; }; struct _tdm_thread_cb_pp_done { diff --git a/src/tdm_thread.c b/src/tdm_thread.c index 6e891d7..ff8c238 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -432,8 +432,7 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) switch (base->type) { case TDM_THREAD_CB_OUTPUT_COMMIT: case TDM_THREAD_CB_OUTPUT_VBLANK: - case TDM_THREAD_CB_OUTPUT_STATUS: - case TDM_THREAD_CB_OUTPUT_DPMS: + case TDM_THREAD_CB_OUTPUT_CHANGE: case TDM_THREAD_CB_PP_DONE: case TDM_THREAD_CB_CAPTURE_DONE: case TDM_THREAD_CB_VBLANK_SW: @@ -610,18 +609,16 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) TDM_RETURN_VAL_IF_FAIL(cb_base != NULL, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->type > 0, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->length > 0, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0 || cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->object_stamp > 0, TDM_ERROR_INVALID_PARAMETER); caller_tid = syscall(SYS_gettid); assert(find_funcs[cb_base->type] != NULL); - /* handling only output-status as sync */ - if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { - TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); - } else { - TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0, TDM_ERROR_INVALID_PARAMETER); - } + /* When there is the previous waiting sync call, the other type sync call CAN't be handlered */ + if (waiting_tid > 0 && cb_base->sync == 1) + assert(waiting_cb_type == cb_base->type); if (!object) { object = find_funcs[cb_base->type](private_display, cb_base->object_stamp); -- 2.7.4 From 758bfd1906831fa520a2e26e795169c0d431570c Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 16 Mar 2018 09:17:07 +0900 Subject: [PATCH 15/16] Revert "Revert "output: seperate output-status and output-dpms change"" This reverts commit 3dab774282940b13db1792b57deaf50109d9d5e3. Change-Id: I64aec7755e0822b85b28e420b4fd2727b6763e51 --- src/tdm.c | 3 +- src/tdm_macro.h | 3 +- src/tdm_output.c | 98 ++++++++++++++++++++++++++++++++++--------------- src/tdm_private_types.h | 16 +++++--- src/tdm_thread.c | 13 ++++--- 5 files changed, 91 insertions(+), 42 deletions(-) diff --git a/src/tdm.c b/src/tdm.c index c17e9fc..42387fd 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -198,7 +198,8 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) { LIST_DEL(&h->link); - tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, h); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, h); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, h); free(h); } diff --git a/src/tdm_macro.h b/src/tdm_macro.h index 45bde65..acdc9f3 100644 --- a/src/tdm_macro.h +++ b/src/tdm_macro.h @@ -244,7 +244,8 @@ static struct tdm_type_name tdm_cb_type_names[] = { { TDM_THREAD_CB_NONE, "none" }, { TDM_THREAD_CB_OUTPUT_COMMIT, "output-commit" }, { TDM_THREAD_CB_OUTPUT_VBLANK, "output-vblank" }, - { TDM_THREAD_CB_OUTPUT_CHANGE, "output-change" }, + { TDM_THREAD_CB_OUTPUT_STATUS, "output-status" }, + { TDM_THREAD_CB_OUTPUT_DPMS, "output-dpms" }, { TDM_THREAD_CB_PP_DONE, "pp-done" }, { TDM_THREAD_CB_CAPTURE_DONE, "capture-done" }, { TDM_THREAD_CB_VBLANK_SW, "vblank-sw" }, diff --git a/src/tdm_output.c b/src/tdm_output.c index b87da84..652e262 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -146,7 +146,9 @@ tdm_output_init(tdm_private_display *private_display) { tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_COMMIT, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_VBLANK, tdm_display_find_output_stamp); - tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_CHANGE, tdm_display_find_output_stamp); + tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_STATUS, tdm_display_find_output_stamp); + tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DPMS, tdm_display_find_output_stamp); + return TDM_ERROR_NONE; } @@ -226,34 +228,68 @@ INTERN void tdm_output_thread_cb_change(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) { tdm_private_output *private_output = object; - tdm_thread_cb_output_change *output_change = (tdm_thread_cb_output_change *)cb_base; tdm_private_output_change_handler *change_handler = user_data; + tdm_output_change_type type = TDM_OUTPUT_CHANGE_CONNECTION; + tdm_value value = {.u32 = 0 }; TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); assert(change_handler->owner_tid == syscall(SYS_gettid)); + if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { + tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status *)cb_base; + type = TDM_OUTPUT_CHANGE_CONNECTION; + value.u32 = output_status->status; + } else if (cb_base->type == TDM_THREAD_CB_OUTPUT_DPMS) { + tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms *)cb_base; + type = TDM_OUTPUT_CHANGE_DPMS; + value.u32 = output_dpms->dpms; + } else { + TDM_NEVER_GET_HERE(); + return; + } + _pthread_mutex_unlock(&private_display->lock); - change_handler->func(private_output, output_change->type, output_change->value, change_handler->user_data); + change_handler->func(private_output, type, value, change_handler->user_data); _pthread_mutex_lock(&private_display->lock); + } static tdm_error -_tdm_output_call_thread_cb_change(tdm_private_output *private_output, tdm_output_change_type type, tdm_value value) +_tdm_output_call_thread_cb_status(tdm_private_output *private_output, tdm_output_conn_status status) { - tdm_thread_cb_output_change output_change; + tdm_thread_cb_output_status output_status; tdm_error ret; - memset(&output_change, 0, sizeof output_change); - output_change.base.type = TDM_THREAD_CB_OUTPUT_CHANGE; - output_change.base.length = sizeof output_change; - output_change.base.object_stamp = private_output->stamp; - output_change.base.data = NULL; - output_change.base.sync = 1; - output_change.type = type; - output_change.value = value; + memset(&output_status, 0, sizeof output_status); + output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS; + output_status.base.length = sizeof output_status; + output_status.base.object_stamp = private_output->stamp; + output_status.base.data = NULL; + output_status.base.sync = 1; + output_status.status = status; - ret = tdm_thread_cb_call(private_output, &output_change.base); + ret = tdm_thread_cb_call(private_output, &output_status.base); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); + + return TDM_ERROR_NONE; +} + +static tdm_error +_tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_dpms dpms) +{ + tdm_thread_cb_output_dpms output_dpms; + tdm_error ret; + + memset(&output_dpms, 0, sizeof output_dpms); + output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS; + output_dpms.base.length = sizeof output_dpms; + output_dpms.base.object_stamp = private_output->stamp; + output_dpms.base.data = NULL; + output_dpms.base.sync = 0; + output_dpms.dpms = dpms; + + ret = tdm_thread_cb_call(private_output, &output_dpms.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; @@ -263,7 +299,6 @@ INTERN void tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data) { tdm_private_output *private_output = user_data; - tdm_value value; tdm_error ret; TDM_RETURN_IF_FAIL(private_output); @@ -278,9 +313,7 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, private_output->caps.status = status; } - value.u32 = status; - - ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_CONNECTION, value); + ret = _tdm_output_call_thread_cb_status(private_output, status); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -288,7 +321,6 @@ INTERN void tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data) { tdm_private_output *private_output = user_data; - tdm_value value; tdm_error ret; TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(dpms)); @@ -297,9 +329,7 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_ private_output->waiting_dpms_change = 0; TDM_INFO("output(%d) dpms async '%s' done", private_output->pipe, tdm_dpms_str(dpms)); - value.u32 = dpms; - - ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); + ret = _tdm_output_call_thread_cb_dpms(private_output, dpms); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -332,10 +362,21 @@ tdm_output_add_change_handler(tdm_output *output, /* LCOV_EXCL_STOP */ } - ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler); + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); + if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ + TDM_ERR("tdm_thread_cb_add failed"); + free(change_handler); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OPERATION_FAILED; + /* LCOV_EXCL_STOP */ + } + + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("tdm_thread_cb_add failed"); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); free(change_handler); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OPERATION_FAILED; @@ -375,7 +416,8 @@ tdm_output_remove_change_handler(tdm_output *output, if (change_handler->func != func || change_handler->user_data != user_data) continue; - tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler); LIST_DEL(&change_handler->link); free(change_handler); @@ -1302,10 +1344,8 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) done: if (ret == TDM_ERROR_NONE) { if (private_output->current_dpms_value != dpms_value) { - tdm_value value; private_output->current_dpms_value = dpms_value; - value.u32 = dpms_value; - _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); + _tdm_output_call_thread_cb_dpms(private_output, dpms_value); TDM_INFO("output(%d) dpms '%s' done", private_output->pipe, tdm_dpms_str(dpms_value)); } } else { @@ -1446,13 +1486,11 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) /* checking with backend's value */ if (*dpms_value != private_output->current_dpms_value) { - tdm_value value; TDM_ERR("output(%d) dpms changed suddenly: %s -> %s", private_output->pipe, tdm_dpms_str(private_output->current_dpms_value), tdm_dpms_str(*dpms_value)); private_output->current_dpms_value = *dpms_value; - value.u32 = *dpms_value; - _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value); + _tdm_output_call_thread_cb_dpms(private_output, *dpms_value); } return ret; diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index d1c132d..a5b4423 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -449,7 +449,8 @@ typedef enum { TDM_THREAD_CB_NONE, TDM_THREAD_CB_OUTPUT_COMMIT, TDM_THREAD_CB_OUTPUT_VBLANK, - TDM_THREAD_CB_OUTPUT_CHANGE, + TDM_THREAD_CB_OUTPUT_STATUS, + TDM_THREAD_CB_OUTPUT_DPMS, TDM_THREAD_CB_PP_DONE, TDM_THREAD_CB_CAPTURE_DONE, TDM_THREAD_CB_VBLANK_SW, @@ -461,7 +462,8 @@ typedef enum { typedef struct _tdm_thread_cb_base tdm_thread_cb_base; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_commit; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_vblank; -typedef struct _tdm_thread_cb_output_change tdm_thread_cb_output_change; +typedef struct _tdm_thread_cb_output_dpms tdm_thread_cb_output_dpms; +typedef struct _tdm_thread_cb_output_status tdm_thread_cb_output_status; typedef struct _tdm_thread_cb_pp_done tdm_thread_cb_pp_done; typedef struct _tdm_thread_cb_capture_done tdm_thread_cb_capture_done; typedef struct _tdm_thread_cb_vblank_sw tdm_thread_cb_vblank_sw; @@ -483,10 +485,14 @@ struct _tdm_thread_cb_output_vblank { unsigned int tv_usec; }; -struct _tdm_thread_cb_output_change { +struct _tdm_thread_cb_output_status { tdm_thread_cb_base base; - tdm_output_change_type type; - tdm_value value; + tdm_output_conn_status status; +}; + +struct _tdm_thread_cb_output_dpms { + tdm_thread_cb_base base; + tdm_output_dpms dpms; }; struct _tdm_thread_cb_pp_done { diff --git a/src/tdm_thread.c b/src/tdm_thread.c index ff8c238..6e891d7 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -432,7 +432,8 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) switch (base->type) { case TDM_THREAD_CB_OUTPUT_COMMIT: case TDM_THREAD_CB_OUTPUT_VBLANK: - case TDM_THREAD_CB_OUTPUT_CHANGE: + case TDM_THREAD_CB_OUTPUT_STATUS: + case TDM_THREAD_CB_OUTPUT_DPMS: case TDM_THREAD_CB_PP_DONE: case TDM_THREAD_CB_CAPTURE_DONE: case TDM_THREAD_CB_VBLANK_SW: @@ -609,16 +610,18 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) TDM_RETURN_VAL_IF_FAIL(cb_base != NULL, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->type > 0, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->length > 0, TDM_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0 || cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(cb_base->object_stamp > 0, TDM_ERROR_INVALID_PARAMETER); caller_tid = syscall(SYS_gettid); assert(find_funcs[cb_base->type] != NULL); - /* When there is the previous waiting sync call, the other type sync call CAN't be handlered */ - if (waiting_tid > 0 && cb_base->sync == 1) - assert(waiting_cb_type == cb_base->type); + /* handling only output-status as sync */ + if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { + TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); + } else { + TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0, TDM_ERROR_INVALID_PARAMETER); + } if (!object) { object = find_funcs[cb_base->type](private_display, cb_base->object_stamp); -- 2.7.4 From d8df1d82aac258eb4ac81829e61e73796073ab4f Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 16 Mar 2018 10:17:28 +0900 Subject: [PATCH 16/16] thread: correct the infinite event propagation issue when calling tdm_thread_cb_call, 'propagation' param will help to decide if we need to propagate a event to other thread or not. and checking waiting_cb_type variable is not needed any more. Change-Id: I59929cb8dc1dd1ada2e7b8acfa9095a174e12928 --- src/tdm_capture.c | 2 +- src/tdm_output.c | 10 +++++----- src/tdm_pp.c | 2 +- src/tdm_thread.c | 43 +++++++++++++++++++++++++------------------ src/tdm_thread.h | 2 +- src/tdm_vblank.c | 4 ++-- 6 files changed, 35 insertions(+), 28 deletions(-) diff --git a/src/tdm_capture.c b/src/tdm_capture.c index 982230f..b0acba2 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -169,7 +169,7 @@ _tdm_capture_cb_done(tdm_capture *capture_module, tbm_surface_h buffer, void *us capture_done.base.sync = 0; capture_done.buffer = buffer; - ret = tdm_thread_cb_call(private_capture, &capture_done.base); + ret = tdm_thread_cb_call(private_capture, &capture_done.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } diff --git a/src/tdm_output.c b/src/tdm_output.c index 652e262..bf353ce 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -269,7 +269,7 @@ _tdm_output_call_thread_cb_status(tdm_private_output *private_output, tdm_output output_status.base.sync = 1; output_status.status = status; - ret = tdm_thread_cb_call(private_output, &output_status.base); + ret = tdm_thread_cb_call(private_output, &output_status.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; @@ -289,7 +289,7 @@ _tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_d output_dpms.base.sync = 0; output_dpms.dpms = dpms; - ret = tdm_thread_cb_call(private_output, &output_dpms.base); + ret = tdm_thread_cb_call(private_output, &output_dpms.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; @@ -811,7 +811,7 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, if (tdm_debug_module & TDM_DEBUG_COMMIT) TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler); - ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base); + ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -887,7 +887,7 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, output_commit.tv_sec = tv_sec; output_commit.tv_usec = tv_usec; - ret = tdm_thread_cb_call(private_output, &output_commit.base); + ret = tdm_thread_cb_call(private_output, &output_commit.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } @@ -2164,7 +2164,7 @@ _need_validate_handler(int fd, tdm_event_loop_mask mask, void *user_data) ev.base.data = NULL; ev.base.sync = 0; - ret = tdm_thread_cb_call(private_output, &ev.base); + ret = tdm_thread_cb_call(private_output, &ev.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); TDM_INFO("tdm-thread: get a 'need to revalidate' event for the ouptut:%p.", private_output); diff --git a/src/tdm_pp.c b/src/tdm_pp.c index d9fcc31..ae5022e 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -173,7 +173,7 @@ _tdm_pp_cb_done(tdm_pp *pp_module, tbm_surface_h src, tbm_surface_h dst, void *u pp_done.src = src; pp_done.dst = dst; - ret = tdm_thread_cb_call(private_pp, &pp_done.base); + ret = tdm_thread_cb_call(private_pp, &pp_done.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } diff --git a/src/tdm_thread.c b/src/tdm_thread.c index 6e891d7..29d996a 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -439,7 +439,8 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) case TDM_THREAD_CB_VBLANK_SW: case TDM_THREAD_CB_VBLANK_CREATE: case TDM_THREAD_CB_NEED_VALIDATE: - ret = tdm_thread_cb_call(NULL, base); + /* this event comes from other thread. so we don't need to propagate this to other thread */ + ret = tdm_thread_cb_call(NULL, base, 0); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); break; default: @@ -594,7 +595,7 @@ tdm_thread_cb_remove(void *object, tdm_thread_cb_type cb_type, void *cb_data, td * because a callback is added with cb_type and cb_data. */ INTERN tdm_error -tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) +tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base, unsigned int propagation) { tdm_private_display *private_display = tdm_display_get(); tdm_private_thread_cb *cb = NULL, *hh = NULL; @@ -603,7 +604,6 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) struct list_head *list, *other_list; struct list_head call_list; static pid_t waiting_tid = 0; - static tdm_thread_cb_type waiting_cb_type = TDM_THREAD_CB_NONE; tdm_error ret; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); @@ -616,12 +616,15 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) assert(find_funcs[cb_base->type] != NULL); - /* handling only output-status as sync */ - if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) { - TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 1, TDM_ERROR_INVALID_PARAMETER); - } else { - TDM_RETURN_VAL_IF_FAIL(cb_base->sync == 0, TDM_ERROR_INVALID_PARAMETER); - } + if (tdm_debug_module & TDM_DEBUG_THREAD) + TDM_INFO("'%s' thread_cb (sync:%d, propagation:%d) ------", + tdm_cb_type_str(cb_base->type), cb_base->sync, propagation); + + /* handling only output-status as sync. below logic can't handle two sync-type events */ + if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) + assert(cb_base->sync == 1); + else + assert(cb_base->sync == 0); if (!object) { object = find_funcs[cb_base->type](private_display, cb_base->object_stamp); @@ -665,9 +668,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) pthread_mutex_unlock(&cb_list_lock); - assert(LIST_IS_EMPTY(&call_list)); - - if (waiting_tid == 0 || waiting_cb_type != cb_base->type) { + if (propagation) { LIST_FOR_EACH_ENTRY_SAFE(cb, hh, other_list, link) { if (cb->object != object || cb->cb_type != cb_base->type || @@ -681,27 +682,34 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) if (!handler_in_other_thread) { if (keep_private_thread) { - if (cb_base->sync) { + if (cb_base->sync && waiting_tid != 0) { waiting_tid = 0; - waiting_cb_type = TDM_THREAD_CB_NONE; pthread_cond_signal(&keep_private_thread->event_cond); if (tdm_debug_module & TDM_DEBUG_THREAD) TDM_INFO("pthread broadcase"); } } if (tdm_debug_module & TDM_DEBUG_THREAD) - TDM_INFO("'%s' thread_cb done(sync:%d)", tdm_cb_type_str(cb_base->type), cb_base->sync); + TDM_INFO("'%s' thread_cb (sync:%d, propagation:%d) ------...", + tdm_cb_type_str(cb_base->type), cb_base->sync, propagation); return TDM_ERROR_NONE; } /* Once we reach here, it means that keep_private_thread is not NULL. * Just make the crash. Avoiding it is not going to help us. */ + assert(keep_private_thread != NULL); + ret = tdm_thread_send_cb(private_display->private_loop, cb_base); TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED); /* waiting until all cb are done in another thread */ if (cb_base->sync) { + /* if waiting_tid is not 0, it means there are two sync-type events at the same time. + * and it would make deadlock issue. + */ + assert(waiting_tid == 0); + if (tdm_debug_module & TDM_DEBUG_THREAD) TDM_INFO("pthread wait"); @@ -710,14 +718,13 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) */ tdm_mutex_locked = 0; waiting_tid = caller_tid; - waiting_cb_type = cb_base->type; - pthread_cond_wait(&keep_private_thread->event_cond, &private_display->lock); tdm_mutex_locked = 1; } if (tdm_debug_module & TDM_DEBUG_THREAD) - TDM_INFO("'%s' thread_cb done(sync:%d)", tdm_cb_type_str(cb_base->type), cb_base->sync); + TDM_INFO("'%s' thread_cb (sync:%d, propagation:%d) ------...", + tdm_cb_type_str(cb_base->type), cb_base->sync, propagation); return TDM_ERROR_NONE; } diff --git a/src/tdm_thread.h b/src/tdm_thread.h index 1a91933..57c4c6f 100644 --- a/src/tdm_thread.h +++ b/src/tdm_thread.h @@ -67,7 +67,7 @@ tdm_thread_cb_add(void *object, tdm_thread_cb_type cb_type, void *cb_data, tdm_t void tdm_thread_cb_remove(void *object, tdm_thread_cb_type cb_type, void *cb_data, tdm_thread_cb func, void *user_data); tdm_error -tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base); +tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base, unsigned int propagation); #ifdef __cplusplus diff --git a/src/tdm_vblank.c b/src/tdm_vblank.c index 263f825..cbedea7 100644 --- a/src/tdm_vblank.c +++ b/src/tdm_vblank.c @@ -601,7 +601,7 @@ _tdm_vblank_call_thread_cb(tdm_private_vblank *private_vblank) vblank_create.base.sync = 0; vblank_create.vblank_stamp = private_vblank->stamp; - ret = tdm_thread_cb_call(private_vblank->dpy, &vblank_create.base); + ret = tdm_thread_cb_call(private_vblank->dpy, &vblank_create.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; @@ -1410,7 +1410,7 @@ _tdm_vblank_cb_timeout_SW(void *user_data) vblank_sw.base.data = NULL; vblank_sw.base.sync = 0; - ret = tdm_thread_cb_call(private_vblank, &vblank_sw.base); + ret = tdm_thread_cb_call(private_vblank, &vblank_sw.base, 1); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; -- 2.7.4