libustctl/libustctl.c

   1 /* Copyright (C) 2009  Pierre-Marc Fournier, Philippe Proulx-Barrette
   2  * Copyright (C) 2011  Ericsson AB
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <getopt.h>
  23 #include <stdlib.h>
  24 #include <fcntl.h>
  25 #include <string.h>
  26 #include <dirent.h>
  27
  28 #include "ustcomm.h"
  29 #include "ust/ustctl.h"
  30 #include "usterr.h"
  31
  32 static int do_cmd(int sock,
  33                   const struct ustcomm_header *req_header,
  34                   const char *req_data,
  35                   struct ustcomm_header *res_header,
  36                   char **res_data)
  37 {
  38         int result, saved_errno = 0;
  39         char *recv_buf;
  40
  41         recv_buf = zmalloc(USTCOMM_BUFFER_SIZE);
  42         if (!recv_buf) {
  43                 saved_errno = ENOMEM;
  44                 goto out;
  45         }
  46
  47         result = ustcomm_req(sock, req_header, req_data, res_header, recv_buf);
  48         if (result > 0) {
  49                 saved_errno = -res_header->result;
  50                 if (res_header->size == 0 || saved_errno > 0) {
  51                         free(recv_buf);
  52                 } else {
  53                         if (res_data) {
  54                                 *res_data = recv_buf;
  55                         } else {
  56                                 free(recv_buf);
  57                         }
  58                 }
  59         } else {
  60                 ERR("ustcomm req failed");
  61                 if (result == 0) {
  62                         saved_errno = ENOTCONN;
  63                 } else {
  64                         saved_errno = -result;
  65                 }
  66                 free(recv_buf);
  67         }
  68
  69 out:
  70         errno = saved_errno;
  71         if (errno) {
  72                 return -1;
  73         }
  74
  75         return 0;
  76 }
  77
  78 int ustctl_connect_pid(pid_t pid)
  79 {
  80         int sock;
  81
  82         if (ustcomm_connect_app(pid, &sock)) {
  83                 ERR("could not connect to PID %u", (unsigned int) pid);
  84                 errno = ENOTCONN;
  85                 return -1;
  86         }
  87
  88         return sock;
  89 }
  90
  91 static void get_pids_in_dir(DIR *dir, pid_t **pid_list,
  92                             unsigned int *pid_list_size)
  93 {
  94         struct dirent *dirent;
  95         unsigned int read_pid;
  96
  97         while ((dirent = readdir(dir))) {
  98                 if (!strcmp(dirent->d_name, ".") ||
  99                     !strcmp(dirent->d_name, "..") ||
 100                     !strcmp(dirent->d_name, "ust-consumer") ||
 101                     dirent->d_type == DT_DIR) {
 102
 103                         continue;
 104                 }
 105
 106                 sscanf(dirent->d_name, "%u", &read_pid);
 107
 108                 (*pid_list)[*pid_list_size - 1] = read_pid;
 109                 /* FIXME: Here we previously called pid_is_online, which
 110                  * always returned 1, now I replaced it with just 1.
 111                  * We need to figure out an intelligent way of solving
 112                  * this, maybe connect-disconnect.
 113                  */
 114                 if (1) {
 115                         (*pid_list_size)++;
 116                         *pid_list = realloc(*pid_list,
 117                                             *pid_list_size * sizeof(pid_t));
 118                 }
 119         }
 120
 121         (*pid_list)[*pid_list_size - 1] = 0; /* Array end */
 122 }
 123
 124 pid_t *ustctl_get_online_pids(void)
 125 {
 126         char *dir_name;
 127         DIR *dir;
 128         unsigned int pid_list_size = 1;
 129         pid_t *pid_list = NULL;
 130
 131         dir_name = ustcomm_user_sock_dir();
 132         if (!dir_name) {
 133                 return NULL;
 134         }
 135
 136         dir = opendir(dir_name);
 137         if (!dir) {
 138                 goto free_dir_name;
 139         }
 140
 141         pid_list = malloc(pid_list_size * sizeof(pid_t));
 142
 143         get_pids_in_dir(dir, &pid_list, &pid_list_size);
 144
 145         if (pid_list[0] == 0) {
 146                 /* No PID at all */
 147                 free(pid_list);
 148                 pid_list = NULL;
 149                 goto close_dir;
 150         }
 151
 152 close_dir:
 153         closedir(dir);
 154
 155 free_dir_name:
 156         free(dir_name);
 157
 158         return pid_list;
 159 }
 160
 161 /**
 162  * Sets marker state (USTCTL_MS_ON or USTCTL_MS_OFF).
 163  *
 164  * @param mn    Marker name
 165  * @param state Marker's new state
 166  * @param pid   Traced process ID
 167  * @return      0 if successful, or errors {USTCTL_ERR_GEN, USTCTL_ERR_ARG}
 168  */
 169 int ustctl_set_marker_state(int sock, const char *trace, const char *channel,
 170                             const char *marker, int state)
 171 {
 172         struct ustcomm_header req_header, res_header;
 173         struct ustcomm_marker_info marker_inf;
 174         int result;
 175
 176         result = ustcomm_pack_marker_info(&req_header,
 177                                           &marker_inf,
 178                                           trace,
 179                                           channel,
 180                                           marker);
 181         if (result < 0) {
 182                 errno = -result;
 183                 return -1;
 184         }
 185
 186         req_header.command = state ? ENABLE_MARKER : DISABLE_MARKER;
 187
 188         return do_cmd(sock, &req_header, (char *)&marker_inf,
 189                       &res_header, NULL);
 190 }
 191
 192 /**
 193  * Set subbuffer size.
 194  *
 195  * @param channel_size  Channel name and size
 196  * @param pid           Traced process ID
 197  * @return              0 if successful, or error
 198  */
 199 int ustctl_set_subbuf_size(int sock, const char *trace, const char *channel,
 200                            unsigned int subbuf_size)
 201 {
 202         struct ustcomm_header req_header, res_header;
 203         struct ustcomm_channel_info ch_inf;
 204         int result;
 205
 206         result = ustcomm_pack_channel_info(&req_header,
 207                                            &ch_inf,
 208                                            trace,
 209                                            channel);
 210         if (result < 0) {
 211                 errno = -result;
 212                 return -1;
 213         }
 214
 215         req_header.command = SET_SUBBUF_SIZE;
 216         ch_inf.subbuf_size = subbuf_size;
 217
 218         return do_cmd(sock, &req_header, (char *)&ch_inf,
 219                       &res_header, NULL);
 220 }
 221
 222 /**
 223  * Set subbuffer num.
 224  *
 225  * @param channel_num   Channel name and num
 226  * @param pid           Traced process ID
 227  * @return              0 if successful, or error
 228  */
 229 int ustctl_set_subbuf_num(int sock, const char *trace, const char *channel,
 230                           unsigned int num)
 231 {
 232         struct ustcomm_header req_header, res_header;
 233         struct ustcomm_channel_info ch_inf;
 234         int result;
 235
 236         result = ustcomm_pack_channel_info(&req_header,
 237                                            &ch_inf,
 238                                            trace,
 239                                            channel);
 240         if (result < 0) {
 241                 errno = -result;
 242                 return -1;
 243         }
 244
 245         req_header.command = SET_SUBBUF_NUM;
 246         ch_inf.subbuf_num = num;
 247
 248         return do_cmd(sock, &req_header, (char *)&ch_inf,
 249                       &res_header, NULL);
 250
 251 }
 252
 253
 254 static int ustctl_get_subbuf_num_size(int sock, const char *trace, const char *channel,
 255                                       int *num, int *size)
 256 {
 257         struct ustcomm_header req_header, res_header;
 258         struct ustcomm_channel_info ch_inf, *ch_inf_res;
 259         int result;
 260
 261
 262         result = ustcomm_pack_channel_info(&req_header,
 263                                            &ch_inf,
 264                                            trace,
 265                                            channel);
 266         if (result < 0) {
 267                 errno = -result;
 268                 return -1;
 269         }
 270
 271         req_header.command = GET_SUBBUF_NUM_SIZE;
 272
 273         result = do_cmd(sock, &req_header, (char *)&ch_inf,
 274                         &res_header, (char **)&ch_inf_res);
 275         if (result < 0) {
 276                 return -1;
 277         }
 278
 279         *num = ch_inf_res->subbuf_num;
 280         *size = ch_inf_res->subbuf_size;
 281
 282         free(ch_inf_res);
 283
 284         return 0;
 285 }
 286
 287 /**
 288  * Get subbuffer num.
 289  *
 290  * @param channel       Channel name
 291  * @param pid           Traced process ID
 292  * @return              subbuf cnf if successful, or error
 293  */
 294 int ustctl_get_subbuf_num(int sock, const char *trace, const char *channel)
 295 {
 296         int num, size, result;
 297
 298         result = ustctl_get_subbuf_num_size(sock, trace, channel,
 299                                             &num, &size);
 300         if (result < 0) {
 301                 errno = -result;
 302                 return -1;
 303         }
 304
 305         return num;
 306 }
 307
 308 /**
 309  * Get subbuffer size.
 310  *
 311  * @param channel       Channel name
 312  * @param pid           Traced process ID
 313  * @return              subbuf size if successful, or error
 314  */
 315 int ustctl_get_subbuf_size(int sock, const char *trace, const char *channel)
 316 {
 317         int num, size, result;
 318
 319         result = ustctl_get_subbuf_num_size(sock, trace, channel,
 320                                             &num, &size);
 321         if (result < 0) {
 322                 errno = -result;
 323                 return -1;
 324         }
 325
 326         return size;
 327 }
 328
 329 static int do_trace_cmd(int sock, const char *trace, int command)
 330 {
 331         struct ustcomm_header req_header, res_header;
 332         struct ustcomm_single_field trace_inf;
 333         int result;
 334
 335         result = ustcomm_pack_single_field(&req_header,
 336                                            &trace_inf,
 337                                            trace);
 338         if (result < 0) {
 339                 errno = -result;
 340                 return -1;
 341         }
 342
 343         req_header.command = command;
 344
 345         return do_cmd(sock, &req_header, (char *)&trace_inf, &res_header, NULL);
 346 }
 347
 348 /**
 349  * Destroys an UST trace according to a PID.
 350  *
 351  * @param pid   Traced process ID
 352  * @return      0 if successful, or error USTCTL_ERR_GEN
 353  */
 354 int ustctl_destroy_trace(int sock, const char *trace)
 355 {
 356         return do_trace_cmd(sock, trace, DESTROY_TRACE);
 357 }
 358
 359 /**
 360  * Starts an UST trace (and setups it) according to a PID.
 361  *
 362  * @param pid   Traced process ID
 363  * @return      0 if successful, or error USTCTL_ERR_GEN
 364  */
 365 int ustctl_setup_and_start(int sock, const char *trace)
 366 {
 367         return do_trace_cmd(sock, trace, START);
 368 }
 369
 370 /**
 371  * Creates an UST trace according to a PID.
 372  *
 373  * @param pid   Traced process ID
 374  * @return      0 if successful, or error USTCTL_ERR_GEN
 375  */
 376 int ustctl_create_trace(int sock, const char *trace)
 377 {
 378         return do_trace_cmd(sock, trace, CREATE_TRACE);
 379 }
 380
 381 /**
 382  * Starts an UST trace according to a PID.
 383  *
 384  * @param pid   Traced process ID
 385  * @return      0 if successful, or error USTCTL_ERR_GEN
 386  */
 387 int ustctl_start_trace(int sock, const char *trace)
 388 {
 389         return do_trace_cmd(sock, trace, START_TRACE);
 390 }
 391
 392 /**
 393  * Alloc an UST trace according to a PID.
 394  *
 395  * @param pid   Traced process ID
 396  * @return      0 if successful, or error USTCTL_ERR_GEN
 397  */
 398 int ustctl_alloc_trace(int sock, const char *trace)
 399 {
 400         return do_trace_cmd(sock, trace, ALLOC_TRACE);
 401 }
 402
 403
 404 int ustctl_force_switch(int sock, const char *trace)
 405 {
 406         return do_trace_cmd(sock, trace, FORCE_SUBBUF_SWITCH);
 407 }
 408
 409 /**
 410  * Stops an UST trace according to a PID.
 411  *
 412  * @param pid   Traced process ID
 413  * @return      0 if successful, or error USTCTL_ERR_GEN
 414  */
 415 int ustctl_stop_trace(int sock, const char *trace)
 416 {
 417         return do_trace_cmd(sock, trace, STOP_TRACE);
 418 }
 419
 420 /**
 421  * Counts newlines ('\n') in a string.
 422  *
 423  * @param str   String to search in
 424  * @return      Total newlines count
 425  */
 426 unsigned int ustctl_count_nl(const char *str)
 427 {
 428         unsigned int i = 0, tot = 0;
 429
 430         while (str[i] != '\0') {
 431                 if (str[i] == '\n') {
 432                         ++tot;
 433                 }
 434                 ++i;
 435         }
 436
 437         return tot;
 438 }
 439
 440 /**
 441  * Frees a CMSF array.
 442  *
 443  * @param cmsf  CMSF array to free
 444  * @return      0 if successful, or error USTCTL_ERR_ARG
 445  */
 446 int ustctl_free_cmsf(struct marker_status *cmsf)
 447 {
 448         if (cmsf == NULL) {
 449                 return USTCTL_ERR_ARG;
 450         }
 451
 452         unsigned int i = 0;
 453         while (cmsf[i].channel != NULL) {
 454                 free(cmsf[i].channel);
 455                 free(cmsf[i].marker);
 456                 free(cmsf[i].fs);
 457                 ++i;
 458         }
 459         free(cmsf);
 460
 461         return 0;
 462 }
 463
 464 /**
 465  * Gets channel/marker/state/format string for a given PID.
 466  *
 467  * @param cmsf  Pointer to CMSF array to be filled (callee allocates, caller
 468  *              frees with `ustctl_free_cmsf')
 469  * @param pid   Targeted PID
 470  * @return      0 if successful, or -1 on error
 471  */
 472 int ustctl_get_cmsf(int sock, struct marker_status **cmsf)
 473 {
 474         struct ustcomm_header req_header, res_header;
 475         char *big_str = NULL;
 476         int result;
 477         struct marker_status *tmp_cmsf = NULL;
 478         unsigned int i = 0, cmsf_ind = 0;
 479
 480         if (cmsf == NULL) {
 481                 return -1;
 482         }
 483
 484         req_header.command = LIST_MARKERS;
 485         req_header.size = 0;
 486
 487         result = ustcomm_send(sock, &req_header, NULL);
 488         if (result <= 0) {
 489                 PERROR("error while requesting markers list");
 490                 return -1;
 491         }
 492
 493         result = ustcomm_recv_alloc(sock, &res_header, &big_str);
 494         if (result <= 0) {
 495                 ERR("error while receiving markers list");
 496                 return -1;
 497         }
 498
 499         tmp_cmsf = (struct marker_status *) zmalloc(sizeof(struct marker_status) *
 500                                                     (ustctl_count_nl(big_str) + 1));
 501         if (tmp_cmsf == NULL) {
 502                 ERR("Failed to allocate CMSF array");
 503                 return -1;
 504         }
 505
 506         /* Parse received reply string (format: "[chan]/[mark] [st] [fs]"): */
 507         while (big_str[i] != '\0') {
 508                 char state;
 509
 510                 sscanf(big_str + i, "marker: %a[^/]/%a[^ ] %c %a[^\n]",
 511                        &tmp_cmsf[cmsf_ind].channel,
 512                        &tmp_cmsf[cmsf_ind].marker,
 513                        &state,
 514                        &tmp_cmsf[cmsf_ind].fs);
 515                 tmp_cmsf[cmsf_ind].state = (state == USTCTL_MS_CHR_ON ?
 516                                             USTCTL_MS_ON : USTCTL_MS_OFF); /* Marker state */
 517
 518                 while (big_str[i] != '\n') {
 519                         ++i; /* Go to next '\n' */
 520                 }
 521                 ++i; /* Skip current pointed '\n' */
 522                 ++cmsf_ind;
 523         }
 524         tmp_cmsf[cmsf_ind].channel = NULL;
 525         tmp_cmsf[cmsf_ind].marker = NULL;
 526         tmp_cmsf[cmsf_ind].fs = NULL;
 527
 528         *cmsf = tmp_cmsf;
 529
 530         free(big_str);
 531         return 0;
 532 }
 533
 534 /**
 535  * Frees a TES array.
 536  *
 537  * @param tes   TES array to free
 538  * @return      0 if successful, or error USTCTL_ERR_ARG
 539  */
 540 int ustctl_free_tes(struct trace_event_status *tes)
 541 {
 542         if (tes == NULL) {
 543                 return USTCTL_ERR_ARG;
 544         }
 545
 546         unsigned int i = 0;
 547         while (tes[i].name != NULL) {
 548                 free(tes[i].name);
 549                 ++i;
 550         }
 551         free(tes);
 552
 553         return 0;
 554 }
 555
 556 /**
 557  * Gets trace_events string for a given PID.
 558  *
 559  * @param tes   Pointer to TES array to be filled (callee allocates, caller
 560  *              frees with `ustctl_free_tes')
 561  * @param pid   Targeted PID
 562  * @return      0 if successful, or -1 on error
 563  */
 564 int ustctl_get_tes(int sock, struct trace_event_status **tes)
 565 {
 566         struct ustcomm_header req_header, res_header;
 567         char *big_str = NULL;
 568         int result;
 569         struct trace_event_status *tmp_tes = NULL;
 570         unsigned int i = 0, tes_ind = 0;
 571
 572         if (tes == NULL) {
 573                 return -1;
 574         }
 575
 576         req_header.command = LIST_TRACE_EVENTS;
 577         req_header.size = 0;
 578
 579         result = ustcomm_send(sock, &req_header, NULL);
 580         if (result != 1) {
 581                 ERR("error while requesting trace_event list");
 582                 return -1;
 583         }
 584
 585         result = ustcomm_recv_alloc(sock, &res_header, &big_str);
 586         if (result != 1) {
 587                 ERR("error while receiving markers list");
 588                 return -1;
 589         }
 590
 591         tmp_tes = (struct trace_event_status *)
 592                 zmalloc(sizeof(struct trace_event_status) *
 593                         (ustctl_count_nl(big_str) + 1));
 594         if (tmp_tes == NULL) {
 595                 ERR("Failed to allocate TES array");
 596                 return -1;
 597         }
 598
 599         /* Parse received reply string (format: "[name]"): */
 600         while (big_str[i] != '\0') {
 601                 sscanf(big_str + i, "trace_event: %a[^\n]",
 602                        &tmp_tes[tes_ind].name);
 603                 while (big_str[i] != '\n') {
 604                         ++i; /* Go to next '\n' */
 605                 }
 606                 ++i; /* Skip current pointed '\n' */
 607                 ++tes_ind;
 608         }
 609         tmp_tes[tes_ind].name = NULL;
 610
 611         *tes = tmp_tes;
 612
 613         free(big_str);
 614         return 0;
 615 }
 616
 617 /**
 618  * Set sock path
 619  *
 620  * @param sock_path     Sock path
 621  * @param pid           Traced process ID
 622  * @return              0 if successful, or error
 623  */
 624 int ustctl_set_sock_path(int sock, const char *sock_path)
 625 {
 626         int result;
 627         struct ustcomm_header req_header, res_header;
 628         struct ustcomm_single_field sock_path_msg;
 629
 630         result = ustcomm_pack_single_field(&req_header,
 631                                            &sock_path_msg,
 632                                            sock_path);
 633         if (result < 0) {
 634                 errno = -result;
 635                 return -1;
 636         }
 637
 638         req_header.command = SET_SOCK_PATH;
 639
 640         return do_cmd(sock, &req_header, (char *)&sock_path_msg,
 641                       &res_header, NULL);
 642 }
 643
 644 /**
 645  * Get sock path
 646  *
 647  * @param sock_path     Pointer to where the sock path will be returned
 648  * @param pid           Traced process ID
 649  * @return              0 if successful, or error
 650  */
 651 int ustctl_get_sock_path(int sock, char **sock_path)
 652 {
 653         int result;
 654         struct ustcomm_header req_header, res_header;
 655         struct ustcomm_single_field *sock_path_msg;
 656
 657         req_header.command = GET_SOCK_PATH;
 658         req_header.size = 0;
 659
 660         result = do_cmd(sock, &req_header, NULL, &res_header,
 661                         (char **)&sock_path_msg);
 662         if (result < 0) {
 663                 return -1;
 664         }
 665
 666         result = ustcomm_unpack_single_field(sock_path_msg);
 667         if (result < 0) {
 668                 return result;
 669         }
 670
 671         *sock_path = strdup(sock_path_msg->field);
 672
 673         free(sock_path_msg);
 674
 675         return 0;
 676 }