change input param's type

[platform/core/uifw/libtdm.git] / src / tdm_event_loop.c

diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c
index e2beaf7..d1eb6ea 100644 (file)
--- a/src/tdm_event_loop.c
+++ b/src/tdm_event_loop.c
@@ -43,14 +43,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <wayland-server-core.h>
 
-struct _tdm_private_loop {
-       struct wl_display *wl_display;
-       struct wl_event_loop *wl_loop;
-
-       int backend_fd;
-       tdm_event_loop_source *backend_source;
-};
-
 typedef struct _tdm_event_loop_source_base
 {
        struct wl_event_source *wl_source;
@@ -78,7 +70,9 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat
        tdm_private_display *private_display = (tdm_private_display*)user_data;
        tdm_private_loop *private_loop;
        tdm_func_display *func_display;
+       tdm_error ret;
 
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(private_display != NULL, TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(private_display->private_loop != NULL, TDM_ERROR_OPERATION_FAILED);
 
@@ -91,13 +85,18 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat
        if (!func_display->display_handle_events)
                return TDM_ERROR_NONE;
 
-       return func_display->display_handle_events(private_display->bdata);
+       ret = func_display->display_handle_events(private_display->bdata);
+
+       return ret;
 }
 
 INTERN tdm_error
 tdm_event_loop_init(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop;
+       tdm_error ret;
+
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
 
        if (private_display->private_loop)
                return TDM_ERROR_NONE;
@@ -116,28 +115,44 @@ tdm_event_loop_init(tdm_private_display *private_display)
                free(private_loop);
                return TDM_ERROR_OUT_OF_MEMORY;
        }
-
        private_loop->wl_loop = wl_display_get_event_loop(private_loop->wl_display);
-       if (!private_loop->wl_loop) {
-               TDM_ERR("no event loop");
+
+       ret = tdm_server_init(private_loop);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("server init failed");
                wl_display_destroy(private_loop->wl_display);
                free(private_loop);
-               return TDM_ERROR_OUT_OF_MEMORY;
+               return TDM_ERROR_OPERATION_FAILED;
        }
 
-       TDM_INFO("event loop fd(%d)", wl_event_loop_get_fd(private_loop->wl_loop));
-
+       private_loop->dpy = private_display;
        private_display->private_loop = private_loop;
 
+       ret = tdm_thread_init(private_loop);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("thread init failed");
+               tdm_server_deinit(private_loop);
+               wl_display_destroy(private_loop->wl_display);
+               free(private_loop);
+               return TDM_ERROR_OPERATION_FAILED;
+       }
+
+       TDM_INFO("event loop fd(%d)", wl_event_loop_get_fd(private_loop->wl_loop));
+
        return TDM_ERROR_NONE;
 }
 
 INTERN void
 tdm_event_loop_deinit(tdm_private_display *private_display)
 {
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
        if (!private_display->private_loop)
                return;
 
+       tdm_thread_deinit(private_display->private_loop);
+       tdm_server_deinit(private_display->private_loop);
+
        if (private_display->private_loop->backend_source)
                tdm_event_loop_source_remove(private_display->private_loop->backend_source);
 
@@ -156,6 +171,7 @@ tdm_event_loop_create_backend_source(tdm_private_display *private_display)
        tdm_error ret;
        int fd = -1;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
        TDM_RETURN_IF_FAIL(private_loop != NULL);
 
        func_display = &private_display->func_display;
@@ -166,7 +182,7 @@ tdm_event_loop_create_backend_source(tdm_private_display *private_display)
 
        ret = func_display->display_get_fd(private_display->bdata, &fd);
        if (fd < 0) {
-               TDM_WRN("TDM backend module returns fd(%d)", fd);
+               TDM_ERR("TDM backend module returns fd(%d)", fd);
                return;
        }
 
@@ -195,6 +211,8 @@ tdm_event_loop_get_fd(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop = private_display->private_loop;
 
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
+
        TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, -1);
 
        return wl_event_loop_get_fd(private_loop->wl_loop);
@@ -205,11 +223,19 @@ tdm_event_loop_dispatch(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop = private_display->private_loop;
 
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
+
        TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, TDM_ERROR_OPERATION_FAILED);
 
        if (tdm_debug_thread)
                TDM_INFO("dispatch");
 
+       if (tdm_thread_is_running() &&
+           tdm_thread_in_display_thread(syscall(SYS_gettid))) {
+               TDM_NEVER_GET_HERE();
+               return TDM_ERROR_OPERATION_FAILED;
+       }
+
        /* Don't set timeout to -1. It can make deadblock by two mutex locks.
         * If need to set -1, use poll() and call tdm_event_loop_dispatch() after
         * escaping polling.
@@ -217,33 +243,44 @@ tdm_event_loop_dispatch(tdm_private_display *private_display)
        if (wl_event_loop_dispatch(private_loop->wl_loop, 0) < 0)
                TDM_ERR("dispatch failed");
 
+       wl_display_flush_clients(private_loop->wl_display);
+
        return TDM_ERROR_NONE;
 }
 
-INTERN tdm_error
-tdm_event_loop_add_socket(tdm_private_display *private_display, const char *name)
+
+INTERN void
+tdm_event_loop_flush(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop = private_display->private_loop;
 
-       TDM_RETURN_VAL_IF_FAIL(private_loop->wl_display != NULL, TDM_ERROR_OPERATION_FAILED);
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
 
-       if (wl_display_add_socket(private_loop->wl_display, name) < 0) {
-               TDM_ERR("add socket(\"%s\") failed", name);
-               return TDM_ERROR_OPERATION_FAILED;
+       TDM_RETURN_IF_FAIL(private_loop->wl_display != NULL);
+
+       if (tdm_thread_is_running() &&
+           tdm_thread_in_display_thread(syscall(SYS_gettid))) {
+               TDM_NEVER_GET_HERE();
+               return;
        }
 
-       return TDM_ERROR_NONE;
+       wl_display_flush_clients(private_loop->wl_display);
 }
 
 static int
 _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data)
 {
        tdm_event_loop_source_fd *fd_source = (tdm_event_loop_source_fd*)data;
+       tdm_private_display *private_display;
        tdm_event_loop_mask mask = 0;
 
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
+
        TDM_RETURN_VAL_IF_FAIL(fd_source, 1);
        TDM_RETURN_VAL_IF_FAIL(fd_source->func, 1);
 
+       private_display = fd_source->private_display;
+
        if (wl_mask & WL_EVENT_READABLE)
                mask |= TDM_EVENT_LOOP_READABLE;
        if (wl_mask & WL_EVENT_WRITABLE)
@@ -253,7 +290,9 @@ _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data)
        if (wl_mask & WL_EVENT_ERROR)
                mask |= TDM_EVENT_LOOP_ERROR;
 
+       _pthread_mutex_lock(&private_display->lock);
        fd_source->func(fd, mask, fd_source->user_data);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return 1;
 }
@@ -269,6 +308,7 @@ tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask mask
        uint32_t wl_mask = 0;
        tdm_error ret;
 
+       TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd >= 0, TDM_ERROR_INVALID_PARAMETER, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL);
@@ -312,6 +352,7 @@ tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_ma
        tdm_event_loop_source_fd *fd_source = source;
        uint32_t wl_mask = 0;
 
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(fd_source, TDM_ERROR_INVALID_PARAMETER);
 
        if (mask & TDM_EVENT_LOOP_READABLE)
@@ -331,11 +372,18 @@ static int
 _tdm_event_loop_timer_func(void *data)
 {
        tdm_event_loop_source_timer *timer_source = (tdm_event_loop_source_timer*)data;
+       tdm_private_display *private_display;
+
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
 
        TDM_RETURN_VAL_IF_FAIL(timer_source, 1);
        TDM_RETURN_VAL_IF_FAIL(timer_source->func, 1);
 
+       private_display = timer_source->private_display;
+
+       _pthread_mutex_lock(&private_display->lock);
        timer_source->func(timer_source->user_data);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return 1;
 }
@@ -349,6 +397,7 @@ tdm_event_loop_add_timer_handler(tdm_display *dpy, tdm_event_loop_timer_handler
        tdm_event_loop_source_timer *timer_source;
        tdm_error ret;
 
+       TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL);
 
@@ -381,10 +430,11 @@ tdm_event_loop_add_timer_handler(tdm_display *dpy, tdm_event_loop_timer_handler
 }
 
 EXTERN tdm_error
-tdm_event_loop_source_timer_update(tdm_event_loop_source *source, int ms_delay)
+tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int ms_delay)
 {
        tdm_event_loop_source_timer *timer_source = source;
 
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(timer_source, TDM_ERROR_INVALID_PARAMETER);
 
        if (wl_event_source_timer_update(timer_source->base.wl_source, ms_delay) < 0) {
@@ -400,6 +450,8 @@ tdm_event_loop_source_remove(tdm_event_loop_source *source)
 {
        tdm_event_loop_source_base *base = (tdm_event_loop_source_base*)source;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
        if (!base)
                return;