src/tdm_monitor_server.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 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdlib.h>
  39 #include <stdint.h>
  40
  41 #include "tdm.h"
  42 #include "tdm_private.h"
  43 #include "tdm_helper.h"
  44 #include "tdm_log.h"
  45
  46 #define TDM_DBG_SERVER_ARGS_MAX         32
  47
  48 /* LCOV_EXCL_START */
  49 static void _tdm_monitor_server_usage(char *app_name, char *reply, int *len);
  50
  51 static void
  52 _tdm_monitor_server_query(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
  53 {
  54         tdm_display_lock(dpy);
  55         tdm_helper_get_display_information(dpy, reply, len);
  56         tdm_display_unlock(dpy);
  57 }
  58
  59 static void
  60 _tdm_monitor_server_protocol_trace(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
  61 {
  62         int enable;
  63
  64         if (argc < 3) {
  65                 _tdm_monitor_server_usage(argv[0], reply, len);
  66                 return;
  67         }
  68
  69         enable = atoi(argv[2]);
  70
  71         tdm_event_loop_trace_enable(dpy, enable);
  72
  73         TDM_SNPRINTF(reply, len, "protocol trace: '%s'\n", (enable) ? "enabled" : "disabled");
  74 }
  75
  76 static void
  77 _tdm_monitor_server_dpms(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
  78 {
  79         tdm_output *output;
  80         int output_idx, dpms_value;
  81         char *arg;
  82         char *end;
  83         tdm_error ret;
  84
  85         if (argc < 3) {
  86                 _tdm_monitor_server_usage(argv[0], reply, len);
  87                 return;
  88         }
  89
  90         arg = argv[2];
  91         output_idx = strtol(arg, &end, 10);
  92         if (*end != ':') {
  93                 TDM_SNPRINTF(reply, len, "failed: no onoff value\n");
  94                 return;
  95         }
  96
  97         arg = end + 1;
  98         dpms_value = strtol(arg, &end, 10);
  99
 100         output = tdm_display_get_output(dpy, output_idx, &ret);
 101         TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE && output != NULL);
 102
 103         ret = tdm_output_set_dpms(output, dpms_value);
 104         TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 105
 106         TDM_SNPRINTF(reply, len, "done: DPMS %s\n", tdm_dpms_str(dpms_value));
 107 }
 108
 109 static void
 110 _tdm_monitor_server_ttrace(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 111 {
 112         int output_id = 0;
 113         char *end;
 114         tdm_error ret;
 115
 116         if (argc < 3) {
 117                 _tdm_monitor_server_usage(argv[0], reply, len);
 118                 return;
 119         }
 120
 121         if (argv[3])
 122                 output_id = strtol(argv[3], &end, 10);
 123
 124         ret = tdm_display_enable_ttrace(dpy, argv[2], output_id, reply, len);
 125         TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 126 }
 127
 128 static void
 129 _tdm_monitor_server_debug(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 130 {
 131         int level;
 132         char *arg;
 133         char *end;
 134
 135         if (argc < 3) {
 136                 _tdm_monitor_server_usage(argv[0], reply, len);
 137                 return;
 138         }
 139
 140         arg = argv[2];
 141         level = strtol(arg, &end, 10);
 142
 143         tdm_log_set_debug_level(level);
 144         TDM_SNPRINTF(reply, len, "debug level: %d\n", level);
 145
 146         if (*end == '@') {
 147                 char *arg = end + 1;
 148
 149                 tdm_display_enable_debug_module((const char *)arg);
 150
 151                 TDM_SNPRINTF(reply, len, "debugging... '%s'\n", arg);
 152         }
 153 }
 154
 155 static void
 156 _tdm_monitor_server_log_path(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 157 {
 158         static int old_stdout = -1;
 159         char fd_name[TDM_PATH_LEN];
 160         char *path;
 161
 162         if (argc < 3) {
 163                 _tdm_monitor_server_usage(argv[0], reply, len);
 164                 return;
 165         }
 166
 167         if (old_stdout == -1)
 168                 old_stdout = dup(STDOUT_FILENO);
 169
 170         path = argv[2];
 171         TDM_DBG_RETURN_IF_FAIL(path != NULL);
 172
 173         tdm_log_enable_dlog(0);
 174
 175         if (!strncmp(path, "dlog", 4)) {
 176                 tdm_log_enable_dlog(1);
 177                 goto done;
 178         } else if (!strncmp(path, "console", 7))
 179                 snprintf(fd_name, TDM_PATH_LEN, "/proc/%d/fd/1", pid);
 180         else {
 181                 if (path[0] == '/')
 182                         snprintf(fd_name, TDM_PATH_LEN, "%s", path);
 183                 else {
 184                         if (cwd)
 185                                 snprintf(fd_name, TDM_PATH_LEN, "%s/%s", cwd, path);
 186                         else
 187                                 snprintf(fd_name, TDM_PATH_LEN, "%s", path);
 188                 }
 189                 tdm_log_enable_color(0);
 190         }
 191
 192         if (tdm_display_enable_path((const char*)fd_name) != TDM_ERROR_NONE) {
 193                 TDM_SNPRINTF(reply, len, "failed: '%s'\n", path);
 194                 return;
 195         }
 196
 197 done:
 198         TDM_SNPRINTF(reply, len, "log path: '%s'\n", path);
 199 }
 200
 201 static void
 202 _tdm_monitor_server_choose_commit_per_vblank_mode(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 203 {
 204         int output_idx;
 205         int mode;
 206         char *arg;
 207         char *end;
 208         tdm_error err;
 209
 210         /* TODO: do we have to provide an ability to choose commit_per_vblank mode outside? */
 211
 212         if (argc < 4) {
 213                 _tdm_monitor_server_usage(argv[0], reply, len);
 214                 return;
 215         }
 216
 217         arg = argv[2];
 218         output_idx = strtol(arg, &end, 10);
 219
 220         arg = argv[3];
 221         mode = strtol(arg, &end, 10);
 222
 223         err = tdm_output_choose_commit_per_vblank_mode(tdm_display_get_output(dpy, output_idx, NULL), mode);
 224         if (err != TDM_ERROR_NONE) {
 225                 TDM_SNPRINTF(reply, len, "an error: output_idx or mode is wrong\n");
 226                 return;
 227         }
 228
 229         TDM_SNPRINTF(reply, len, "the mode's been set\n");
 230 }
 231
 232 static void
 233 _tdm_monitor_server_fps(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 234 {
 235         int enable;
 236         char *arg;
 237         char *end;
 238
 239         if (argc < 3) {
 240                 _tdm_monitor_server_usage(argv[0], reply, len);
 241                 return;
 242         }
 243
 244         arg = argv[2];
 245         enable = strtol(arg, &end, 10);
 246
 247         tdm_display_enable_fps(dpy, enable);
 248
 249         TDM_SNPRINTF(reply, len, "%s to print fps\n", (enable) ? "enable" : "disable");
 250 }
 251
 252 static void
 253 _tdm_monitor_server_vblank_list(unsigned int pid, char *cwd, int argc, char *argv[],
 254                                                                 char *reply, int *len, tdm_display *dpy)
 255 {
 256         tdm_vblank_get_vblank_list_information(dpy, reply, len);
 257 }
 258
 259 static void
 260 _tdm_monitor_server_vblank_fps(unsigned int pid, char *cwd, int argc, char *argv[],
 261                                                            char *reply, int *len, tdm_display *dpy)
 262 {
 263         unsigned int target_pid, fps;
 264         char *arg;
 265         char *end;
 266         char name[TDM_NAME_LEN];
 267         tdm_error ret;
 268
 269         if (argc < 3) {
 270                 _tdm_monitor_server_usage(argv[0], reply, len);
 271                 return;
 272         }
 273
 274         arg = argv[2];
 275         target_pid = strtol(arg, &end, 10);
 276
 277         if (*end == ',') {
 278                 arg = end + 1;
 279                 end = strtostr(name, TDM_NAME_LEN, arg, TDM_DELIM);
 280         } else {
 281                 strncpy(name, TDM_VBLANK_DEFAULT_NAME, TDM_NAME_LEN - 1);
 282                 name[TDM_NAME_LEN - 1] = '\0';
 283         }
 284
 285         if (*end != '@') {
 286                 TDM_SNPRINTF(reply, len, "failed: no fps value\n");
 287                 return;
 288         }
 289
 290         arg = end + 1;
 291         fps = strtol(arg, &end, 10);
 292
 293         ret = tdm_vblank_set_client_vblank_fps(target_pid, name, fps);
 294         if (ret != TDM_ERROR_NONE) {
 295                 TDM_SNPRINTF(reply, len, "can't set '%u' fps to '%s' client vblank(PID:%u)\n", fps, name, target_pid);
 296                 return;
 297         }
 298
 299         TDM_SNPRINTF(reply, len, "success: '%u' fps for '%s' client vblank(PID:%u)\n", fps, name, target_pid);
 300 }
 301
 302 static void
 303 _tdm_monitor_server_global_fps(unsigned int pid, char *cwd, int argc, char *argv[],
 304                                                            char *reply, int *len, tdm_display *dpy)
 305 {
 306         unsigned int fps;
 307         char *arg;
 308         char *end;
 309         tdm_error ret;
 310
 311         if (argc < 3) {
 312                 _tdm_monitor_server_usage(argv[0], reply, len);
 313                 return;
 314         }
 315
 316         arg = argv[2];
 317         fps = strtol(arg, &end, 10);
 318
 319         if (fps > 0)
 320                 ret = tdm_vblank_enable_global_fps(1, fps);
 321         else
 322                 ret = tdm_vblank_enable_global_fps(0, 0);
 323
 324         if (ret != TDM_ERROR_NONE) {
 325                 TDM_SNPRINTF(reply, len, "can't set '%u' fps to global fps\n", fps);
 326                 return;
 327         }
 328
 329         TDM_SNPRINTF(reply, len, "success: '%u' global fps\n", fps);
 330 }
 331
 332 static void
 333 _tdm_monitor_server_prop(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 334 {
 335         tdm_output *output;
 336         tdm_output *layer = NULL;
 337         int output_idx, layer_idx = -1;
 338         int cnt, i, done = 0;
 339         tdm_value value;
 340         char temp[TDM_PATH_LEN];
 341         char *prop_name;
 342         char *arg;
 343         char *end;
 344         tdm_error ret;
 345         const tdm_prop *props;
 346
 347         if (argc < 3) {
 348                 _tdm_monitor_server_usage(argv[0], reply, len);
 349                 return;
 350         }
 351
 352         snprintf(temp, TDM_PATH_LEN, "%s", argv[2]);
 353         arg = temp;
 354
 355         output_idx = strtol(arg, &end, 10);
 356         if (*end == ',') {
 357                 arg = end + 1;
 358                 layer_idx = strtol(arg, &end, 10);
 359         }
 360
 361         if (*end != ':') {
 362                 TDM_SNPRINTF(reply, len, "failed: no prop_name\n");
 363                 return;
 364         }
 365
 366         arg = end + 1;
 367         prop_name = strtok_r(arg, ",", &end);
 368         if (!prop_name) {
 369                 TDM_SNPRINTF(reply, len, "failed: get prop_name by strtok_r\n");
 370                 return;
 371         }
 372
 373         if (*end == '\0') {
 374                 TDM_SNPRINTF(reply, len, "failed: no value\n");
 375                 return;
 376         }
 377
 378         arg = strtok_r(NULL, TDM_DELIM, &end);
 379         if (!arg) {
 380                 TDM_SNPRINTF(reply, len, "failed: get arg by strtok_r\n");
 381                 return;
 382         }
 383         value.u32 = strtol(arg, &end, 10);
 384
 385         output = tdm_display_get_output(dpy, output_idx, &ret);
 386         TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE && output != NULL);
 387
 388         if (layer_idx != -1) {
 389                 layer = tdm_output_get_layer(output, layer_idx, &ret);
 390                 TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE && layer != NULL);
 391         }
 392
 393         if (layer) {
 394                 ret = tdm_layer_get_available_properties(layer, &props, &cnt);
 395                 TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 396
 397                 for (i = 0; i < cnt; i++) {
 398                         if (!strncmp(props[i].name, prop_name, TDM_NAME_LEN)) {
 399                                 ret = tdm_layer_set_property(layer, props[i].id, value);
 400                                 TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 401                                 done = 1;
 402                                 break;
 403                         }
 404                 }
 405         } else {
 406                 ret = tdm_output_get_available_properties(output, &props, &cnt);
 407                 TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 408
 409                 for (i = 0; i < cnt; i++) {
 410                         if (!strncmp(props[i].name, prop_name, TDM_NAME_LEN)) {
 411                                 ret = tdm_output_set_property(output, props[i].id, value);
 412                                 TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 413                                 done = 1;
 414                                 break;
 415                         }
 416                 }
 417         }
 418
 419         if (done)
 420                 TDM_SNPRINTF(reply, len, "done: %s:%d \n", prop_name, value.u32);
 421         else
 422                 TDM_SNPRINTF(reply, len, "no '%s' propperty \n", prop_name);
 423 }
 424
 425 static void
 426 _tdm_monitor_server_dump(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 427 {
 428         if (argc < 3) {
 429                 _tdm_monitor_server_usage(argv[0], reply, len);
 430                 return;
 431         }
 432
 433         tdm_display_enable_dump(dpy, (const char*)argv[2], reply, len);
 434 }
 435
 436 static void
 437 _tdm_monitor_server_punch(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy)
 438 {
 439         char *arg, *end;
 440         unsigned int output_id, layer_id;
 441         tdm_output *output;
 442         tdm_layer *layer;
 443         tbm_surface_h buffer;
 444
 445         arg = argv[2];
 446
 447         output_id = strtol(arg, &end, 10);
 448         output = tdm_display_get_output(dpy, output_id, NULL);
 449         if (!output) {
 450                 TDM_SNPRINTF(reply, len, "not found output\n");
 451                 return;
 452         }
 453         if (*end != ',') {
 454                 TDM_SNPRINTF(reply, len, "not found ',<layer_idx>'\n");
 455                 return;
 456         }
 457
 458         arg = end + 1;
 459         layer_id = strtol(arg, &end, 10);
 460         layer = tdm_output_get_layer(output, layer_id, NULL);
 461         if (!layer) {
 462                 TDM_SNPRINTF(reply, len, "not found layer\n");
 463                 return;
 464         }
 465
 466         buffer = tdm_layer_get_displaying_buffer(layer, NULL);
 467         if (!buffer) {
 468                 TDM_SNPRINTF(reply, len, "not found buffer\n");
 469                 return;
 470         }
 471
 472         if (*end == ':') {
 473                 tdm_pos pos = {0,};
 474
 475                 arg = end + 1;
 476                 pos.w = strtol(arg, &end, 10);
 477                 TDM_EXIT_IF_FAIL(*end == 'x');
 478                 arg = end + 1;
 479                 pos.h = strtol(arg, &end, 10);
 480                 if (*end == '+') {
 481                         arg = end + 1;
 482                         pos.x = strtol(arg, &end, 10);
 483                         TDM_EXIT_IF_FAIL(*end == '+');
 484                         arg = end + 1;
 485                         pos.y = strtol(arg, &end, 10);
 486                 }
 487
 488                 tdm_helper_clear_buffer_pos(buffer, &pos);
 489         } else
 490                 tdm_helper_clear_buffer(buffer);
 491 }
 492
 493 static struct {
 494         const char *opt;
 495         void (*func)(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy);
 496         const char *desc;
 497         const char *arg;
 498         const char *ex;
 499 } option_proc[] = {
 500         {
 501                 "info", _tdm_monitor_server_query,
 502                 "show tdm output, layer information", NULL, NULL
 503         },
 504         {
 505                 "trace", _tdm_monitor_server_protocol_trace,
 506                 "enable/disable the wl protocol",
 507                 "<enable>",
 508                 "0 or 1"
 509         },
 510         {
 511                 "dpms", _tdm_monitor_server_dpms,
 512                 "set output dpms", "<output_idx>:<dpms>", "0:3 or 0:0"
 513         },
 514         {
 515                 "ttrace", _tdm_monitor_server_ttrace,
 516                 "enable/disable ttrace (module: none, vblank, client, layer, pp, capture, all",
 517                 "<module>[@<output_idx>]",
 518                 NULL
 519         },
 520         {
 521                 "debug", _tdm_monitor_server_debug,
 522                 "set the debug level and modules(module: none, mutex, buffer, thread, vblank)",
 523                 "<level>[@<module1>[,<module2>]]",
 524                 NULL
 525         },
 526         {
 527                 "log_path", _tdm_monitor_server_log_path,
 528                 "set the log path (console,dlog,filepath)",
 529                 "<path>",
 530                 "console"
 531         },
 532         {
 533                 "choose_commit_per_vblank_mode", _tdm_monitor_server_choose_commit_per_vblank_mode,
 534                 "choose a commit_per_vblank mode for the output",
 535                 "<output_idx> <mode>",
 536                 "0 1 or 1 2 or 2 0"
 537         },
 538         {
 539                 "fps", _tdm_monitor_server_fps,
 540                 "enable/disable to print fps",
 541                 "<enable>",
 542                 "0 or 1"
 543         },
 544         {
 545                 "vblank_list", _tdm_monitor_server_vblank_list,
 546                 "print the client vblank list",
 547                 NULL,
 548                 NULL
 549         },
 550         {
 551                 "vblank_fps", _tdm_monitor_server_vblank_fps,
 552                 "set the client vblank fps for the given process ID and client vblank name",
 553                 "<pid>[,<vblank_name>]@<fps>",
 554                 NULL
 555         },
 556         {
 557                 "global_fps", _tdm_monitor_server_global_fps,
 558                 "set the global vblank fps for the entire system",
 559                 "<fps>",
 560                 NULL
 561         },
 562         {
 563                 "prop", _tdm_monitor_server_prop,
 564                 "set the property of a output or a layer",
 565                 "<output_idx>[,<layer_idx>]:<prop_name>,<value>",
 566                 NULL
 567         },
 568         {
 569                 "dump", _tdm_monitor_server_dump,
 570                 "dump buffers (type: none, layer, pp, capture, current)\n"
 571                 "\t\t  layer, pp, capture - start to dump buffers of layer, pp, capture\n"
 572                 "\t\t  none               - stop to dump buffers\n"
 573                 "\t\t  current            - dump the current buffer of all layers",
 574                 "<object_type1>[,<object_type2>[,...]][@<directory_path>]",
 575                 NULL
 576         },
 577         {
 578                 "punch", _tdm_monitor_server_punch,
 579                 "punch a layer",
 580                 "<output_idx>,<layer_idx>[:<w>x<h>[+<x>+<y>]]",
 581                 NULL
 582         },
 583 };
 584
 585 static void
 586 _tdm_monitor_server_usage(char *app_name, char *reply, int *len)
 587 {
 588         int opt_size = sizeof(option_proc) / sizeof(option_proc[0]);
 589         int i;
 590
 591         TDM_SNPRINTF(reply, len, "usage: %s \n\n", app_name);
 592
 593         for (i = 0; i < opt_size; i++) {
 594                 TDM_SNPRINTF(reply, len, "\t-%s\t%s\n", option_proc[i].opt, option_proc[i].desc);
 595                 if (option_proc[i].arg)
 596                         TDM_SNPRINTF(reply, len, "\t\t  %s\n", option_proc[i].arg);
 597                 if (option_proc[i].ex)
 598                         TDM_SNPRINTF(reply, len, "\t\t  ex) %s\n", option_proc[i].ex);
 599                 TDM_SNPRINTF(reply, len, "\n");
 600         }
 601 }
 602
 603 static void
 604 _tdm_monitor_server_command(unsigned int pid, char *cwd, tdm_display *dpy, int argc, char *argv[], char *reply, int *len)
 605 {
 606         int opt_size = sizeof(option_proc) / sizeof(option_proc[0]);
 607         int i;
 608
 609         if (argc < 2) {
 610                 _tdm_monitor_server_usage(argv[0], reply, len);
 611                 return;
 612         }
 613
 614         for (i = 0; i < opt_size; i++) {
 615                 if (argv[1][0] == '-' && !strncmp(argv[1] + 1, option_proc[i].opt, 32)) {
 616                         if (option_proc[i].func) {
 617                                 option_proc[i].func(pid, cwd, argc, argv, reply, len, dpy);
 618                                 return;
 619                         } else {
 620                                 TDM_SNPRINTF(reply, len, "'%s' not implemented.\n", argv[1]);
 621                                 return;
 622                         }
 623                 }
 624         }
 625
 626         _tdm_monitor_server_usage(argv[0], reply, len);
 627         return;
 628 }
 629
 630
 631 INTERN void
 632 tdm_monitor_server_command(tdm_display *dpy, const char *options, char *reply, int *len)
 633 {
 634         unsigned int pid;
 635         char cwd[1024];
 636         int argc = 0;
 637         char *argv[TDM_DBG_SERVER_ARGS_MAX] = {0,};
 638         char temp[1024];
 639         char *arg;
 640         char *end = NULL, *e;
 641
 642         snprintf(temp, sizeof(temp), "%s", options);
 643
 644         arg = strtok_r(temp, " ", &end);
 645         if (!arg) {
 646                 TDM_SNPRINTF(reply, len, "no pid for tdm-monitor");
 647                 return;
 648         }
 649         pid = strtol(arg, &e, 10);
 650
 651         arg = strtok_r(NULL, " ", &end);
 652         if (!arg) {
 653                 TDM_SNPRINTF(reply, len, "no cwd for tdm-monitor");
 654                 return;
 655         }
 656         snprintf(cwd, sizeof(cwd), "%s", arg);
 657
 658         TDM_DBG("pid(%d) cwd(%s)", pid, cwd);
 659
 660         argv[argc] = strtok_r(NULL, " ", &end);
 661         while (argv[argc]) {
 662                 argc++;
 663                 if (argc == TDM_DBG_SERVER_ARGS_MAX) {
 664                         TDM_SNPRINTF(reply, len, "too many arguments for tdm-monitor");
 665                         break;
 666                 }
 667                 argv[argc] = strtok_r(NULL, " ", &end);
 668         }
 669
 670         _tdm_monitor_server_command(pid, cwd, dpy, argc, argv, reply, len);
 671 }
 672 /* LCOV_EXCL_STOP */