One Level Up Top Level

userspace/kp_parse_events.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * parse_events.c - ktap events parser
  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 <unistd.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <dirent.h>
  27. #include <fcntl.h>
  28. #include <ctype.h>

  30. #include "../include/ktap_types.h"
  31. #include "../include/ktap_bc.h"
  32. #include "kp_symbol.h"
  33. #include "kp_util.h"

  35. ‌#define TRACING_EVENTS_DIR "/sys/kernel/debug/tracing/events"

  37. ‌static u8 *idmap;
  38. ‌static int idmap_size = 1024; /* set init size */
  39. ‌static int id_nr;

  41. ‌static int idmap_init(void)
  42. {
  43.     idmap = malloc(idmap_size);
  44.     if (!idmap)
  45.         return -1;

  47.     memset(idmap, 0, idmap_size);
  48.     return 0;
  49. }

  51. ‌static void idmap_free(void)
  52. {
  53.     id_nr = 0;
  54.     free(idmap);
  55. }

  57. ‌static inline int idmap_is_set(int id)
  58. {
  59.     return idmap[id / 8] & (1 << (id % 8));
  60. }

  62. ‌static void idmap_set(int id)
  63. {
  64.     if (id >= idmap_size * 8) {
  65.         int newsize = id + 100; /* allocate extra 800 id */
  66.         idmap = realloc(idmap, newsize);
  67.         memset(idmap + idmap_size, 0, newsize - idmap_size);
  68.         idmap_size = newsize;
  69.     }

  71.     if (!idmap_is_set(id))
  72.         id_nr++;

  74.     idmap[id / 8] = idmap[id / 8] | (1 << (id % 8));
  75. }

  77. ‌static void idmap_clear(int id)
  78. {
  79.     if (!idmap_is_set(id))
  80.         return;

  82.     id_nr--;
  83.     idmap[id / 8] = idmap[id / 8] & ~ (1 << (id % 8));
  84. }

  86. ‌static int idmap_get_max_id(void)
  87. {
  88.     return idmap_size * 8;
  89. }

  91. ‌static int *get_id_array()
  92. {
  93.     int *id_array;
  94.     int i, j = 0;

  96.     id_array = malloc(sizeof(int) * id_nr);
  97.     if (!id_array)
  98.         return NULL;

  100.     for (i = 0; i < idmap_get_max_id(); i++) {
  101.         if (idmap_is_set(i))
  102.             id_array[j++] = i;
  103.     }

  105.     return id_array;
  106. }

  108. ‌static int add_event(char *evtid_path)
  109. {
  110.     char id_buf[24];
  111.     int id, fd;

  113.     fd = open(evtid_path, O_RDONLY);
  114.     if (fd < 0) {
  115.         /*
  116.          * some tracepoint doesn't have id file, like ftrace,
  117.          * return success in here, and don't print error.
  118.          */
  119.         verbose_printf("warning: cannot open file %s\n", evtid_path);
  120.         return 0;
  121.     }

  123.     if (read(fd, id_buf, sizeof(id_buf)) < 0) {
  124.         fprintf(stderr, "read file error %s\n", evtid_path);
  125.         close(fd);
  126.         return -1;
  127.     }

  129.     id = atoll(id_buf);

  131.     idmap_set(id);

  133.     close(fd);
  134.     return 0;
  135. }

  137. ‌static int add_tracepoint(const char *sys_name, const char *evt_name)
  138. {
  139.     char evtid_path[PATH_MAX] = {0};

  141.     snprintf(evtid_path, PATH_MAX, "%s/%s/%s/id", TRACING_EVENTS_DIR,
  142.                     sys_name, evt_name);
  143.     return add_event(evtid_path);
  144. }

  146. ‌static int parse_events_add_tracepoint(char *sys, char *event)
  147. {
  148.     process_available_tracepoints(sys, event, add_tracepoint);
  149.     return 0;
  150. }

  152. enum {
  153.     KPROBE_EVENT,
  154.     UPROBE_EVENT,
  155. };

  157. ‌struct probe_list {
  158.     struct probe_list *next;
  159.     int type;
  160.     char event[64];
  161. };

  163. ‌static struct probe_list *probe_list_head; /* for cleanup resources */

  165. /*
  166. * Some symbol format cannot write to uprobe_events in debugfs, like:
  167. * symbol "check_one_fd.part.0" in glibc.
  168. * For those symbols, we change the format to:
  169. * "check_one_fd.part.0" -> "check_one_fd_part_0"
  170. */
  171. ‌static char *format_symbol_name(const char *old_symbol)
  172. {
  173.     char *new_name = strdup(old_symbol);
  174.     char *name = new_name;
  175.     int changed = 0;

  177.         if (!isalpha(*name) && *name != '_') {
  178.         *name = '_';
  179.         changed = 1;
  180.     }

  182.         while (*++name != '\0') {
  183.                 if (!isalpha(*name) && !isdigit(*name) && *name != '_') {
  184.             *name = '_';
  185.             changed = 1;
  186.             continue;
  187.         }
  188.         }

  190.     if (changed)
  191.         fprintf(stderr,
  192.             "Warning: symbol \"%s\" transformed to event \"%s\"\n",
  193.             old_symbol, new_name);

  195.     /* this is a good name */
  196.         return new_name;
  197. }


  200. ‌#define KPROBE_EVENTS_PATH "/sys/kernel/debug/tracing/kprobe_events"

  202. /**
  203. * @return 0 on success, otherwise -1
  204. */
  205. static int
  206. ‌write_kprobe_event(int fd, int ret_probe, const char *symbol,
  207.            unsigned long start, char *fetch_args)
  208. {
  209.     char probe_event[128] = {0};
  210.     char event[64] = {0};
  211.     struct probe_list *pl;
  212.     char event_id_path[128] = {0};
  213.     char *symbol_name;
  214.     int id_fd, ret;

  216.     /* In case some symbols cannot write to uprobe_events debugfs file */
  217.     symbol_name = format_symbol_name(symbol);

  219.     if (!fetch_args)
  220.         fetch_args = " ";

  222.     if (ret_probe) {
  223.         snprintf(event, 64, "ktap_kprobes_%d/ret_%s",
  224.              getpid(), symbol_name);
  225.         /* Return probe point must be a symbol */
  226.         snprintf(probe_event, 128, "r:%s %s %s",
  227.              event, symbol, fetch_args);
  228.     } else {
  229.         snprintf(event, 64, "ktap_kprobes_%d/%s",
  230.              getpid(), symbol_name);
  231.         snprintf(probe_event, 128, "p:%s 0x%lx %s",
  232.              event, start, fetch_args);
  233.     }

  235.     sprintf(event_id_path, "/sys/kernel/debug/tracing/events/%s/id", event);
  236.     /* if event id already exist, then don't write to kprobes_event again */
  237.     id_fd = open(event_id_path, O_RDONLY);
  238.     if (id_fd > 0) {
  239.         close(id_fd);

  241.         /* remember add event id to ids_array */
  242.         ret = add_event(event_id_path);
  243.         if (ret)
  244.             goto error;

  246.         goto out;
  247.     }

  249.     verbose_printf("write kprobe event %s\n", probe_event);

  251.     if (write(fd, probe_event, strlen(probe_event)) <= 0) {
  252.         fprintf(stderr, "Cannot write %s to %s\n", probe_event,
  253.                 KPROBE_EVENTS_PATH);
  254.         goto error;
  255.     }

  257.     /* add to cleanup list */
  258.     pl = malloc(sizeof(struct probe_list));
  259.     if (!pl)
  260.         goto error;

  262.     pl->type = KPROBE_EVENT;
  263.     pl->next = probe_list_head;
  264.     memcpy(pl->event, event, 64);
  265.     probe_list_head = pl;

  267.     ret = add_event(event_id_path);
  268.     if (ret < 0)
  269.         goto error;

  271. out:
  272.     free(symbol_name);
  273.     return 0;

  275. error:
  276.     free(symbol_name);
  277.     return -1;
  278. }

  280. ‌static unsigned long kprobes_text_start;
  281. ‌static unsigned long kprobes_text_end;

  283. ‌static void init_kprobe_prohibited_area(void)
  284. {
  285.     static int once = 0;

  287.     if (once > 0)
  288.         return;

  290.     once = 1;
  291.     kprobes_text_start     = find_kernel_symbol("__kprobes_text_start");
  292.     kprobes_text_end       = find_kernel_symbol("__kprobes_text_end");
  293. }

  295. ‌static int check_kprobe_addr_prohibited(unsigned long addr)
  296. {
  297.     if (addr >= kprobes_text_start && addr <= kprobes_text_end)
  298.         return -1;

  300.     return 0;
  301. }

  303. ‌struct probe_cb_base {
  304.     int fd;
  305.     int ret_probe;
  306.     const char *event;
  307.     char *binary;
  308.     char *symbol;
  309.     char *fetch_args;
  310. };

  312. ‌static int kprobe_symbol_actor(void *arg, const char *name, char type,
  313.                    unsigned long start)
  314. {
  315.     struct probe_cb_base *base = (struct probe_cb_base *)arg;

  317.     /* only can probe text function */
  318.     if (type != 't' && type != 'T')
  319.         return -1;

  321.     if (!strglobmatch(name, base->symbol))
  322.         return -1;

  324.     if (check_kprobe_addr_prohibited(start))
  325.         return -1;

  327.     /* ignore reture code of write debugfs */
  328.     write_kprobe_event(base->fd, base->ret_probe, name, start,
  329.                base->fetch_args);

  331.     return 0; /* success */
  332. }

  334. ‌static int parse_events_add_kprobe(char *event)
  335. {
  336.     char *symbol, *end;
  337.     struct probe_cb_base base;
  338.     int fd, ret;

  340.     fd = open(KPROBE_EVENTS_PATH, O_WRONLY);
  341.     if (fd < 0) {
  342.         fprintf(stderr, "Cannot open %s\n", KPROBE_EVENTS_PATH);
  343.         return -1;
  344.     }

  346.     end = strpbrk(event, "% ");
  347.     if (end)
  348.         symbol = strndup(event, end - event);
  349.     else
  350.         symbol = strdup(event);

  352.     base.fd = fd;
  353.     base.ret_probe = !!strstr(event, "%return");
  354.     base.symbol = symbol;
  355.     base.fetch_args = strchr(event, ' ');

  357.     init_kprobe_prohibited_area();

  359.     ret = kallsyms_parse(&base, kprobe_symbol_actor);
  360.     if (ret <= 0) {
  361.         fprintf(stderr, "cannot parse symbol \"%s\"\n", symbol);
  362.         ret = -1;
  363.     } else {
  364.         ret = 0;
  365.     }

  367.     free(symbol);
  368.     close(fd);

  370.     return ret;
  371. }

  373. ‌#define UPROBE_EVENTS_PATH "/sys/kernel/debug/tracing/uprobe_events"

  375. /**
  376. * @return 0 on success, otherwise -1
  377. */
  378. static int
  379. ‌write_uprobe_event(int fd, int ret_probe, const char *binary,
  380.            const char *symbol, unsigned long addr,
  381.            char *fetch_args)
  382. {
  383.     char probe_event[128] = {0};
  384.     char event[64] = {0};
  385.     struct probe_list *pl;
  386.     char event_id_path[128] = {0};
  387.     char *symbol_name;
  388.     int id_fd, ret;

  390.     /* In case some symbols cannot write to uprobe_events debugfs file */
  391.     symbol_name = format_symbol_name(symbol);

  393.     if (!fetch_args)
  394.         fetch_args = " ";

  396.     if (ret_probe) {
  397.         snprintf(event, 64, "ktap_uprobes_%d/ret_%s",
  398.              getpid(), symbol_name);
  399.         snprintf(probe_event, 128, "r:%s %s:0x%lx %s",
  400.              event, binary, addr, fetch_args);
  401.     } else {
  402.         snprintf(event, 64, "ktap_uprobes_%d/%s",
  403.              getpid(), symbol_name);
  404.         snprintf(probe_event, 128, "p:%s %s:0x%lx %s",
  405.              event, binary, addr, fetch_args);
  406.     }

  408.     sprintf(event_id_path, "/sys/kernel/debug/tracing/events/%s/id", event);
  409.     /* if event id already exist, then don't write to uprobes_event again */
  410.     id_fd = open(event_id_path, O_RDONLY);
  411.     if (id_fd > 0) {
  412.         close(id_fd);

  414.         /* remember add event id to ids_array */
  415.         ret = add_event(event_id_path);
  416.         if (ret)
  417.             goto error;

  419.         goto out;
  420.     }

  422.     verbose_printf("write uprobe event %s\n", probe_event);

  424.     if (write(fd, probe_event, strlen(probe_event)) <= 0) {
  425.         fprintf(stderr, "Cannot write %s to %s\n", probe_event,
  426.                 UPROBE_EVENTS_PATH);
  427.         goto error;
  428.     }

  430.     /* add to cleanup list */
  431.     pl = malloc(sizeof(struct probe_list));
  432.     if (!pl)
  433.         goto error;

  435.     pl->type = UPROBE_EVENT;
  436.     pl->next = probe_list_head;
  437.     memcpy(pl->event, event, 64);
  438.     probe_list_head = pl;

  440.     ret = add_event(event_id_path);
  441.     if (ret < 0)
  442.         goto error;

  444. out:
  445.     free(symbol_name);
  446.     return 0;

  448. error:
  449.     free(symbol_name);
  450.     return -1;
  451. }

  453. /**
  454. * TODO: avoid copy-paste stuff
  455. *
  456. * @return 1 on success, otherwise 0
  457. */
  458. #ifdef NO_LIBELF
  459. ‌static int parse_events_resolve_symbol(int fd, char *event, int type)
  460. {
  461.     char *colon, *binary, *fetch_args;
  462.     unsigned long symbol_address;

  464.     colon = strchr(event, ':');
  465.     if (!colon)
  466.         return -1;

  468.     symbol_address = strtol(colon + 1 /* skip ":" */, NULL, 0);

  470.     fetch_args = strchr(event, ' ');

  472.     /**
  473.      * We already have address, no need in resolving.
  474.      */
  475.     if (symbol_address) {
  476.         int ret;

  478.         binary = strndup(event, colon - event);
  479.         ret = write_uprobe_event(fd, !!strstr(event, "%return"), binary,
  480.                      "NULL", symbol_address, fetch_args);
  481.         free(binary);
  482.         return ret;
  483.     }

  485.     fprintf(stderr, "error: cannot resolve event \"%s\" without libelf, "
  486.             "please recompile ktap with NO_LIBELF disabled\n",
  487.             event);
  488.     exit(EXIT_FAILURE);
  489.     return -1;
  490. }

  492. #else
  493. ‌static int uprobe_symbol_actor(const char *name, vaddr_t addr, void *arg)
  494. {
  495.     struct probe_cb_base *base = (struct probe_cb_base *)arg;
  496.     int ret;

  498.     if (!strglobmatch(name, base->symbol))
  499.         return 0;

  501.     verbose_printf("uprobe: binary: \"%s\" symbol \"%s\" "
  502.             "resolved to 0x%lx\n",
  503.             base->binary, base->symbol, (unsigned long)addr);

  505.     ret = write_uprobe_event(base->fd, base->ret_probe, base->binary,
  506.                  name, addr, base->fetch_args);
  507.     if (ret)
  508.         return ret;

  510.     return 0;
  511. }

  513. ‌static int parse_events_resolve_symbol(int fd, char *event, int type)
  514. {
  515.     char *colon, *end;
  516.     vaddr_t symbol_address;
  517.     int ret;
  518.     struct probe_cb_base base = {
  519.         .fd = fd,
  520.         .event = event
  521.     };

  523.     colon = strchr(event, ':');
  524.     if (!colon)
  525.         return 0;

  527.     base.ret_probe = !!strstr(event, "%return");
  528.     symbol_address = strtol(colon + 1 /* skip ":" */, NULL, 0);
  529.     base.binary = strndup(event, colon - event);

  531.     base.fetch_args = strchr(event, ' ');

  533.     /*
  534.      * We already have address, no need in resolving.
  535.      */
  536.     if (symbol_address) {
  537.         int ret;
  538.         ret = write_uprobe_event(fd, base.ret_probe, base.binary,
  539.                      "NULL", symbol_address,
  540.                      base.fetch_args);
  541.         free(base.binary);
  542.         return ret;
  543.     }

  545.     end = strpbrk(event, "% ");
  546.     if (end)
  547.         base.symbol = strndup(colon + 1, end - 1 - colon);
  548.     else
  549.         base.symbol = strdup(colon + 1);

  551.     ret = parse_dso_symbols(base.binary, type, uprobe_symbol_actor,
  552.                 (void *)&base);
  553.     if (!ret) {
  554.         fprintf(stderr, "error: cannot find symbol %s in binary %s\n",
  555.             base.symbol, base.binary);
  556.         ret = -1;
  557.     } else if(ret > 0) {
  558.         /* no error found when parse symbols */
  559.         ret = 0;
  560.     }

  562.     free(base.binary);
  563.     free(base.symbol);

  565.     return ret;
  566. }
  567. #endif

  569. ‌static int parse_events_add_uprobe(char *old_event, int type)
  570. {
  571.     int ret;
  572.     int fd;

  574.     fd = open(UPROBE_EVENTS_PATH, O_WRONLY);
  575.     if (fd < 0) {
  576.         fprintf(stderr, "Cannot open %s\n", UPROBE_EVENTS_PATH);
  577.         return -1;
  578.     }

  580.     ret = parse_events_resolve_symbol(fd, old_event, type);

  582.     close(fd);
  583.     return ret;
  584. }

  586. ‌static int parse_events_add_probe(char *old_event)
  587. {
  588.     char *separator;

  590.     separator = strchr(old_event, ':');
  591.     if (!separator || (separator == old_event))
  592.         return parse_events_add_kprobe(old_event);
  593.     else
  594.         return parse_events_add_uprobe(old_event, FIND_SYMBOL);
  595. }

  597. ‌static int parse_events_add_sdt(char *old_event)
  598. {
  599.     return parse_events_add_uprobe(old_event, FIND_STAPSDT_NOTE);
  600. }

  602. ‌static void strim(char *s)
  603. {
  604.     size_t size;
  605.     char *end;

  607.     size = strlen(s);
  608.     if (!size)
  609.         return;

  611.     end = s + size -1;
  612.     while (end >= s && isspace(*end))
  613.         end--;

  615.     *(end + 1) = '\0';
  616. }

  618. ‌static int get_sys_event_filter_str(char *start,
  619.                     char **sys, char **event, char **filter)
  620. {
  621.     char *separator, *separator2, *ptr, *end;

  623.     while (*start == ' ')
  624.         start++;

  626.     /* find sys */
  627.     separator = strchr(start, ':');
  628.     if (!separator || (separator == start)) {
  629.         return -1;
  630.     }

  632.     ptr = malloc(separator - start + 1);
  633.     if (!ptr)
  634.         return -1;

  636.     strncpy(ptr, start, separator - start);
  637.     ptr[separator - start] = '\0';

  639.     strim(ptr);
  640.     *sys = ptr;

  642.     if (!strcmp(*sys, "probe") && (*(separator + 1) == '/')) {
  643.         /* it's uprobe event */
  644.         separator2 = strchr(separator + 1, ':');
  645.         if (!separator2)
  646.             return -1;
  647.     } else
  648.         separator2 = separator;

  650.     /* find filter */
  651.     end = start + strlen(start);
  652.     while (*--end == ' ') {
  653.     }

  655.     if (*end == '/') {
  656.         char *filter_start;

  658.         filter_start = strchr(separator2, '/');
  659.         if (filter_start == end)
  660.             return -1;

  662.         ptr = malloc(end - filter_start);
  663.         if (!ptr)
  664.             return -1;

  666.         memcpy(ptr, filter_start + 1, end - filter_start - 1);
  667.         ptr[end - filter_start - 1] = '\0';

  669.         *filter = ptr;

  671.         end = filter_start;
  672.     } else {
  673.         *filter = NULL;
  674.         end++;
  675.     }

  677.     /* find event */
  678.     ptr = malloc(end - separator);
  679.     if (!ptr)
  680.         return -1;

  682.     memcpy(ptr, separator + 1, end - separator - 1);
  683.     ptr[end - separator - 1] = '\0';

  685.     strim(ptr);
  686.     *event = ptr;

  688.     return 0;
  689. }

  691. ‌static char *get_next_eventdef(char *str)
  692. {
  693.     char *separator;

  695.     separator = strchr(str, ',');
  696.     if (!separator)
  697.         return str + strlen(str);

  699.     *separator = '\0';
  700.     return separator + 1;
  701. }

  703. ‌ktap_eventdesc_t *kp_parse_events(const char *eventdef)
  704. {
  705.     char *str = strdup(eventdef);
  706.     char *sys, *event, *filter, *next;
  707.     ktap_eventdesc_t *evdef_info;
  708.     int ret;

  710.     idmap_init();

  712. parse_next_eventdef:
  713.     next = get_next_eventdef(str);

  715.     if (get_sys_event_filter_str(str, &sys, &event, &filter))
  716.         goto error;

  718.     verbose_printf("parse_eventdef: sys[%s], event[%s], filter[%s]\n",
  719.                sys, event, filter);

  721.     if (!strcmp(sys, "probe"))
  722.         ret = parse_events_add_probe(event);
  723.     else if (!strcmp(sys, "sdt"))
  724.         ret = parse_events_add_sdt(event);
  725.     else
  726.         ret = parse_events_add_tracepoint(sys, event);

  728.     if (ret)
  729.         goto error;

  731.     /* don't trace ftrace:function when all tracepoints enabled */
  732.     if (!strcmp(sys, "*"))
  733.         idmap_clear(1);


  736.     if (filter && *next != '\0') {
  737.         fprintf(stderr, "Error: eventdef only can append one filter\n");
  738.         goto error;
  739.     }

  741.     str = next;
  742.     if (*next != '\0')
  743.         goto parse_next_eventdef;

  745.     evdef_info = malloc(sizeof(*evdef_info));
  746.     if (!evdef_info)
  747.         goto error;

  749.     evdef_info->nr = id_nr;
  750.     evdef_info->id_arr = get_id_array();
  751.     evdef_info->filter = filter;

  753.     idmap_free();
  754.     return evdef_info;
  755. error:
  756.     idmap_free();
  757.     cleanup_event_resources();
  758.     return NULL;
  759. }

  761. ‌void cleanup_event_resources(void)
  762. {
  763.     struct probe_list *pl;
  764.     const char *path;
  765.     char probe_event[128] = {0};
  766.     int fd, ret;

  768.     for (pl = probe_list_head; pl; pl = pl->next) {
  769.         if (pl->type == KPROBE_EVENT)
  770.             path = KPROBE_EVENTS_PATH;
  771.         else if (pl->type == UPROBE_EVENT)
  772.             path = UPROBE_EVENTS_PATH;
  773.         else {
  774.             fprintf(stderr, "Cannot cleanup event type %d\n",
  775.                     pl->type);
  776.             continue;
  777.         }

  779.         snprintf(probe_event, 128, "-:%s", pl->event);

  781.         fd = open(path, O_WRONLY);
  782.         if (fd < 0) {
  783.             fprintf(stderr, "Cannot open %s\n", UPROBE_EVENTS_PATH);
  784.             continue;
  785.         }

  787.         ret = write(fd, probe_event, strlen(probe_event));
  788.         if (ret <= 0) {
  789.             fprintf(stderr, "Cannot write %s to %s\n", probe_event,
  790.                     path);
  791.             close(fd);
  792.             continue;
  793.         }

  795.         close(fd);
  796.     }
  797. }

One Level Up Top Level