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