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