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