src/tdm_event_loop.c

   1 /**************************************************************************
   2  *
   3  * libtdm
   4  *
   5  * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   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 <sc1.lim@samsung.com>
  13  *
  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:
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  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.
  33  *
  34 **************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include "tdm_private.h"
  41
  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;
  47
  48 typedef struct _tdm_event_loop_source_fd {
  49         tdm_event_loop_source_base base;
  50         tdm_event_loop_fd_handler func;
  51         void *user_data;
  52 } tdm_event_loop_source_fd;
  53
  54 typedef struct _tdm_event_loop_source_timer {
  55         tdm_event_loop_source_base base;
  56         tdm_event_loop_timer_handler func;
  57         void *user_data;
  58 } tdm_event_loop_source_timer;
  59
  60 static tdm_private_loop *keep_private_loop;
  61
  62 static tdm_error
  63 _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_data)
  64 {
  65         tdm_private_module *private_module = (tdm_private_module*)user_data;
  66         tdm_func_display *func_display;
  67         tdm_error ret;
  68
  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);
  71
  72         if (tdm_debug_module & TDM_DEBUG_EVENT)
  73                 TDM_INFO("backend fd(%d) event happens", private_module->fd);
  74
  75         func_display = &private_module->func_display;
  76         if (!func_display->display_handle_events)
  77                 return TDM_ERROR_NONE;
  78
  79         ret = func_display->display_handle_events(private_module->bdata);
  80
  81         return ret;
  82 }
  83
  84 INTERN tdm_error
  85 tdm_event_loop_init(tdm_private_display *private_display)
  86 {
  87         tdm_private_loop *private_loop;
  88         tdm_error ret;
  89
  90         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
  91
  92         if (private_display->private_loop)
  93                 return TDM_ERROR_NONE;
  94
  95         private_loop = calloc(1, sizeof * private_loop);
  96         if (!private_loop) {
  97                 TDM_ERR("alloc failed");
  98                 return TDM_ERROR_OUT_OF_MEMORY;
  99         }
 100
 101         private_loop->wl_display = wl_display_create();
 102         if (!private_loop->wl_display) {
 103                 TDM_ERR("creating a wayland display failed");
 104                 free(private_loop);
 105                 return TDM_ERROR_OUT_OF_MEMORY;
 106         }
 107         private_loop->wl_loop = wl_display_get_event_loop(private_loop->wl_display);
 108
 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);
 113                 free(private_loop);
 114                 return TDM_ERROR_OPERATION_FAILED;
 115         }
 116
 117         LIST_INITHEAD(&private_loop->source_list);
 118
 119         private_loop->dpy = private_display;
 120         private_display->private_loop = private_loop;
 121
 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);
 127                 free(private_loop);
 128                 return TDM_ERROR_OPERATION_FAILED;
 129         }
 130
 131         keep_private_loop = private_loop;
 132
 133         TDM_INFO("event loop fd(%d)", wl_event_loop_get_fd(private_loop->wl_loop));
 134
 135         return TDM_ERROR_NONE;
 136 }
 137
 138 INTERN void
 139 tdm_event_loop_deinit(tdm_private_display *private_display)
 140 {
 141         tdm_private_module *private_module = NULL;
 142         tdm_event_loop_source_base *source = NULL, *ss = NULL;
 143
 144         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 145
 146         if (!private_display->private_loop)
 147                 return;
 148
 149         if (tdm_thread_is_running())
 150                 TDM_ERR("thread is still running. tdm_event_loop_stop SHOULD be called");
 151
 152         tdm_server_deinit(private_display->private_loop);
 153
 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;
 159         }
 160
 161         LIST_FOR_EACH_ENTRY_SAFE(source, ss, &private_display->private_loop->source_list, link) {
 162                 tdm_event_loop_source_remove(source);
 163         }
 164
 165         wl_display_destroy(private_display->private_loop->wl_display);
 166
 167         free(private_display->private_loop);
 168         private_display->private_loop = NULL;
 169         keep_private_loop = NULL;
 170
 171         TDM_INFO("event loop deinit done");
 172 }
 173
 174 INTERN void
 175 tdm_event_loop_stop(tdm_private_display *private_display)
 176 {
 177         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 178
 179         /* after tdm_thread_deinit, we don't worry about thread things because it's finalized */
 180         tdm_thread_deinit(private_display->private_loop);
 181 }
 182
 183 INTERN void
 184 tdm_event_loop_create_backend_source(tdm_private_display *private_display)
 185 {
 186         tdm_private_loop *private_loop = private_display->private_loop;
 187         tdm_private_module *private_module = NULL;
 188         tdm_error ret;
 189         int fd = -1;
 190
 191         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 192         TDM_RETURN_IF_FAIL(private_loop != NULL);
 193
 194         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 195                 tdm_func_display *func_display = &private_module->func_display;
 196
 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;
 201                         continue;
 202                 }
 203
 204                 ret = func_display->display_get_fd(private_module->bdata, &fd);
 205
 206                 assert(ret == TDM_ERROR_NONE && fd >= 0);
 207                 assert(func_display->display_handle_events);
 208
 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);
 216                         return;
 217                 }
 218
 219                 private_module->fd = fd;
 220
 221                 TDM_INFO("backend fd(%d) source created", private_module->fd);
 222         }
 223 }
 224
 225 INTERN int
 226 tdm_event_loop_get_fd(tdm_private_display *private_display)
 227 {
 228         tdm_private_loop *private_loop = private_display->private_loop;
 229
 230         /* DON'T check TDM_MUTEX_IS_LOCKED here */
 231
 232         TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, -1);
 233
 234         return wl_event_loop_get_fd(private_loop->wl_loop);
 235 }
 236
 237 INTERN tdm_error
 238 tdm_event_loop_dispatch(tdm_private_display *private_display)
 239 {
 240         tdm_private_loop *private_loop = private_display->private_loop;
 241
 242         /* DON'T check TDM_MUTEX_IS_LOCKED here */
 243
 244         TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, TDM_ERROR_OPERATION_FAILED);
 245
 246         if (tdm_debug_module & TDM_DEBUG_EVENT)
 247                 TDM_INFO("dispatch");
 248
 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;
 253         }
 254
 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
 257          * escaping polling.
 258          */
 259         if (wl_event_loop_dispatch(private_loop->wl_loop, 0) < 0)
 260                 TDM_ERR("dispatch failed");
 261
 262         wl_display_flush_clients(private_loop->wl_display);
 263
 264         return TDM_ERROR_NONE;
 265 }
 266
 267
 268 INTERN void
 269 tdm_event_loop_flush(tdm_private_display *private_display)
 270 {
 271         tdm_private_loop *private_loop = private_display->private_loop;
 272
 273         /* DON'T check TDM_MUTEX_IS_LOCKED here */
 274
 275         TDM_RETURN_IF_FAIL(private_loop->wl_display != NULL);
 276
 277         if (tdm_thread_is_running() &&
 278                 tdm_thread_in_display_thread(syscall(SYS_gettid))) {
 279                 TDM_NEVER_GET_HERE();
 280                 return;
 281         }
 282
 283         wl_display_flush_clients(private_loop->wl_display);
 284 }
 285
 286 static int
 287 _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data)
 288 {
 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;
 292
 293         /* DON'T check TDM_MUTEX_IS_LOCKED here */
 294
 295         TDM_RETURN_VAL_IF_FAIL(fd_source, 1);
 296         TDM_RETURN_VAL_IF_FAIL(fd_source->func, 1);
 297
 298         private_display = fd_source->base.private_display;
 299
 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;
 308
 309         _pthread_mutex_lock(&private_display->lock);
 310         fd_source->func(fd, mask, fd_source->user_data);
 311         _pthread_mutex_unlock(&private_display->lock);
 312
 313         return 1;
 314 }
 315
 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,
 319                                                           tdm_error *error)
 320 {
 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;
 325         tdm_error ret;
 326
 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);
 331
 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);
 336
 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);
 339
 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;
 344
 345         fd_source->func = func;
 346         fd_source->user_data = user_data;
 347
 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) {
 353                 if (error)
 354                         *error = TDM_ERROR_OUT_OF_MEMORY;
 355                 free(fd_source);
 356                 return NULL;
 357         }
 358
 359         LIST_ADDTAIL(&fd_source->base.link, &private_loop->source_list);
 360
 361         if (error)
 362                 *error = TDM_ERROR_NONE;
 363
 364         return (tdm_event_loop_source *)fd_source;
 365 }
 366
 367 EXTERN tdm_error
 368 tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_mask mask)
 369 {
 370         tdm_event_loop_source_fd *fd_source = source;
 371         uint32_t wl_mask = 0;
 372
 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);
 375
 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;
 380
 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;
 384         }
 385
 386         return TDM_ERROR_NONE;
 387 }
 388
 389 static int
 390 _tdm_event_loop_timer_func(void *data)
 391 {
 392         tdm_event_loop_source_timer *timer_source = (tdm_event_loop_source_timer*)data;
 393         tdm_private_display *private_display;
 394
 395         /* DON'T check TDM_MUTEX_IS_LOCKED here */
 396
 397         TDM_RETURN_VAL_IF_FAIL(timer_source, 1);
 398         TDM_RETURN_VAL_IF_FAIL(timer_source->func, 1);
 399
 400         private_display = timer_source->base.private_display;
 401
 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
 404          * mutex things.
 405          */
 406         _pthread_mutex_lock(&private_display->lock);
 407         timer_source->func(timer_source->user_data);
 408         _pthread_mutex_unlock(&private_display->lock);
 409
 410         return 1;
 411 }
 412
 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)
 416 {
 417         tdm_private_display *private_display;
 418         tdm_private_loop *private_loop;
 419         tdm_event_loop_source_timer *timer_source;
 420         tdm_error ret;
 421
 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);
 425
 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);
 430
 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);
 433
 434         timer_source->func = func;
 435         timer_source->user_data = user_data;
 436
 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) {
 442                 if (error)
 443                         *error = TDM_ERROR_OUT_OF_MEMORY;
 444                 free(timer_source);
 445                 return NULL;
 446         }
 447
 448         LIST_ADDTAIL(&timer_source->base.link, &private_loop->source_list);
 449
 450         if (error)
 451                 *error = TDM_ERROR_NONE;
 452
 453         return (tdm_event_loop_source *)timer_source;
 454 }
 455
 456 EXTERN tdm_error
 457 tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int ms_delay)
 458 {
 459         tdm_event_loop_source_timer *timer_source = source;
 460
 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);
 463
 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;
 467         }
 468
 469         return TDM_ERROR_NONE;
 470 }
 471
 472 EXTERN void
 473 tdm_event_loop_source_remove(tdm_event_loop_source *source)
 474 {
 475         tdm_event_loop_source_base *base = (tdm_event_loop_source_base*)source;
 476
 477         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 478
 479         if (!base || !keep_private_loop)
 480                 return;
 481
 482         LIST_DEL(&base->link);
 483
 484         wl_event_source_remove(base->wl_source);
 485
 486         free(source);
 487 }
 488
 489 /* LCOV_EXCL_START */
 490 static void
 491 _trace_cb_client_destroy(struct wl_listener *listener, void *data)
 492 {
 493         struct wl_client *client = (struct wl_client *) data;
 494         struct timespec tp;
 495         unsigned int time;
 496         pid_t pid = -1;
 497         const char *proc_name;
 498         char temp[512] = { 0, }, *p = temp;
 499         int len = sizeof(temp), *l = &len;
 500
 501         wl_client_get_credentials(client, &pid, NULL, NULL);
 502         proc_name = tdm_server_get_client_name(pid);
 503
 504         clock_gettime(CLOCK_MONOTONIC, &tp);
 505         time = (tp.tv_sec * 1000000L) + (tp.tv_nsec / 1000);
 506
 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");
 509
 510         TDM_INFO("%s", temp);
 511
 512         wl_list_remove(&listener->link);
 513         free(listener);
 514 }
 515
 516 static void
 517 _trace_reg_client_destroy_listener(struct wl_client *client)
 518 {
 519         struct wl_listener *listener;
 520
 521         listener = wl_client_get_destroy_listener(client, _trace_cb_client_destroy);
 522         if (listener)
 523                 return;
 524
 525         listener = calloc(1, sizeof(struct wl_listener));
 526         TDM_RETURN_IF_FAIL(listener != NULL);
 527
 528         listener->notify = _trace_cb_client_destroy;
 529         wl_client_add_destroy_listener(client, listener);
 530 }
 531
 532 static const char *
 533 _trace_get_next_argument(const char *signature,
 534                                                  struct argument_details *details)
 535 {
 536         details->nullable = 0;
 537         for (; *signature; ++signature) {
 538                 switch (*signature) {
 539                 case 'i':
 540                 case 'u':
 541                 case 'f':
 542                 case 's':
 543                 case 'o':
 544                 case 'n':
 545                 case 'a':
 546                 case 'h':
 547                         details->type = *signature;
 548                         return signature + 1;
 549                 case '?':
 550                         details->nullable = 1;
 551                         break;
 552                 default:
 553                         return NULL;
 554                 }
 555         }
 556         details->type = '\0';
 557         return signature;
 558 }
 559
 560 static struct wl_protocol_logger *_trace_protocol_logger;
 561
 562 static void
 563 _trace_protocol_logger_cb(void *user_data,
 564                                                   enum wl_protocol_logger_type direction,
 565                                                   const struct wl_protocol_logger_message *message)
 566 {
 567         int i;
 568         struct argument_details arg;
 569         struct wl_client *client = wl_resource_get_client(message->resource);
 570         const char *signature = message->message->signature;
 571         struct timespec tp;
 572         unsigned int time;
 573         pid_t pid = -1;
 574         const char *proc_name;
 575         char temp[512] = { 0, }, *p = temp;
 576         int len = sizeof(temp), *l = &len;
 577         int send;
 578
 579         if (client) {
 580                 _trace_reg_client_destroy_listener(client);
 581                 wl_client_get_credentials(client, &pid, NULL, NULL);
 582         }
 583
 584         proc_name = tdm_server_get_client_name(pid);
 585
 586         clock_gettime(CLOCK_MONOTONIC, &tp);
 587         time = (tp.tv_sec * 1000000L) + (tp.tv_nsec / 1000);
 588
 589         send = (direction == WL_PROTOCOL_LOGGER_EVENT) ? 1 : 0;
 590
 591         TDM_SNPRINTF(p, l, "[%10.3f] %s%d%s%s@%u.%s(",
 592                                  time / 1000.0,
 593                                  send ? "Server -> Client [PID:" : "Server <- Client [PID:",
 594                                  pid, "] ",
 595                                  wl_resource_get_class(message->resource),
 596                                  wl_resource_get_id(message->resource),
 597                                  message->message->name);
 598
 599         for (i = 0; i < message->arguments_count; i++) {
 600                 signature = _trace_get_next_argument(signature, &arg);
 601                 TDM_RETURN_IF_FAIL(signature != NULL);
 602
 603                 if (i > 0)
 604                         TDM_SNPRINTF(p, l, ", ");
 605
 606                 switch (arg.type) {
 607                 case 'u':
 608                         TDM_SNPRINTF(p, l, "%u", message->arguments[i].u);
 609                         break;
 610                 case 'i':
 611                         TDM_SNPRINTF(p, l, "%d", message->arguments[i].i);
 612                         break;
 613                 case 'f':
 614                         TDM_SNPRINTF(p, l, "%f",
 615                                                  wl_fixed_to_double(message->arguments[i].f));
 616                         break;
 617                 case 's':
 618                         TDM_SNPRINTF(p, l, "\"%s\"", message->arguments[i].s);
 619                         break;
 620                 case 'o':
 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));
 625                         else
 626                                 TDM_SNPRINTF(p, l, "nil");
 627                         break;
 628                 case 'n':
 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);
 633                         else
 634                                 TDM_SNPRINTF(p, l, "nil");
 635                         break;
 636                 case 'a':
 637                         TDM_SNPRINTF(p, l, "array");
 638                         break;
 639                 case 'h':
 640                         TDM_SNPRINTF(p, l, "fd %d", message->arguments[i].h);
 641                         break;
 642                 default:
 643                         return;
 644                 }
 645         }
 646
 647         TDM_SNPRINTF(p, l, "), cmd: %s", proc_name ? proc_name : "Unknown");
 648
 649         TDM_INFO("%s", temp);
 650 }
 651
 652 INTERN tdm_error
 653 tdm_event_loop_trace_enable(tdm_private_display * private_display,
 654                                                         unsigned int enable)
 655 {
 656         tdm_private_loop *private_loop = private_display->private_loop;
 657
 658         TDM_RETURN_VAL_IF_FAIL(private_loop->wl_display != NULL, TDM_ERROR_NONE);
 659
 660         if (!enable) {
 661                 if (_trace_protocol_logger) {
 662                         wl_protocol_logger_destroy(_trace_protocol_logger);
 663                         _trace_protocol_logger = NULL;
 664                 }
 665                 return TDM_ERROR_NONE;
 666         }
 667
 668         if (_trace_protocol_logger)
 669                 wl_protocol_logger_destroy(_trace_protocol_logger);
 670
 671         _trace_protocol_logger =
 672                 wl_display_add_protocol_logger(private_loop->wl_display, _trace_protocol_logger_cb, NULL);
 673
 674         return TDM_ERROR_NONE;
 675 }
 676 /* LCOV_EXCL_STOP */