libustcmd/ustcmd.c

   1 /* Copyright (C) 2009  Pierre-Marc Fournier, Philippe Proulx-Barrette
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <getopt.h>
  22 #include <stdlib.h>
  23 #include <fcntl.h>
  24 #include <string.h>
  25 #include <dirent.h>
  26
  27 #include "ustcomm.h"
  28 #include "ustcmd.h"
  29
  30 pid_t *ustcmd_get_online_pids(void)
  31 {
  32         struct dirent *dirent;
  33         DIR *dir;
  34         unsigned int ret_size = 1 * sizeof(pid_t), i = 0;
  35
  36         dir = opendir(SOCK_DIR);
  37         if (!dir) {
  38                 return NULL;
  39         }
  40
  41         pid_t *ret = (pid_t *) malloc(ret_size);
  42
  43         while ((dirent = readdir(dir))) {
  44                 if (!strcmp(dirent->d_name, ".") ||
  45                         !strcmp(dirent->d_name, "..")) {
  46
  47                         continue;
  48                 }
  49
  50                 if (dirent->d_type != DT_DIR &&
  51                         !!strcmp(dirent->d_name, "ustd")) {
  52
  53                         sscanf(dirent->d_name, "%u", (unsigned int *) &ret[i]);
  54                         if (pid_is_online(ret[i])) {
  55                                 ret_size += sizeof(pid_t);
  56                                 ret = (pid_t *) realloc(ret, ret_size);
  57                                 ++i;
  58                         }
  59                 }
  60         }
  61
  62         ret[i] = 0; /* Array end */
  63
  64         if (ret[0] == 0) {
  65                  /* No PID at all */
  66                 free(ret);
  67                 return NULL;
  68         }
  69
  70         closedir(dir);
  71         return ret;
  72 }
  73
  74 /**
  75  * Sets marker state (USTCMD_MS_ON or USTCMD_MS_OFF).
  76  *
  77  * @param mn    Marker name
  78  * @param state Marker's new state
  79  * @param pid   Traced process ID
  80  * @return      0 if successful, or errors {USTCMD_ERR_GEN, USTCMD_ERR_ARG}
  81  */
  82 int ustcmd_set_marker_state(const char *mn, int state, pid_t pid)
  83 {
  84         char *cmd_str [] = {"disable_marker", "enable_marker"};
  85         char *cmd;
  86         int result;
  87
  88         if (mn == NULL) {
  89                 return USTCMD_ERR_ARG;
  90         }
  91
  92         asprintf(&cmd, "%s %s", cmd_str[state], mn);
  93
  94         result = ustcmd_send_cmd(cmd, pid, NULL);
  95         if (result) {
  96                 free(cmd);
  97                 return USTCMD_ERR_GEN;
  98         }
  99
 100         free(cmd);
 101         return 0;
 102 }
 103
 104 /**
 105  * Destroys an UST trace according to a PID.
 106  *
 107  * @param pid   Traced process ID
 108  * @return      0 if successful, or error USTCMD_ERR_GEN
 109  */
 110 int ustcmd_destroy_trace(pid_t pid)
 111 {
 112         int result;
 113
 114         result = ustcmd_send_cmd("destroy", pid, NULL);
 115         if (result) {
 116                 return USTCMD_ERR_GEN;
 117         }
 118
 119         return 0;
 120 }
 121
 122 /**
 123  * Starts an UST trace (and setups it) according to a PID.
 124  *
 125  * @param pid   Traced process ID
 126  * @return      0 if successful, or error USTCMD_ERR_GEN
 127  */
 128 int ustcmd_setup_and_start(pid_t pid)
 129 {
 130         int result;
 131
 132         result = ustcmd_send_cmd("start", pid, NULL);
 133         if (result) {
 134                 return USTCMD_ERR_GEN;
 135         }
 136
 137         return 0;
 138 }
 139
 140 /**
 141  * Starts an UST trace according to a PID.
 142  *
 143  * @param pid   Traced process ID
 144  * @return      0 if successful, or error USTCMD_ERR_GEN
 145  */
 146 int ustcmd_start_trace(pid_t pid)
 147 {
 148         int result;
 149
 150         result = ustcmd_send_cmd("trace_start", pid, NULL);
 151         if (result) {
 152                 return USTCMD_ERR_GEN;
 153         }
 154
 155         return 0;
 156 }
 157
 158 /**
 159  * Stops an UST trace according to a PID.
 160  *
 161  * @param pid   Traced process ID
 162  * @return      0 if successful, or error USTCMD_ERR_GEN
 163  */
 164 int ustcmd_stop_trace(pid_t pid)
 165 {
 166         int result;
 167
 168         result = ustcmd_send_cmd("trace_stop", pid, NULL);
 169         if (result) {
 170                 return USTCMD_ERR_GEN;
 171         }
 172
 173         return 0;
 174 }
 175
 176 /**
 177  * Counts newlines ('\n') in a string.
 178  *
 179  * @param str   String to search in
 180  * @return      Total newlines count
 181  */
 182 unsigned int ustcmd_count_nl(const char *str)
 183 {
 184         unsigned int i = 0, tot = 0;
 185
 186         while (str[i] != '\0') {
 187                 if (str[i] == '\n') {
 188                         ++tot;
 189                 }
 190                 ++i;
 191         }
 192
 193         return tot;
 194 }
 195
 196 /**
 197  * Frees a CMSF array.
 198  *
 199  * @param cmsf  CMSF array to free
 200  * @return      0 if successful, or error USTCMD_ERR_ARG
 201  */
 202 int ustcmd_free_cmsf(struct marker_status *cmsf)
 203 {
 204         if (cmsf == NULL) {
 205                 return USTCMD_ERR_ARG;
 206         }
 207
 208         unsigned int i = 0;
 209         while (cmsf[i].channel != NULL) {
 210                 free(cmsf[i].channel);
 211                 free(cmsf[i].marker);
 212                 free(cmsf[i].fs);
 213                 ++i;
 214         }
 215         free(cmsf);
 216
 217         return 0;
 218 }
 219
 220 /**
 221  * Gets channel/marker/state/format string for a given PID.
 222  *
 223  * @param cmsf  Pointer to CMSF array to be filled (callee allocates, caller
 224  *              frees with `ustcmd_free_cmsf')
 225  * @param pid   Targeted PID
 226  * @return      0 if successful, or errors {USTCMD_ERR_ARG, USTCMD_ERR_GEN}
 227  */
 228 int ustcmd_get_cmsf(struct marker_status **cmsf, const pid_t pid)
 229 {
 230         char *big_str = NULL;
 231         int result;
 232         struct marker_status *tmp_cmsf = NULL;
 233         unsigned int i = 0, cmsf_ind = 0;
 234
 235         if (cmsf == NULL) {
 236                 return USTCMD_ERR_ARG;
 237         }
 238         result = ustcmd_send_cmd("list_markers", pid, &big_str);
 239         if (result) {
 240                 return USTCMD_ERR_GEN;
 241         }
 242
 243         if (big_str == NULL) {
 244                 fprintf(stderr, "ustcmd: error while getting markers list\n");
 245                 return USTCMD_ERR_GEN;
 246         }
 247
 248         tmp_cmsf = (struct marker_status *) malloc(sizeof(struct marker_status) *
 249                 (ustcmd_count_nl(big_str) + 1));
 250         if (tmp_cmsf == NULL) {
 251                 return USTCMD_ERR_GEN;
 252         }
 253
 254         /* Parse received reply string (format: "[chan]/[mark] [st] [fs]"): */
 255         while (big_str[i] != '\0') {
 256                 char state;
 257
 258                 sscanf(big_str + i, "marker: %a[^/]/%a[^ ] %c %a[^\n]",
 259                         &tmp_cmsf[cmsf_ind].channel,
 260                         &tmp_cmsf[cmsf_ind].marker,
 261                         &state,
 262                         &tmp_cmsf[cmsf_ind].fs);
 263                 tmp_cmsf[cmsf_ind].state = (state == USTCMD_MS_CHR_ON ?
 264                         USTCMD_MS_ON : USTCMD_MS_OFF); /* Marker state */
 265
 266                 while (big_str[i] != '\n') {
 267                         ++i; /* Go to next '\n' */
 268                 }
 269                 ++i; /* Skip current pointed '\n' */
 270                 ++cmsf_ind;
 271         }
 272         tmp_cmsf[cmsf_ind].channel = NULL;
 273         tmp_cmsf[cmsf_ind].marker = NULL;
 274         tmp_cmsf[cmsf_ind].fs = NULL;
 275
 276         *cmsf = tmp_cmsf;
 277
 278         free(big_str);
 279         return 0;
 280 }
 281
 282 /**
 283  * Shoots a given command using ustcomm.
 284  *
 285  * @param cmd   Null-terminated command to shoot
 286  * @param pid   Targeted PID
 287  * @param reply Pointer to string to be filled with a reply string (must
 288  *              be NULL if no reply is needed for the given command).
 289  * @return      0 if successful, or errors {USTCMD_ERR_ARG, USTCMD_ERR_CONN}
 290  */
 291
 292 int ustcmd_send_cmd(const char *cmd, const pid_t pid, char **reply)
 293 {
 294         struct ustcomm_connection conn;
 295
 296         if (cmd == NULL) {
 297                 return USTCMD_ERR_ARG;
 298         }
 299
 300         if (ustcomm_connect_app(pid, &conn)) {
 301                 fprintf(stderr, "ustcmd_send_cmd: could not connect to PID %u\n",
 302                         (unsigned int) pid);
 303                 return USTCMD_ERR_CONN;
 304         }
 305
 306         ustcomm_send_request(&conn, cmd, reply);
 307
 308         return 0;
 309 }