One Level Up Top Level

userspace/kp_main.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * main.c - ktap compiler and loader entry
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2013 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */

  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <sched.h>
  25. #include <string.h>
  26. #include <signal.h>
  27. #include <stdarg.h>
  28. #include <sys/mman.h>
  29. #include <sys/stat.h>
  30. #include <sys/ioctl.h>
  31. #include <sys/types.h>
  32. #include <unistd.h>
  33. #include <fcntl.h>
  34. #include <math.h>
  35. #include <linux/errno.h>

  37. #include "../include/ktap_types.h"
  38. #include "kp_lex.h"
  39. #include "kp_parse.h"
  40. #include "kp_symbol.h"
  41. #include "cparser.h"

  43. ‌static void usage(const char *msg_fmt, ...)
  44. {
  45.     va_list ap;

  47.     va_start(ap, msg_fmt);
  48.     vfprintf(stderr, msg_fmt, ap);
  49.     va_end(ap);

  51.     fprintf(stderr,
  52. "Usage: ktap [options] file [script args] -- cmd [args]\n"
  53. "   or: ktap [options] -e one-liner  -- cmd [args]\n"
  54. "\n"
  55. "Options and arguments:\n"
  56. "  -o file        : send script output to file, instead of stderr\n"
  57. "  -p pid         : specific tracing pid\n"
  58. "  -C cpu         : cpu to monitor in system-wide\n"
  59. "  -T             : show timestamp for event\n"
  60. "  -V             : show version\n"
  61. "  -v             : enable verbose mode\n"
  62. "  -q             : suppress start tracing message\n"
  63. "  -d             : dry run mode(register NULL callback to perf events)\n"
  64. "  -s             : simple event tracing\n"
  65. "  -b             : list byte codes\n"
  66. "  -le [glob]     : list pre-defined events in system\n"
  67. #ifndef NO_LIBELF
  68. "  -lf DSO        : list available functions from DSO\n"
  69. "  -lm DSO        : list available sdt notes from DSO\n"
  70. #endif
  71. "  file           : program read from script file\n"
  72. "  -- cmd [args]  : workload to tracing\n");

  74.     exit(EXIT_FAILURE);
  75. }

  77. ‌#define handle_error(str) do { perror(str); exit(-1); } while(0)

  79. ‌ktap_option_t uparm;
  80. ‌static int ktap_trunk_mem_size = 1024;

  82. ‌static int kp_writer(const void* p, size_t sz, void* ud)
  83. {
  84.     if (uparm.trunk_len + sz > ktap_trunk_mem_size) {
  85.         int new_size = (uparm.trunk_len + sz) * 2;
  86.         uparm.trunk = realloc(uparm.trunk, new_size);
  87.         ktap_trunk_mem_size = new_size;
  88.     }

  90.     memcpy(uparm.trunk + uparm.trunk_len, p, sz);
  91.     uparm.trunk_len += sz;

  93.     return 0;
  94. }


  97. ‌static int forks;
  98. ‌static char **workload_argv;

  100. ‌static int fork_workload(int ktap_fd)
  101. {
  102.     int pid;

  104.     pid = fork();
  105.     if (pid < 0)
  106.         handle_error("failed to fork");

  108.     if (pid > 0)
  109.         return pid;

  111.     signal(SIGTERM, SIG_DFL);

  113.     execvp("", workload_argv);

  115.     /*
  116.      * waiting ktapvm prepare all tracing event
  117.      * make it more robust in future.
  118.      */
  119.     pause();

  121.     execvp(workload_argv[0], workload_argv);

  123.     perror(workload_argv[0]);
  124.     exit(-1);

  126.     return -1;
  127. }

  129. ‌#define KTAPVM_PATH "/sys/kernel/debug/ktap/ktapvm"

  131. ‌static char *output_filename;

  133. ‌static int run_ktapvm()
  134. {
  135.         int ktapvm_fd, ktap_fd;
  136.     int ret;

  138.     ktapvm_fd = open(KTAPVM_PATH, O_RDONLY);
  139.     if (ktapvm_fd < 0)
  140.         handle_error("open " KTAPVM_PATH " failed");

  142.     ktap_fd = ioctl(ktapvm_fd, 0, NULL);
  143.     if (ktap_fd < 0)
  144.         handle_error("ioctl ktapvm failed");

  146.     kp_create_reader(output_filename);

  148.     if (forks) {
  149.         uparm.trace_pid = fork_workload(ktap_fd);
  150.         uparm.workload = 1;
  151.     }

  153.     ret = ioctl(ktap_fd, KTAP_CMD_IOC_RUN, &uparm);
  154.     switch (ret) {
  155.     case -EPERM:
  156.     case -EACCES:
  157.         fprintf(stderr, "You may not have permission to run ktap\n");
  158.         break;
  159.     }

  161.     close(ktap_fd);
  162.     close(ktapvm_fd);

  164.     return ret;
  165. }

  167. ‌int verbose;
  168. ‌static int quiet;
  169. ‌static int dry_run;
  170. ‌static int dump_bytecode;
  171. ‌static char oneline_src[1024];
  172. ‌static int trace_pid = -1;
  173. ‌static int trace_cpu = -1;
  174. ‌static int print_timestamp;

  176. ‌#define SIMPLE_ONE_LINER_FMT    \
  177.     "trace %s { print(cpu(), tid(), execname(), argstr) }"

  179. ‌static const char *script_file;
  180. ‌static int script_args_start;
  181. ‌static int script_args_end;

  183. #ifndef NO_LIBELF
  184. ‌struct binary_base
  185. {
  186.     int type;
  187.     const char *binary;
  188. };
  189. ‌static int print_symbol(const char *name, vaddr_t addr, void *arg)
  190. {
  191.     struct binary_base *base = (struct binary_base *)arg;
  192.     const char *type = base->type == FIND_SYMBOL ?
  193.         "probe" : "sdt";

  195.     printf("%s:%s:%s\n", type, base->binary, name);
  196.     return 0;
  197. }
  198. #endif

  200. ‌static void parse_option(int argc, char **argv)
  201. {
  202.     char pid[32] = {0};
  203.     char cpu_str[32] = {0};
  204.     char *next_arg;
  205.     int i, j;

  207.     for (i = 1; i < argc; i++) {
  208.         if (argv[i][0] != '-') {
  209.             script_file = argv[i];
  210.             if (!script_file)
  211.                 usage("");

  213.             script_args_start = i + 1;
  214.             script_args_end = argc;

  216.             for (j = i + 1; j < argc; j++) {
  217.                 if (argv[j][0] == '-' && argv[j][1] == '-')
  218.                     goto found_cmd;
  219.             }

  221.             return;
  222.         }

  224.         if (argv[i][0] == '-' && argv[i][1] == '-') {
  225.             j = i;
  226.             goto found_cmd;
  227.         }

  229.         next_arg = argv[i + 1];

  231.         switch (argv[i][1]) {
  232.         case 'o':
  233.             output_filename = malloc(strlen(next_arg) + 1);
  234.             if (!output_filename)
  235.                 return;

  237.             strncpy(output_filename, next_arg, strlen(next_arg));
  238.             i++;
  239.             break;
  240.         case 'e':
  241.             strncpy(oneline_src, next_arg, strlen(next_arg));
  242.             i++;
  243.             break;
  244.         case 'p':
  245.             strncpy(pid, next_arg, strlen(next_arg));
  246.             trace_pid = atoi(pid);
  247.             i++;
  248.             break;
  249.         case 'C':
  250.             strncpy(cpu_str, next_arg, strlen(next_arg));
  251.             trace_cpu = atoi(cpu_str);
  252.             i++;
  253.             break;
  254.         case 'T':
  255.             print_timestamp = 1;
  256.             break;
  257.         case 'v':
  258.             verbose = 1;
  259.             break;
  260.         case 'q':
  261.             quiet = 1;
  262.             break;
  263.         case 'd':
  264.             dry_run = 1;
  265.             break;
  266.         case 's':
  267.             sprintf(oneline_src, SIMPLE_ONE_LINER_FMT, next_arg);
  268.             i++;
  269.             break;
  270.         case 'b':
  271.             dump_bytecode = 1;
  272.             break;
  273.         case 'l': /* list available events */
  274.             switch (argv[i][2]) {
  275.             case 'e': /* tracepoints */
  276.                 list_available_events(next_arg);
  277.                 exit(EXIT_SUCCESS);
  278. #ifndef NO_LIBELF
  279.             case 'f': /* functions in DSO */
  280.             case 'm': /* static marks in DSO */ {
  281.                 const char *binary = next_arg;
  282.                 int type = argv[i][2] == 'f' ?
  283.                         FIND_SYMBOL : FIND_STAPSDT_NOTE;
  284.                 struct binary_base base = {
  285.                     .type = type,
  286.                     .binary = binary,
  287.                 };
  288.                 int ret;

  290.                 ret = parse_dso_symbols(binary, type,
  291.                             print_symbol,
  292.                             (void *)&base);
  293.                 if (ret <= 0) {
  294.                     fprintf(stderr,
  295.                     "error: no symbols in binary %s\n",
  296.                         binary);
  297.                     exit(EXIT_FAILURE);
  298.                 }
  299.                 exit(EXIT_SUCCESS);
  300.             }
  301. #endif
  302.             default:
  303.                 exit(EXIT_FAILURE);
  304.             }
  305.             break;
  306.         case 'V':
  307. #ifdef CONFIG_KTAP_FFI
  308.             usage("%s (with FFI)\n\n", KTAP_VERSION);
  309. #else
  310.             usage("%s\n\n", KTAP_VERSION);
  311. #endif
  312.             break;
  313.         case '?':
  314.         case 'h':
  315.             usage("");
  316.             break;
  317.         default:
  318.             usage("wrong argument\n");
  319.             break;
  320.         }
  321.     }

  323.     return;

  325. found_cmd:
  326.     script_args_end = j;
  327.     forks = 1;
  328.     workload_argv = &argv[j + 1];
  329. }

  331. ‌static ktap_proto_t *parse(const char *chunkname, const char *src)
  332. {
  333.     LexState ls;

  335.     ls.chunkarg = chunkname ? chunkname : "?";
  336.     kp_lex_init();
  337.     kp_buf_init(&ls.sb);
  338.     kp_lex_setup(&ls, src);
  339.     return kp_parse(&ls);
  340. }

  342. ‌static void compile(const char *input)
  343. {
  344.     ktap_proto_t *pt;
  345.     char *buff;
  346.     struct stat sb;
  347.     int fdin;

  349.     kp_str_resize();

  351.     if (oneline_src[0] != '\0') {
  352.         ffi_cparser_init();
  353.         pt = parse(input, oneline_src);
  354.         goto dump;
  355.     }

  357.     fdin = open(input, O_RDONLY);
  358.     if (fdin < 0) {
  359.         fprintf(stderr, "open file %s failed\n", input);
  360.         exit(-1);
  361.     }

  363.     if (fstat(fdin, &sb) == -1)
  364.         handle_error("fstat failed");

  366.     buff = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fdin, 0);
  367.     if (buff == MAP_FAILED)
  368.         handle_error("mmap failed");

  370.     ffi_cparser_init();
  371.     pt = parse(input, buff);

  373.     munmap(buff, sb.st_size);
  374.     close(fdin);

  376. dump:
  377.     if (dump_bytecode) {
  378. #ifdef CONFIG_KTAP_FFI
  379.         kp_dump_csymbols();
  380. #endif
  381.         kp_dump_proto(pt);
  382.         exit(0);
  383.     }

  385.     /* bcwrite */
  386.     uparm.trunk = malloc(ktap_trunk_mem_size);
  387.     if (!uparm.trunk)
  388.         handle_error("malloc failed");

  390.     kp_bcwrite(pt, kp_writer, NULL, 0);
  391.     ffi_cparser_free();
  392. }

  394. ‌int main(int argc, char **argv)
  395. {
  396.     char **ktapvm_argv;
  397.     int new_index, i;
  398.     int ret;

  400.     if (argc == 1)
  401.         usage("");

  403.     parse_option(argc, argv);

  405.     if (oneline_src[0] != '\0')
  406.         script_file = "(command line)";

  408.     compile(script_file);

  410.     ktapvm_argv = (char **)malloc(sizeof(char *)*(script_args_end -
  411.                     script_args_start + 1));
  412.     if (!ktapvm_argv) {
  413.         fprintf(stderr, "canno allocate ktapvm_argv\n");
  414.         return -1;
  415.     }

  417.     ktapvm_argv[0] = malloc(strlen(script_file) + 1);
  418.     if (!ktapvm_argv[0]) {
  419.         fprintf(stderr, "canno allocate memory\n");
  420.         return -1;
  421.     }
  422.     strcpy(ktapvm_argv[0], script_file);
  423.     ktapvm_argv[0][strlen(script_file)] = '\0';

  425.     /* pass rest argv into ktapvm */
  426.     new_index = 1;
  427.     for (i = script_args_start; i < script_args_end; i++) {
  428.         ktapvm_argv[new_index] = malloc(strlen(argv[i]) + 1);
  429.         if (!ktapvm_argv[new_index]) {
  430.             fprintf(stderr, "canno allocate memory\n");
  431.             free(ktapvm_argv);
  432.             return -1;
  433.         }
  434.         strcpy(ktapvm_argv[new_index], argv[i]);
  435.         ktapvm_argv[new_index][strlen(argv[i])] = '\0';
  436.         new_index++;
  437.     }

  439.     uparm.argv = ktapvm_argv;
  440.     uparm.argc = new_index;
  441.     uparm.verbose = verbose;
  442.     uparm.trace_pid = trace_pid;
  443.     uparm.trace_cpu = trace_cpu;
  444.     uparm.print_timestamp = print_timestamp;
  445.     uparm.quiet = quiet;
  446.     uparm.dry_run = dry_run;

  448.     /* start running into kernel ktapvm */
  449.     ret = run_ktapvm();

  451.     cleanup_event_resources();
  452.     return ret;
  453. }

One Level Up Top Level