ltt-control/lttctl/lttctl.c

   1 /* lttctl
   2  *
   3  * Linux Trace Toolkit Control
   4  *
   5  * Small program that controls LTT through libltt.
   6  *
   7  * Copyright 2005 -
   8  *      Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
   9  */
  10
  11 #ifdef HAVE_CONFIG_H
  12 #include <config.h>
  13 #endif
  14
  15 #include <liblttctl/lttctl.h>
  16 #include <errno.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <sys/types.h>
  20 #include <sys/wait.h>
  21 #include <unistd.h>
  22 #include <signal.h>
  23 #include <dirent.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26
  27 /* Buffer for file copy : 4k seems optimal. */
  28 #define BUF_SIZE 4096
  29
  30 enum trace_ctl_op {
  31   CTL_OP_CREATE_START,
  32         CTL_OP_CREATE,
  33         CTL_OP_DESTROY,
  34   CTL_OP_STOP_DESTROY,
  35         CTL_OP_START,
  36         CTL_OP_STOP,
  37         CTL_OP_DAEMON,
  38         CTL_OP_DESCRIPTION,
  39         CTL_OP_NONE
  40 };
  41
  42 static char *trace_name = NULL;
  43 static char *mode_name = NULL;
  44 static unsigned subbuf_size = 0;
  45 static unsigned n_subbufs = 0;
  46 static unsigned append_trace = 0;
  47 static enum trace_mode mode = LTT_TRACE_NORMAL;
  48 static enum trace_ctl_op op = CTL_OP_NONE;
  49 static char *channel_root = NULL;
  50 static char *trace_root = NULL;
  51 static char *num_threads = "1";
  52
  53 static int sigchld_received = 0;
  54
  55 void sigchld_handler(int signo)
  56 {
  57         printf("signal %d received\n", signo);
  58         sigchld_received = 1;
  59 }
  60
  61
  62 /* Args :
  63  *
  64  */
  65 void show_arguments(void)
  66 {
  67         printf("Please use the following arguments :\n");
  68         printf("\n");
  69         printf("-n name       Name of the trace.\n");
  70         printf("-b            Create trace channels and start tracing (no daemon).\n");
  71         printf("-c            Create trace channels.\n");
  72         printf("-m mode       Normal or flight recorder mode.\n");
  73         printf("              Mode values : normal (default) or flight.\n");
  74         printf("-r            Destroy trace channels.\n");
  75         printf("-R            Stop tracing and destroy trace channels.\n");
  76         printf("-s            Start tracing.\n");
  77         //printf("              Note : will automatically create a normal trace if "
  78         //                                                                                      "none exists.\n");
  79         printf("-q            Stop tracing.\n");
  80         printf("-d            Create trace, spawn a lttd daemon, start tracing.\n");
  81         printf("              (optionnaly, you can set LTT_DAEMON\n");
  82         printf("              and the LTT_FACILITIES env. vars.)\n");
  83         printf("-t            Trace root path. (ex. /root/traces/example_trace)\n");
  84         printf("-l            LTT channels root path. (ex. /mnt/relayfs/ltt)\n");
  85         printf("-z            Size of the subbuffers (will be rounded to next page size)\n");
  86         printf("-x            Number of subbuffers\n");
  87         printf("-e            Get XML facilities description\n");
  88         printf("-a            Append to trace\n");
  89         printf("-N            Number of lttd threads\n");
  90         printf("\n");
  91 }
  92
  93
  94 /* parse_arguments
  95  *
  96  * Parses the command line arguments.
  97  *
  98  * Returns -1 if the arguments were correct, but doesn't ask for program
  99  * continuation. Returns EINVAL if the arguments are incorrect, or 0 if OK.
 100  */
 101 int parse_arguments(int argc, char **argv)
 102 {
 103         int ret = 0;
 104         int argn = 1;
 105
 106         if(argc == 2) {
 107                 if(strcmp(argv[1], "-h") == 0) {
 108                         return -1;
 109                 }
 110         }
 111
 112         while(argn < argc) {
 113
 114                 switch(argv[argn][0]) {
 115                         case '-':
 116                                 switch(argv[argn][1]) {
 117                                         case 'n':
 118                                                 if(argn+1 < argc) {
 119                                                         trace_name = argv[argn+1];
 120                                                         argn++;
 121                                                 } else {
 122                                                         printf("Specify a trace name after -n.\n");
 123                                                         printf("\n");
 124                                                         ret = EINVAL;
 125                                                 }
 126
 127                                                 break;
 128           case 'b':
 129             op = CTL_OP_CREATE_START;
 130                                                 break;
 131                                         case 'c':
 132                                                 op = CTL_OP_CREATE;
 133             break;
 134                                         case 'm':
 135                                                 if(argn+1 < argc) {
 136                                                         mode_name = argv[argn+1];
 137                                                         argn++;
 138                                                         if(strcmp(mode_name, "normal") == 0)
 139                                                                 mode = LTT_TRACE_NORMAL;
 140                                                         else if(strcmp(mode_name, "flight") == 0)
 141                                                                 mode = LTT_TRACE_FLIGHT;
 142                                                         else {
 143                                                                 printf("Invalid mode '%s'.\n", argv[argn]);
 144                                                                 printf("\n");
 145                                                                 ret = EINVAL;
 146                                                         }
 147                                                 } else {
 148                                                                 printf("Specify a mode after -m.\n");
 149                                                                 printf("\n");
 150                                                                 ret = EINVAL;
 151                                                 }
 152                                                 break;
 153                                         case 'r':
 154                                                 op = CTL_OP_DESTROY;
 155                                                 break;
 156                                         case 'R':
 157                                                 op = CTL_OP_STOP_DESTROY;
 158                                                 break;
 159                                         case 's':
 160                                                 op = CTL_OP_START;
 161                                                 break;
 162                                         case 'q':
 163                                                 op = CTL_OP_STOP;
 164                                                 break;
 165                                         case 'z':
 166                                                 if(argn+1 < argc) {
 167                                                         subbuf_size = (unsigned)atoi(argv[argn+1]);
 168                                                         argn++;
 169                                                 } else {
 170                                                         printf("Specify a number of subbuffers after -z.\n");
 171                                                         printf("\n");
 172                                                         ret = EINVAL;
 173                                                 }
 174                                                 break;
 175                                         case 'x':
 176                                                 if(argn+1 < argc) {
 177                                                         n_subbufs = (unsigned)atoi(argv[argn+1]);
 178                                                         argn++;
 179                                                 } else {
 180                                                         printf("Specify a subbuffer size after -x.\n");
 181                                                         printf("\n");
 182                                                         ret = EINVAL;
 183                                                 }
 184                                                 break;
 185                                         case 'd':
 186                                                 op = CTL_OP_DAEMON;
 187                                                 break;
 188           case 'e':
 189             op = CTL_OP_DESCRIPTION;
 190             break;
 191                                         case 't':
 192                                                 if(argn+1 < argc) {
 193                                                         trace_root = argv[argn+1];
 194                                                         argn++;
 195                                                 } else {
 196                                                         printf("Specify a trace root path after -t.\n");
 197                                                         printf("\n");
 198                                                         ret = EINVAL;
 199                                                 }
 200                                                 break;
 201                                         case 'l':
 202                                                 if(argn+1 < argc) {
 203                                                         channel_root = argv[argn+1];
 204                                                         argn++;
 205                                                 } else {
 206                                                         printf("Specify a channel root path after -l.\n");
 207                                                         printf("\n");
 208                                                         ret = EINVAL;
 209                                                 }
 210                                                 break;
 211           case 'a':
 212             append_trace = 1;
 213             break;
 214           case 'N':
 215                                                 if(argn+1 < argc) {
 216                                                         num_threads = argv[argn+1];
 217                                                         argn++;
 218                                                 }
 219                                                 break;
 220                                         default:
 221                                                 printf("Invalid argument '%s'.\n", argv[argn]);
 222                                                 printf("\n");
 223                                                 ret = EINVAL;
 224                                 }
 225                                 break;
 226                         default:
 227                                 printf("Invalid argument '%s'.\n", argv[argn]);
 228                                 printf("\n");
 229                                 ret = EINVAL;
 230                 }
 231                 argn++;
 232         }
 233
 234         if(op != CTL_OP_DESCRIPTION && trace_name == NULL) {
 235                 printf("Please specify a trace name.\n");
 236                 printf("\n");
 237                 ret = EINVAL;
 238         }
 239
 240         if(op == CTL_OP_NONE) {
 241                 printf("Please specify an operation.\n");
 242                 printf("\n");
 243                 ret = EINVAL;
 244         }
 245
 246         if(op == CTL_OP_DAEMON) {
 247                 if(trace_root == NULL) {
 248                         printf("Please specify -t trace_root_path with the -d option.\n");
 249                         printf("\n");
 250                         ret = EINVAL;
 251                 }
 252                 if(channel_root == NULL) {
 253                         printf("Please specify -l ltt_root_path with the -d option.\n");
 254                         printf("\n");
 255                         ret = EINVAL;
 256                 }
 257         }
 258
 259   if(op == CTL_OP_DESCRIPTION) {
 260     if(trace_root == NULL) {
 261                         printf("Please specify -t trace_root_path with the -e option.\n");
 262                         printf("\n");
 263                         ret = EINVAL;
 264     }
 265   }
 266
 267         return ret;
 268 }
 269
 270 void show_info(void)
 271 {
 272         printf("Linux Trace Toolkit Trace Control\n");
 273         printf("\n");
 274   if(trace_name != NULL) {
 275         printf("Controlling trace : %s\n", trace_name);
 276         printf("\n");
 277   }
 278 }
 279
 280 int create_eventdefs(void)
 281 {
 282   int ret = 0;
 283   char eventdefs_path[PATH_MAX];
 284   char eventdefs_file[PATH_MAX];
 285   char facilities_file[PATH_MAX];
 286   char read_buf[BUF_SIZE];
 287   struct dirent *entry;
 288         char *facilities_path = getenv("LTT_FACILITIES");
 289         if(facilities_path == NULL) facilities_path =
 290           PACKAGE_DATA_DIR "/" PACKAGE "/facilities";
 291
 292   ret = mkdir(trace_root, S_IRWXU|S_IRWXG|S_IRWXO);
 293   if(ret == -1 && errno != EEXIST) {
 294     ret = errno;
 295     perror("Cannot create trace_root directory");
 296     printf("trace_root is %s\n", trace_root);
 297     goto error;
 298   }
 299   ret = 0;
 300
 301   size_t trace_root_len = strlen(trace_root);
 302   strncpy(eventdefs_path, trace_root, PATH_MAX);
 303   strncat(eventdefs_path, "/eventdefs/", PATH_MAX - trace_root_len);
 304   size_t eventdefs_path_len = strlen(eventdefs_path);
 305   ret = mkdir(eventdefs_path, S_IRWXU|S_IRWXG|S_IRWXO);
 306   if(ret == -1 && (!append_trace || errno != EEXIST)) {
 307     ret = errno;
 308     perror("Cannot create eventdefs directory");
 309     goto error;
 310   }
 311   ret = 0;
 312
 313   DIR *facilities_dir = opendir(facilities_path);
 314
 315   if(facilities_dir == NULL) {
 316     perror("Cannot open facilities directory");
 317     ret = EEXIST;
 318     goto error;
 319   }
 320
 321   while((entry = readdir(facilities_dir)) != NULL) {
 322     if(entry->d_name[0] == '.') continue;
 323
 324     printf("Appending facility file %s\n", entry->d_name);
 325     strncpy(eventdefs_file, eventdefs_path, PATH_MAX);
 326     strncat(eventdefs_file, entry->d_name, PATH_MAX - eventdefs_path_len);
 327     /* Append to the file */
 328     FILE *dest = fopen(eventdefs_file, "a");
 329     if(!dest) {
 330       perror("Cannot create eventdefs file");
 331       continue;
 332     }
 333     strncpy(facilities_file, facilities_path, PATH_MAX);
 334     size_t facilities_dir_len = strlen(facilities_path);
 335     strncat(facilities_file, "/", PATH_MAX - facilities_dir_len);
 336     strncat(facilities_file, entry->d_name, PATH_MAX - facilities_dir_len-1);
 337     FILE *src = fopen(facilities_file, "r");
 338     if(!src) {
 339       ret = errno;
 340       perror("Cannot open eventdefs file for reading");
 341       goto close_dest;
 342     }
 343
 344     do {
 345       size_t read_size, write_size;
 346       read_size = fread(read_buf, sizeof(char), BUF_SIZE, src);
 347       if(ferror(src)) {
 348         ret = errno;
 349         perror("Cannot read eventdefs file");
 350         goto close_src;
 351       }
 352       write_size = fwrite(read_buf, sizeof(char), read_size, dest);
 353       if(ferror(dest)) {
 354         ret = errno;
 355         perror("Cannot write eventdefs file");
 356         goto close_src;
 357       }
 358     } while(!feof(src));
 359
 360     /* Add spacing between facilities */
 361     fwrite("\n", 1, 1, dest);
 362
 363 close_src:
 364     fclose(src);
 365 close_dest:
 366     fclose(dest);
 367   }
 368
 369   closedir(facilities_dir);
 370
 371 error:
 372   return ret;
 373
 374 }
 375
 376
 377 int lttctl_daemon(struct lttctl_handle *handle, char *trace_name)
 378 {
 379         char channel_path[PATH_MAX] = "";
 380         pid_t pid;
 381         int ret;
 382         char *lttd_path = getenv("LTT_DAEMON");
 383         struct sigaction act;
 384
 385         if(lttd_path == NULL) lttd_path =
 386     PACKAGE_BIN_DIR "/lttd";
 387
 388         strcat(channel_path, channel_root);
 389         strcat(channel_path, "/");
 390         strcat(channel_path, trace_name);
 391
 392
 393         ret = lttctl_create_trace(handle, trace_name, mode, subbuf_size, n_subbufs);
 394         if(ret != 0) goto create_error;
 395
 396         act.sa_handler = sigchld_handler;
 397         sigemptyset(&(act.sa_mask));
 398         sigaddset(&(act.sa_mask), SIGCHLD);
 399         sigaction(SIGCHLD, &act, NULL);
 400
 401         pid = fork();
 402
 403         if(pid > 0) {
 404     int status;
 405                 /* parent */
 406                 while(!(sigchld_received)) pause();
 407
 408     waitpid(pid, &status, 0);
 409     ret = 0;
 410     if(WIFEXITED(status))
 411       ret = WEXITSTATUS(status);
 412     if(ret) goto start_error;
 413
 414                 printf("Creating supplementary trace files\n");
 415     ret = create_eventdefs();
 416     if(ret) goto start_error;
 417
 418         } else if(pid == 0) {
 419                 /* child */
 420     int ret;
 421     if(append_trace)
 422                 ret =   execlp(lttd_path, lttd_path, "-t", trace_root, "-c",
 423                        channel_path, "-d", "-a", "-N", num_threads, NULL);
 424     else
 425                 ret =   execlp(lttd_path, lttd_path, "-t", trace_root, "-c",
 426                        channel_path, "-d", "-N", num_threads, NULL);
 427                 if(ret) {
 428       ret = errno;
 429                         perror("Error in executing the lttd daemon");
 430                         exit(ret);
 431                 }
 432         } else {
 433                 /* error */
 434                 perror("Error in forking for lttd daemon");
 435         }
 436
 437         ret = lttctl_start(handle, trace_name);
 438         if(ret != 0) goto start_error;
 439
 440         return 0;
 441
 442         /* error handling */
 443 start_error:
 444   printf("Trace start error\n");
 445         ret |= lttctl_destroy_trace(handle, trace_name);
 446 create_error:
 447         return ret;
 448 }
 449
 450 int main(int argc, char ** argv)
 451 {
 452         int ret;
 453         struct lttctl_handle *handle;
 454
 455         ret = parse_arguments(argc, argv);
 456
 457         if(ret != 0) show_arguments();
 458         if(ret == EINVAL) return EINVAL;
 459         if(ret == -1) return 0;
 460
 461         show_info();
 462
 463         handle = lttctl_create_handle();
 464
 465         if(handle == NULL) return -1;
 466
 467         switch(op) {
 468     case CTL_OP_CREATE_START:
 469                         ret = lttctl_create_trace(handle, trace_name, mode, subbuf_size,
 470                                                                                                                                 n_subbufs);
 471       if(!ret)
 472         ret = lttctl_start(handle, trace_name);
 473       break;
 474         case CTL_OP_CREATE:
 475                         ret = lttctl_create_trace(handle, trace_name, mode, subbuf_size,
 476                                                                                                                                 n_subbufs);
 477       break;
 478                 case CTL_OP_DESTROY:
 479                         ret = lttctl_destroy_trace(handle, trace_name);
 480                         break;
 481                 case CTL_OP_STOP_DESTROY:
 482                         ret = lttctl_stop(handle, trace_name);
 483       if(!ret)
 484                         ret = lttctl_destroy_trace(handle, trace_name);
 485                         break;
 486                 case CTL_OP_START:
 487                         ret = lttctl_start(handle, trace_name);
 488                         break;
 489                 case CTL_OP_STOP:
 490                         ret = lttctl_stop(handle, trace_name);
 491                         break;
 492                 case CTL_OP_DAEMON:
 493                         ret = lttctl_daemon(handle, trace_name);
 494                         break;
 495     case CTL_OP_DESCRIPTION:
 496       ret = create_eventdefs();
 497       break;
 498                 case CTL_OP_NONE:
 499                         break;
 500         }
 501
 502         ret |= lttctl_destroy_handle(handle);
 503
 504         return ret;
 505 }