1 /**************************************************************************
5 * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
7 * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
8 * JinYoung Jeon <jy0.jeon@samsung.com>,
9 * Taeheon Kim <th908.kim@samsung.com>,
10 * YoungJun Cho <yj44.cho@samsung.com>,
11 * SooChan Lim <sc1.lim@samsung.com>,
12 * Boram Park <boram1288.park@samsung.com>
14 * Permission is hereby granted, free of charge, to any person obtaining a
15 * copy of this software and associated documentation files (the
16 * "Software"), to deal in the Software without restriction, including
17 * without limitation the rights to use, copy, modify, merge, publish,
18 * distribute, sub license, and/or sell copies of the Software, and to
19 * permit persons to whom the Software is furnished to do so, subject to
20 * the following conditions:
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
27 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
29 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
30 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
31 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
32 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 **************************************************************************/
40 #include "tdm_private.h"
42 typedef struct _tdm_event_loop_source_base {
43 struct list_head link;
44 tdm_private_display *private_display;
45 struct wl_event_source *wl_source;
46 } tdm_event_loop_source_base;
48 typedef struct _tdm_event_loop_source_fd {
49 tdm_event_loop_source_base base;
50 tdm_event_loop_fd_handler func;
52 } tdm_event_loop_source_fd;
54 typedef struct _tdm_event_loop_source_timer {
55 tdm_event_loop_source_base base;
56 tdm_event_loop_timer_handler func;
58 } tdm_event_loop_source_timer;
60 static tdm_private_loop *keep_private_loop;
63 _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_data)
65 tdm_private_module *private_module = (tdm_private_module*)user_data;
66 tdm_func_display *func_display;
69 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
70 TDM_RETURN_VAL_IF_FAIL(private_module != NULL, TDM_ERROR_OPERATION_FAILED);
72 if (tdm_debug_module & TDM_DEBUG_EVENT)
73 TDM_INFO("backend fd(%d) event happens", private_module->fd);
75 func_display = &private_module->func_display;
76 if (!func_display->display_handle_events)
77 return TDM_ERROR_NONE;
79 ret = func_display->display_handle_events(private_module->bdata);
85 tdm_event_loop_init(tdm_private_display *private_display)
87 tdm_private_loop *private_loop;
90 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
92 if (private_display->private_loop)
93 return TDM_ERROR_NONE;
95 private_loop = calloc(1, sizeof * private_loop);
97 TDM_ERR("alloc failed");
98 return TDM_ERROR_OUT_OF_MEMORY;
101 private_loop->wl_display = wl_display_create();
102 if (!private_loop->wl_display) {
103 TDM_ERR("creating a wayland display failed");
105 return TDM_ERROR_OUT_OF_MEMORY;
107 private_loop->wl_loop = wl_display_get_event_loop(private_loop->wl_display);
109 ret = tdm_server_init(private_loop);
110 if (ret != TDM_ERROR_NONE) {
111 TDM_ERR("server init failed");
112 wl_display_destroy(private_loop->wl_display);
114 return TDM_ERROR_OPERATION_FAILED;
117 LIST_INITHEAD(&private_loop->source_list);
119 private_loop->dpy = private_display;
120 private_display->private_loop = private_loop;
122 ret = tdm_thread_init(private_loop);
123 if (ret != TDM_ERROR_NONE) {
124 TDM_ERR("thread init failed");
125 tdm_server_deinit(private_loop);
126 wl_display_destroy(private_loop->wl_display);
128 return TDM_ERROR_OPERATION_FAILED;
131 keep_private_loop = private_loop;
133 TDM_INFO("event loop fd(%d)", wl_event_loop_get_fd(private_loop->wl_loop));
135 return TDM_ERROR_NONE;
139 tdm_event_loop_deinit(tdm_private_display *private_display)
141 tdm_private_module *private_module = NULL;
142 tdm_event_loop_source_base *source = NULL, *ss = NULL;
144 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
146 if (!private_display->private_loop)
149 if (tdm_thread_is_running())
150 TDM_ERR("thread is still running. tdm_event_loop_stop SHOULD be called");
152 tdm_server_deinit(private_display->private_loop);
154 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
155 if (private_module->event_source)
156 tdm_event_loop_source_remove(private_module->event_source);
157 private_module->event_source = NULL;
158 private_module->fd = -1;
161 LIST_FOR_EACH_ENTRY_SAFE(source, ss, &private_display->private_loop->source_list, link) {
162 tdm_event_loop_source_remove(source);
165 wl_display_destroy(private_display->private_loop->wl_display);
167 free(private_display->private_loop);
168 private_display->private_loop = NULL;
169 keep_private_loop = NULL;
171 TDM_INFO("event loop deinit done");
175 tdm_event_loop_stop(tdm_private_display *private_display)
177 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
179 /* after tdm_thread_deinit, we don't worry about thread things because it's finalized */
180 tdm_thread_deinit(private_display->private_loop);
184 tdm_event_loop_create_backend_source(tdm_private_display *private_display)
186 tdm_private_loop *private_loop = private_display->private_loop;
187 tdm_private_module *private_module = NULL;
191 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
192 TDM_RETURN_IF_FAIL(private_loop != NULL);
194 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
195 tdm_func_display *func_display = &private_module->func_display;
197 if (!func_display->display_get_fd) {
198 TDM_INFO("TDM backend module won't offer a display fd");
199 private_module->event_source = NULL;
200 private_module->fd = -1;
204 ret = func_display->display_get_fd(private_module->bdata, &fd);
206 assert(ret == TDM_ERROR_NONE && fd >= 0);
207 assert(func_display->display_handle_events);
209 private_module->event_source =
210 tdm_event_loop_add_fd_handler(private_display, fd,
211 TDM_EVENT_LOOP_READABLE,
212 _tdm_event_loop_main_fd_handler,
213 private_module, &ret);
214 if (!private_module->event_source) {
215 TDM_ERR("no backend fd(%d) source", fd);
219 private_module->fd = fd;
221 TDM_INFO("backend fd(%d) source created", private_module->fd);
226 tdm_event_loop_get_fd(tdm_private_display *private_display)
228 tdm_private_loop *private_loop = private_display->private_loop;
230 /* DON'T check TDM_MUTEX_IS_LOCKED here */
232 TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, -1);
234 return wl_event_loop_get_fd(private_loop->wl_loop);
238 tdm_event_loop_dispatch(tdm_private_display *private_display)
240 tdm_private_loop *private_loop = private_display->private_loop;
242 /* DON'T check TDM_MUTEX_IS_LOCKED here */
244 TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, TDM_ERROR_OPERATION_FAILED);
246 if (tdm_debug_module & TDM_DEBUG_EVENT)
247 TDM_INFO("dispatch");
249 if (tdm_thread_is_running() &&
250 tdm_thread_in_display_thread(syscall(SYS_gettid))) {
251 TDM_NEVER_GET_HERE();
252 return TDM_ERROR_OPERATION_FAILED;
255 /* Don't set timeout to -1. It can make deadblock by two mutex locks.
256 * If need to set -1, use poll() and call tdm_event_loop_dispatch() after
259 if (wl_event_loop_dispatch(private_loop->wl_loop, 0) < 0)
260 TDM_ERR("dispatch failed");
262 wl_display_flush_clients(private_loop->wl_display);
264 return TDM_ERROR_NONE;
269 tdm_event_loop_flush(tdm_private_display *private_display)
271 tdm_private_loop *private_loop = private_display->private_loop;
273 /* DON'T check TDM_MUTEX_IS_LOCKED here */
275 TDM_RETURN_IF_FAIL(private_loop->wl_display != NULL);
277 if (tdm_thread_is_running() &&
278 tdm_thread_in_display_thread(syscall(SYS_gettid))) {
279 TDM_NEVER_GET_HERE();
283 wl_display_flush_clients(private_loop->wl_display);
287 _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data)
289 tdm_event_loop_source_fd *fd_source = (tdm_event_loop_source_fd*)data;
290 tdm_private_display *private_display;
291 tdm_event_loop_mask mask = 0;
293 /* DON'T check TDM_MUTEX_IS_LOCKED here */
295 TDM_RETURN_VAL_IF_FAIL(fd_source, 1);
296 TDM_RETURN_VAL_IF_FAIL(fd_source->func, 1);
298 private_display = fd_source->base.private_display;
300 if (wl_mask & WL_EVENT_READABLE)
301 mask |= TDM_EVENT_LOOP_READABLE;
302 if (wl_mask & WL_EVENT_WRITABLE)
303 mask |= TDM_EVENT_LOOP_WRITABLE;
304 if (wl_mask & WL_EVENT_HANGUP)
305 mask |= TDM_EVENT_LOOP_HANGUP;
306 if (wl_mask & WL_EVENT_ERROR)
307 mask |= TDM_EVENT_LOOP_ERROR;
309 _pthread_mutex_lock(&private_display->lock);
310 fd_source->func(fd, mask, fd_source->user_data);
311 _pthread_mutex_unlock(&private_display->lock);
316 EXTERN tdm_event_loop_source *
317 tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask mask,
318 tdm_event_loop_fd_handler func, void *user_data,
321 tdm_private_display *private_display;
322 tdm_private_loop *private_loop;
323 tdm_event_loop_source_fd *fd_source;
324 uint32_t wl_mask = 0;
327 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED, NULL);
328 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL);
329 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd >= 0, TDM_ERROR_INVALID_PARAMETER, NULL);
330 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL);
332 private_display = (tdm_private_display*)dpy;
333 private_loop = private_display->private_loop;
334 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_loop, TDM_ERROR_INVALID_PARAMETER, NULL);
335 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_loop->wl_loop, TDM_ERROR_INVALID_PARAMETER, NULL);
337 fd_source = calloc(1, sizeof(tdm_event_loop_source_fd));
338 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd_source, TDM_ERROR_OUT_OF_MEMORY, NULL);
340 if (mask & TDM_EVENT_LOOP_READABLE)
341 wl_mask |= WL_EVENT_READABLE;
342 if (mask & TDM_EVENT_LOOP_WRITABLE)
343 wl_mask |= WL_EVENT_WRITABLE;
345 fd_source->func = func;
346 fd_source->user_data = user_data;
348 fd_source->base.private_display = private_display;
349 fd_source->base.wl_source =
350 wl_event_loop_add_fd(private_loop->wl_loop,
351 fd, wl_mask, _tdm_event_loop_fd_func, fd_source);
352 if (!fd_source->base.wl_source) {
354 *error = TDM_ERROR_OUT_OF_MEMORY;
359 LIST_ADDTAIL(&fd_source->base.link, &private_loop->source_list);
362 *error = TDM_ERROR_NONE;
364 return (tdm_event_loop_source *)fd_source;
368 tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_mask mask)
370 tdm_event_loop_source_fd *fd_source = source;
371 uint32_t wl_mask = 0;
373 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
374 TDM_RETURN_VAL_IF_FAIL(fd_source, TDM_ERROR_INVALID_PARAMETER);
376 if (mask & TDM_EVENT_LOOP_READABLE)
377 wl_mask |= WL_EVENT_READABLE;
378 if (mask & TDM_EVENT_LOOP_WRITABLE)
379 wl_mask |= WL_EVENT_WRITABLE;
381 if (wl_event_source_fd_update(fd_source->base.wl_source, wl_mask) < 0) {
382 TDM_ERR("source update failed: %m");
383 return TDM_ERROR_OPERATION_FAILED;
386 return TDM_ERROR_NONE;
390 _tdm_event_loop_timer_func(void *data)
392 tdm_event_loop_source_timer *timer_source = (tdm_event_loop_source_timer*)data;
393 tdm_private_display *private_display;
395 /* DON'T check TDM_MUTEX_IS_LOCKED here */
397 TDM_RETURN_VAL_IF_FAIL(timer_source, 1);
398 TDM_RETURN_VAL_IF_FAIL(timer_source->func, 1);
400 private_display = timer_source->base.private_display;
402 /* TDM event_loop function is actually for TDM backend module. When we call the
403 * backend's functions, we have to lock the mutex. TDM backend shouldn't consider
406 _pthread_mutex_lock(&private_display->lock);
407 timer_source->func(timer_source->user_data);
408 _pthread_mutex_unlock(&private_display->lock);
413 EXTERN tdm_event_loop_source *
414 tdm_event_loop_add_timer_handler(tdm_display *dpy, tdm_event_loop_timer_handler func,
415 void *user_data, tdm_error *error)
417 tdm_private_display *private_display;
418 tdm_private_loop *private_loop;
419 tdm_event_loop_source_timer *timer_source;
422 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED, NULL);
423 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL);
424 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL);
426 private_display = (tdm_private_display*)dpy;
427 private_loop = private_display->private_loop;
428 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_loop, TDM_ERROR_INVALID_PARAMETER, NULL);
429 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_loop->wl_loop, TDM_ERROR_INVALID_PARAMETER, NULL);
431 timer_source = calloc(1, sizeof(tdm_event_loop_source_timer));
432 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(timer_source, TDM_ERROR_OUT_OF_MEMORY, NULL);
434 timer_source->func = func;
435 timer_source->user_data = user_data;
437 timer_source->base.private_display = private_display;
438 timer_source->base.wl_source =
439 wl_event_loop_add_timer(private_loop->wl_loop,
440 _tdm_event_loop_timer_func, timer_source);
441 if (!timer_source->base.wl_source) {
443 *error = TDM_ERROR_OUT_OF_MEMORY;
448 LIST_ADDTAIL(&timer_source->base.link, &private_loop->source_list);
451 *error = TDM_ERROR_NONE;
453 return (tdm_event_loop_source *)timer_source;
457 tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int ms_delay)
459 tdm_event_loop_source_timer *timer_source = source;
461 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
462 TDM_RETURN_VAL_IF_FAIL(timer_source, TDM_ERROR_INVALID_PARAMETER);
464 if (wl_event_source_timer_update(timer_source->base.wl_source, ms_delay) < 0) {
465 TDM_ERR("source update failed: %m");
466 return TDM_ERROR_OPERATION_FAILED;
469 return TDM_ERROR_NONE;
473 tdm_event_loop_source_remove(tdm_event_loop_source *source)
475 tdm_event_loop_source_base *base = (tdm_event_loop_source_base*)source;
477 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
479 if (!base || !keep_private_loop)
482 LIST_DEL(&base->link);
484 wl_event_source_remove(base->wl_source);
489 /* LCOV_EXCL_START */
491 _trace_cb_client_destroy(struct wl_listener *listener, void *data)
493 struct wl_client *client = (struct wl_client *) data;
497 const char *proc_name;
498 char temp[512] = { 0, }, *p = temp;
499 int len = sizeof(temp), *l = &len;
501 wl_client_get_credentials(client, &pid, NULL, NULL);
502 proc_name = tdm_server_get_client_name(pid);
504 clock_gettime(CLOCK_MONOTONIC, &tp);
505 time = (tp.tv_sec * 1000000L) + (tp.tv_nsec / 1000);
507 TDM_SNPRINTF(p, l, "[%10.3f] Server [PID:%d] client destroying", time / 1000.0, pid);
508 TDM_SNPRINTF(p, l, ", cmd: %s", proc_name ? proc_name : "Unknown");
510 TDM_INFO("%s", temp);
512 wl_list_remove(&listener->link);
517 _trace_reg_client_destroy_listener(struct wl_client *client)
519 struct wl_listener *listener;
521 listener = wl_client_get_destroy_listener(client, _trace_cb_client_destroy);
525 listener = calloc(1, sizeof(struct wl_listener));
526 TDM_RETURN_IF_FAIL(listener != NULL);
528 listener->notify = _trace_cb_client_destroy;
529 wl_client_add_destroy_listener(client, listener);
533 _trace_get_next_argument(const char *signature,
534 struct argument_details *details)
536 details->nullable = 0;
537 for (; *signature; ++signature) {
538 switch (*signature) {
547 details->type = *signature;
548 return signature + 1;
550 details->nullable = 1;
556 details->type = '\0';
560 static struct wl_protocol_logger *_trace_protocol_logger;
563 _trace_protocol_logger_cb(void *user_data,
564 enum wl_protocol_logger_type direction,
565 const struct wl_protocol_logger_message *message)
568 struct argument_details arg;
569 struct wl_client *client = wl_resource_get_client(message->resource);
570 const char *signature = message->message->signature;
574 const char *proc_name;
575 char temp[512] = { 0, }, *p = temp;
576 int len = sizeof(temp), *l = &len;
580 _trace_reg_client_destroy_listener(client);
581 wl_client_get_credentials(client, &pid, NULL, NULL);
584 proc_name = tdm_server_get_client_name(pid);
586 clock_gettime(CLOCK_MONOTONIC, &tp);
587 time = (tp.tv_sec * 1000000L) + (tp.tv_nsec / 1000);
589 send = (direction == WL_PROTOCOL_LOGGER_EVENT) ? 1 : 0;
591 TDM_SNPRINTF(p, l, "[%10.3f] %s%d%s%s@%u.%s(",
593 send ? "Server -> Client [PID:" : "Server <- Client [PID:",
595 wl_resource_get_class(message->resource),
596 wl_resource_get_id(message->resource),
597 message->message->name);
599 for (i = 0; i < message->arguments_count; i++) {
600 signature = _trace_get_next_argument(signature, &arg);
601 TDM_RETURN_IF_FAIL(signature != NULL);
604 TDM_SNPRINTF(p, l, ", ");
608 TDM_SNPRINTF(p, l, "%u", message->arguments[i].u);
611 TDM_SNPRINTF(p, l, "%d", message->arguments[i].i);
614 TDM_SNPRINTF(p, l, "%f",
615 wl_fixed_to_double(message->arguments[i].f));
618 TDM_SNPRINTF(p, l, "\"%s\"", message->arguments[i].s);
621 if (message->arguments[i].o)
622 TDM_SNPRINTF(p, l, "%s@%u",
623 wl_resource_get_class((struct wl_resource *) message->arguments[i].o),
624 wl_resource_get_id((struct wl_resource *) message->arguments[i].o));
626 TDM_SNPRINTF(p, l, "nil");
629 TDM_SNPRINTF(p, l, "new id %s@",
630 (message->message->types[i]) ? message->message->types[i]->name : "[unknown]");
631 if (message->arguments[i].n != 0)
632 TDM_SNPRINTF(p, l, "%u", message->arguments[i].n);
634 TDM_SNPRINTF(p, l, "nil");
637 TDM_SNPRINTF(p, l, "array");
640 TDM_SNPRINTF(p, l, "fd %d", message->arguments[i].h);
647 TDM_SNPRINTF(p, l, "), cmd: %s", proc_name ? proc_name : "Unknown");
649 TDM_INFO("%s", temp);
653 tdm_event_loop_trace_enable(tdm_private_display * private_display,
656 tdm_private_loop *private_loop = private_display->private_loop;
658 TDM_RETURN_VAL_IF_FAIL(private_loop->wl_display != NULL, TDM_ERROR_NONE);
661 if (_trace_protocol_logger) {
662 wl_protocol_logger_destroy(_trace_protocol_logger);
663 _trace_protocol_logger = NULL;
665 return TDM_ERROR_NONE;
668 if (_trace_protocol_logger)
669 wl_protocol_logger_destroy(_trace_protocol_logger);
671 _trace_protocol_logger =
672 wl_display_add_protocol_logger(private_loop->wl_display, _trace_protocol_logger_cb, NULL);
674 return TDM_ERROR_NONE;