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