* Taeheon Kim <th908.kim@samsung.com>,
* YoungJun Cho <yj44.cho@samsung.com>,
* SooChan Lim <sc1.lim@samsung.com>,
- * Boram Park <sc1.lim@samsung.com>
+ * Boram Park <boram1288.park@samsung.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
pthread_cond_t event_cond;
pthread_t event_thread;
+ unsigned int event_thread_exit;
+ unsigned int event_thread_joined;
pid_t display_tid;
pid_t thread_tid;
/* 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);
TDM_INFO("server flush");
tdm_event_loop_flush(private_loop->dpy);
+ if (private_thread->event_thread_exit)
+ break;
+
if (tdm_debug_module & TDM_DEBUG_EVENT)
TDM_INFO("fd(%d) polling in", fd);
pthread_exit(NULL);
}
+static tdm_error
+_tdm_thread_exit(tdm_private_loop *private_loop)
+{
+ tdm_thread_cb_base cb_base;
+ tdm_error ret;
+
+ memset(&cb_base, 0, sizeof cb_base);
+ cb_base.type = TDM_THREAD_CB_EXIT;
+ cb_base.length = sizeof cb_base;
+
+ ret = tdm_thread_send_cb(private_loop, &cb_base);
+ TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
+
+ return ret;
+}
+
/* NOTE: tdm thread doesn't care about multi-thread. */
INTERN tdm_error
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]);
{
tdm_private_display *private_display;
tdm_private_thread_cb *cb = NULL, *hh = NULL;
- int i;
+ tdm_error ret;
TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- for (i = 0; i < TDM_THREAD_CB_MAX; i++)
- find_funcs[i] = NULL;
-
if (!private_loop->private_thread)
return;
- if (private_loop->private_thread->sub_event_source)
- tdm_event_loop_source_remove(private_loop->private_thread->sub_event_source);
-
- pthread_cancel(private_loop->private_thread->event_thread);
+ ret = _tdm_thread_exit(private_loop);
+ if (ret != TDM_ERROR_NONE)
+ pthread_cancel(private_loop->private_thread->event_thread);
private_display = private_loop->dpy;
*/
_pthread_mutex_unlock(&private_display->lock);
pthread_join(private_loop->private_thread->event_thread, NULL);
+ private_loop->private_thread->event_thread_joined = 1;
+ TDM_INFO("Joined a TDM event thread");
+ pthread_mutex_unlock(&cb_list_lock);
tdm_log_reset();
- pthread_mutex_destroy(&cb_list_lock);
+ if (private_loop->private_thread->sub_event_source)
+ tdm_event_loop_source_remove(private_loop->private_thread->sub_event_source);
LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list[0], link) {
_tdm_thread_free_cb(cb);
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:
case TDM_THREAD_CB_VBLANK_CREATE:
- case TDM_THREAD_CB_NEED_VALIDATE:
- ret = tdm_thread_cb_call(NULL, base);
+ case TDM_THREAD_CB_HWC_COMMIT:
+ /* 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;
+ case TDM_THREAD_CB_EXIT:
+ private_thread->event_thread_exit = 1;
+ break;
default:
break;
}
{
/* DON'T check TDM_MUTEX_IS_LOCKED here */
- return (keep_private_thread) ? 1 : 0;
+ return (keep_private_thread && !keep_private_thread->event_thread_joined) ? 1 : 0;
}
static void
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;
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;
}
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");
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());
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);
}
* 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;
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);
+ if (keep_private_thread && keep_private_thread->thread_tid != caller_tid) {
+ /* A sync-type event from display-thread to tdm-thread can't be handled.
+ * If sync-type events happen in both threads at the same time,
+ * it would make a deadlock issue.
+ */
+ assert(cb_base->sync != 1);
+ }
+
+ 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);
+
if (!object) {
object = find_funcs[cb_base->type](private_display, cb_base->object_stamp);
if (!object) {
pthread_mutex_unlock(&cb_list_lock);
- assert(LIST_IS_EMPTY(&call_list));
-
- if (waiting_tid == 0) {
+ if (propagation) {
LIST_FOR_EACH_ENTRY_SAFE(cb, hh, other_list, link) {
if (cb->object != object ||
cb->cb_type != cb_base->type ||
if (!handler_in_other_thread) {
if (keep_private_thread) {
- if (cb_base->sync) {
+ if (cb_base->sync && waiting_tid != 0) {
waiting_tid = 0;
pthread_cond_signal(&keep_private_thread->event_cond);
if (tdm_debug_module & TDM_DEBUG_THREAD)
}
}
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");
}
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;
}
projects / platform / core / uifw / libtdm.git / blobdiff