void *user_data;
pid_t owner_tid;
- unsigned int called;
} tdm_private_thread_cb;
static tdm_thread_find_object find_funcs[TDM_THREAD_CB_MAX] = {0, };
-static struct list_head cb_list;
+
+/* 0: for display thread, 1: for tdm thread */
+static struct list_head cb_list[2];
+static pthread_mutex_t cb_list_lock = PTHREAD_MUTEX_INITIALIZER;
static void _tdm_thread_free_cb(tdm_private_thread_cb *cb);
{
tdm_private_display *private_display;
tdm_private_thread *private_thread;
- int thread;
+ int thread, i;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
TDM_RETURN_VAL_IF_FAIL(private_loop->dpy, TDM_ERROR_OPERATION_FAILED);
private_display = private_loop->dpy;
TDM_RETURN_VAL_IF_FAIL(private_display->private_loop, TDM_ERROR_OPERATION_FAILED);
- LIST_INITHEAD(&cb_list);
-
if (private_loop->private_thread)
return TDM_ERROR_NONE;
+ for (i = 0; i < TDM_THREAD_CB_MAX; i++)
+ find_funcs[i] = NULL;
+
+ LIST_INITHEAD(&cb_list[0]);
+ LIST_INITHEAD(&cb_list[1]);
+
/* enable as default */
thread = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_THREAD, 1);
if (!thread) {
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;
tdm_log_reset();
- LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list, link) {
+ LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list[0], link) {
+ _tdm_thread_free_cb(cb);
+ }
+ LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list[1], link) {
_tdm_thread_free_cb(cb);
}
private_loop->private_thread = NULL;
keep_private_thread = NULL;
- for (i = 0; i < TDM_THREAD_CB_MAX; i++)
- find_funcs[i] = NULL;
-
TDM_INFO("Finish a TDM event thread");
}
pipe = private_thread->pipe[1];
if (tdm_debug_module & TDM_DEBUG_THREAD)
- TDM_INFO("fd(%d) type(%d), length(%d)", pipe, base->type, base->length);
+ TDM_INFO("fd(%d) type(%s), length(%d)", pipe, tdm_cb_type_str(base->type), base->length);
len = write(pipe, base, base->length);
if (len != base->length) {
char buffer[1024];
unsigned int i;
int len, pipe, in_main;
+ tdm_error ret = TDM_ERROR_NONE;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
TDM_RETURN_VAL_IF_FAIL(private_loop, TDM_ERROR_INVALID_PARAMETER);
while (i < len) {
base = (tdm_thread_cb_base*)&buffer[i];
if (tdm_debug_module & TDM_DEBUG_THREAD)
- TDM_INFO("type(%d), length(%d)", base->type, base->length);
+ TDM_INFO("type(%s), length(%d)", tdm_cb_type_str(base->type), base->length);
switch (base->type) {
- case TDM_THREAD_CB_OUTPUT_COMMIT: {
- tdm_thread_cb_output_commit *output_commit = (tdm_thread_cb_output_commit*)base;
- tdm_output *output_backend =
- tdm_display_find_output_stamp(private_loop->dpy, output_commit->output_stamp);
- if (!output_backend) {
- TDM_WRN("no output(%f)", output_commit->output_stamp);
- break;
- }
- tdm_output_cb_commit(output_backend, output_commit->sequence,
- output_commit->tv_sec, output_commit->tv_usec,
- output_commit->user_data);
- break;
- }
- case TDM_THREAD_CB_OUTPUT_VBLANK: {
- tdm_thread_cb_output_vblank *output_vblank = (tdm_thread_cb_output_vblank*)base;
- tdm_output *output_backend =
- tdm_display_find_output_stamp(private_loop->dpy, output_vblank->output_stamp);
- if (!output_backend) {
- TDM_WRN("no output(%f)", output_vblank->output_stamp);
- break;
- }
- tdm_output_cb_vblank(output_backend, output_vblank->sequence,
- output_vblank->tv_sec, output_vblank->tv_usec,
- output_vblank->user_data);
+ 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_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);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
break;
- }
- case TDM_THREAD_CB_OUTPUT_STATUS: {
- /* LCOV_EXCL_START */
- tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status*)base;
- tdm_output *output_backend =
- tdm_display_find_output_stamp(private_loop->dpy, output_status->output_stamp);
- if (!output_backend) {
- TDM_WRN("no output(%f)", output_status->output_stamp);
- break;
- }
- tdm_output_cb_status(output_backend, output_status->status,
- output_status->user_data);
- break;
- /* LCOV_EXCL_STOP */
- }
- case TDM_THREAD_CB_OUTPUT_DPMS: {
- /* LCOV_EXCL_START */
- tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms*)base;
- tdm_output *output_backend =
- tdm_display_find_output_stamp(private_loop->dpy, output_dpms->output_stamp);
- if (!output_backend) {
- TDM_WRN("no output(%f)", output_dpms->output_stamp);
- break;
- }
- tdm_output_cb_dpms(output_backend, output_dpms->dpms, output_dpms->user_data);
- break;
- /* LCOV_EXCL_STOP */
- }
- case TDM_THREAD_CB_PP_DONE: {
- tdm_thread_cb_pp_done *pp_done = (tdm_thread_cb_pp_done*)base;
- tdm_pp *pp_backend =
- tdm_pp_find_stamp(private_loop->dpy, pp_done->pp_stamp);
- if (!pp_backend) {
- TDM_WRN("no pp(%f)", pp_done->pp_stamp);
- break;
- }
- tdm_pp_cb_done(pp_backend, pp_done->src, pp_done->dst, pp_done->user_data);
- break;
- }
- case TDM_THREAD_CB_CAPTURE_DONE: {
- tdm_thread_cb_capture_done *capture_done = (tdm_thread_cb_capture_done*)base;
- tdm_capture *capture_backend =
- tdm_capture_find_stamp(private_loop->dpy, capture_done->capture_stamp);
- if (!capture_backend) {
- TDM_WRN("no capture(%f)", capture_done->capture_stamp);
- break;
- }
- tdm_capture_cb_done(capture_backend, capture_done->buffer, capture_done->user_data);
- break;
- }
- case TDM_THREAD_CB_VBLANK_SW: {
- tdm_thread_cb_vblank_sw *vblank_sw = (tdm_thread_cb_vblank_sw*)base;
- tdm_vblank_cb_vblank_SW(NULL, vblank_sw->vblank_stamp);
- break;
- }
- case TDM_THREAD_CB_VBLANK_CREATE: {
- tdm_thread_cb_vblank_create *vblank_create = (tdm_thread_cb_vblank_create*)base;
- tdm_vblank_cb_vblank_create(NULL, vblank_create->vblank_stamp);
- break;
- }
- case TDM_THREAD_CB_NEED_VALIDATE: {
- tdm_thread_cb_need_validate *ev = (tdm_thread_cb_need_validate*)base;
- tdm_output_cb_need_validate(ev->o);
- break;
- }
default:
break;
}
}
static tdm_private_thread_cb *
-_tdm_thread_find_cb(void *object, tdm_thread_cb_type cb_type, void *cb_data, tdm_thread_cb func, void *user_data, pid_t owner_tid)
+_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)
{
tdm_private_thread_cb *cb = NULL;
- LIST_FOR_EACH_ENTRY(cb, &cb_list, link) {
+ LIST_FOR_EACH_ENTRY(cb, list, link) {
if (cb->object == object &&
cb->cb_type == cb_type &&
cb->cb_data == cb_data &&
cb->func == func &&
cb->user_data == user_data &&
- cb->owner_tid == owner_tid)
+ cb->owner_tid == caller_tid)
return cb;
}
return NULL;
}
-static void
-_tdm_thread_reset_cb(tdm_thread_cb_type cb_type)
-{
- tdm_private_thread_cb *cb = NULL;
-
- LIST_FOR_EACH_ENTRY(cb, &cb_list, link) {
- if (cb->cb_type == cb_type)
- cb->called = 0;
- }
-}
-
INTERN void
tdm_thread_cb_set_find_func(tdm_thread_cb_type cb_type, tdm_thread_find_object func)
{
{
tdm_private_thread_cb *cb = NULL;
pid_t caller_tid;
+ struct list_head *list;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
TDM_RETURN_VAL_IF_FAIL(object != NULL, TDM_ERROR_INVALID_PARAMETER);
caller_tid = syscall(SYS_gettid);
- cb = _tdm_thread_find_cb(object, cb_type, cb_data, func, user_data, caller_tid);
+ pthread_mutex_lock(&cb_list_lock);
+
+ if (tdm_thread_in_display_thread(caller_tid))
+ list = &cb_list[0];
+ else
+ list = &cb_list[1];
+
+ cb = _tdm_thread_find_cb(list, object, cb_type, cb_data, func, user_data, caller_tid);
if (cb) {
+ pthread_mutex_unlock(&cb_list_lock);
TDM_ERR("can't be added twice with same data");
-#if 1
- assert(0);
-#endif
return TDM_ERROR_BAD_REQUEST;
}
cb = calloc(1, sizeof *cb);
if (!cb) {
+ pthread_mutex_unlock(&cb_list_lock);
TDM_ERR("calloc failed");
return TDM_ERROR_OUT_OF_MEMORY;
}
- LIST_ADDTAIL(&cb->link, &cb_list);
+ LIST_ADDTAIL(&cb->link, list);
LIST_INITHEAD(&cb->call_link);
cb->object = object;
cb->owner_tid = caller_tid;
if (tdm_debug_module & TDM_DEBUG_THREAD)
- TDM_INFO("cb_type(%d) cb(%p) added", cb_type, cb);
+ TDM_INFO("cb_type(%s) cb(%p) added", tdm_cb_type_str(cb_type), cb);
+
+ pthread_mutex_unlock(&cb_list_lock);
return TDM_ERROR_NONE;
}
{
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(object != NULL);
caller_tid = syscall(SYS_gettid);
- cb = _tdm_thread_find_cb(object, cb_type, cb_data, func, user_data, caller_tid);
- if (!cb)
+ pthread_mutex_lock(&cb_list_lock);
+
+ if (tdm_thread_in_display_thread(caller_tid))
+ list = &cb_list[0];
+ else
+ list = &cb_list[1];
+
+ 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;
+ }
_tdm_thread_free_cb(cb);
+ pthread_mutex_unlock(&cb_list_lock);
}
/* when call a callback, we check both cb_base's type and cb_base's data,
tdm_private_thread_cb *cb = NULL, *hh = NULL;
int handler_in_other_thread = 0;
pid_t caller_tid;
+ 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);
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);
+ }
+
if (!object) {
object = find_funcs[cb_base->type](private_display, cb_base->object_stamp);
if (!object) {
}
}
+ pthread_mutex_lock(&cb_list_lock);
+
+ if (tdm_thread_in_display_thread(caller_tid)) {
+ list = &cb_list[0];
+ other_list = &cb_list[1];
+ } else {
+ other_list = &cb_list[0];
+ list = &cb_list[1];
+ }
+
LIST_INITHEAD(&call_list);
- LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &cb_list, link) {
- if (cb->called ||
- cb->object != object ||
+ LIST_FOR_EACH_ENTRY_SAFE(cb, hh, list, link) {
+ if (cb->object != object ||
cb->cb_type != cb_base->type ||
cb->cb_data != cb_base->data)
continue;
- if (cb->owner_tid == caller_tid)
- LIST_ADDTAIL(&cb->call_link, &call_list);
- else
- handler_in_other_thread = 1;
+ LIST_ADDTAIL(&cb->call_link, &call_list);
}
if (!LIST_IS_EMPTY(&call_list)) {
LIST_FOR_EACH_ENTRY_SAFE(cb, hh, &call_list, call_link) {
LIST_DELINIT(&cb->call_link);
- cb->called = 1;
if (tdm_debug_module & TDM_DEBUG_THREAD)
- TDM_INFO("cb_type(%d) cb(%p) called", cb->cb_type, cb);
+ TDM_INFO("cb_type(%s) cb(%p) calling", tdm_cb_type_str(cb->cb_type), cb);
+ pthread_mutex_unlock(&cb_list_lock);
cb->func(private_display, cb->object, cb_base, cb->user_data);
+ pthread_mutex_lock(&cb_list_lock);
}
}
+ pthread_mutex_unlock(&cb_list_lock);
+
assert(LIST_IS_EMPTY(&call_list));
+ if (waiting_tid == 0 || waiting_cb_type != cb_base->type) {
+ LIST_FOR_EACH_ENTRY_SAFE(cb, hh, other_list, link) {
+ if (cb->object != object ||
+ cb->cb_type != cb_base->type ||
+ cb->cb_data != cb_base->data)
+ continue;
+
+ handler_in_other_thread = 1;
+ break;
+ }
+ }
+
if (!handler_in_other_thread) {
- _tdm_thread_reset_cb(cb_base->type);
if (keep_private_thread) {
if (cb_base->sync) {
+ 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");
* the mutex shall have been locked and shall be owned by the calling thread
*/
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;
}