One Level Up Top Level

userspace/kp_util.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * util.c
  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. * Adapted from luajit and lua interpreter.
  9. * Copyright (C) 2005-2014 Mike Pall.
  10. * Copyright (C) 1994-2008 Lua.org, PUC-Rio.
  11. *
  12. * ktap is free software; you can redistribute it and/or modify it
  13. * under the terms and conditions of the GNU General Public License,
  14. * version 2, as published by the Free Software Foundation.
  15. *
  16. * ktap is distributed in the hope it will be useful, but WITHOUT
  17. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19. * more details.
  20. *
  21. * You should have received a copy of the GNU General Public License along with
  22. * this program; if not, write to the Free Software Foundation, Inc.,
  23. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  24. */

  26. #include <stdarg.h>
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <math.h>
  31. #include <ctype.h>
  32. #include "../include/ktap_types.h"
  33. #include "../include/ktap_bc.h"
  34. #include "kp_util.h"

  36. /* Error message strings. */
  37. ‌const char *kp_err_allmsg =
  38. ‌#define ERRDEF(name, msg)       msg "\0"
  39. #include "../include/ktap_errmsg.h"
  40. ;

  42. ‌const uint8_t kp_char_bits[257] = {
  43.     0,
  44.     1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  3,  3,  3,  3,  1,  1,
  45.     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  46.     2,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
  47.   152,152,152,152,152,152,152,152,152,152,  4,  4,  4,  4,  4,  4,
  48.     4,176,176,176,176,176,176,160,160,160,160,160,160,160,160,160,
  49.   160,160,160,160,160,160,160,160,160,160,160,  4,  4,  4,  4,132,
  50.     4,208,208,208,208,208,208,192,192,192,192,192,192,192,192,192,
  51.   192,192,192,192,192,192,192,192,192,192,192,  4,  4,  4,  4,  1,
  52.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  53.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  54.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  55.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  56.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  57.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  58.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
  59.   128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128
  60. };

  62. ‌void kp_buf_init(SBuf *sb)
  63. {
  64.     sb->b = (char *)malloc(200);
  65.     sb->p = NULL;
  66.     sb->e = sb->b + 200;
  67. }

  69. ‌void kp_buf_reset(SBuf *sb)
  70. {
  71.     sb->p = sb->b;
  72. }

  74. ‌void kp_buf_free(SBuf *sb)
  75. {
  76.     free(sbufB(sb));
  77. }

  79. ‌char *kp_buf_more(SBuf *sb, int sz)
  80. {
  81.     char *b;
  82.     int old_len = sbuflen(sb);

  84.     if (sz > sbufleft(sb)) {
  85.         b = realloc(sbufB(sb), sbuflen(sb) * 2);
  86.         sb->b = b;
  87.         sb->p = b + old_len;
  88.         sb->e = b + old_len * 2;
  89.     }

  91.     return sbufP(sb);
  92. }

  94. ‌char *kp_buf_need(SBuf *sb, int sz)
  95. {
  96.     char *b;
  97.     int old_len = sbuflen(sb);

  99.     if (sz > sbufsz(sb)) {
  100.         b = realloc(sbufB(sb), sz);
  101.         sb->b = b;
  102.         sb->p = b + old_len;
  103.         sb->e = b + sz;
  104.     }

  106.     return sbufB(sb);
  107. }

  109. ‌char *kp_buf_wmem(char *p, const void *q, int len)
  110. {
  111.     return (char *)memcpy(p, q, len) + len;
  112. }

  114. ‌void kp_buf_putb(SBuf *sb, int c)
  115. {
  116.     char *p = kp_buf_more(sb, 1);
  117.     *p++ = (char)c;
  118.     setsbufP(sb, p);
  119. }

  121. ‌ktap_str_t *kp_buf_str(SBuf *sb)
  122. {
  123.     return kp_str_new(sbufB(sb), sbuflen(sb));
  124. }

  126. /* Write ULEB128 to buffer. */
  127. ‌char *strfmt_wuleb128(char *p, uint32_t v)
  128. {
  129.   for (; v >= 0x80; v >>= 7)
  130.     *p++ = (char)((v & 0x7f) | 0x80);
  131.   *p++ = (char)v;
  132.   return p;
  133. }

  135. ‌void kp_err_lex(ktap_str_t *src, const char *tok, BCLine line,
  136.         ErrMsg em, va_list argp)
  137. {
  138.     const char *msg;

  140.     msg = kp_sprintfv(err2msg(em), argp);
  141.     msg = kp_sprintf("%s:%d: %s", getstr(src), line, msg);
  142.     if (tok)
  143.         msg = kp_sprintf(err2msg(KP_ERR_XNEAR), msg, tok);
  144.     fprintf(stderr, "%s: %s\n", err2msg(KP_ERR_XSYNTAX), msg);
  145.     exit(-1);
  146. }

  148. ‌void *kp_reallocv(void *block, size_t osize, size_t nsize)
  149. {
  150.     return realloc(block, nsize);
  151. }

  153. ‌static const ktap_val_t kp_niltv = { {NULL}, {KTAP_TNIL} } ;
  154. ‌#define niltv  (&kp_niltv)

  156. ‌#define gnode(t,i)    (&(t)->node[i])
  157. ‌#define gkey(n)        (&(n)->key)
  158. ‌#define gval(n)        (&(n)->val)

  160. ‌const ktap_val_t *kp_tab_get(ktap_tab_t *t, const ktap_val_t *key)
  161. {
  162.     int i;

  164.     switch (itype(key)) {
  165.     case KTAP_TNIL:
  166.         return niltv;
  167.     case KTAP_TNUM:
  168.         for (i = 0; i <= t->hmask; i++) {
  169.             ktap_val_t *v = gkey(gnode(t, i));
  170.             if (is_number(v) && nvalue(key) == nvalue(v))
  171.                 return gval(gnode(t, i));
  172.         }
  173.         break;
  174.     case KTAP_TSTR:
  175.         for (i = 0; i <= t->hmask; i++) {
  176.             ktap_val_t *v = gkey(gnode(t, i));
  177.             if (is_string(v) && (rawtsvalue(key) == rawtsvalue(v)))
  178.                 return gval(gnode(t, i));
  179.         }
  180.         break;
  181.     default:
  182.         for (i = 0; i <= t->hmask; i++) {
  183.             if (kp_obj_equal(key, gkey(gnode(t, i))))
  184.                 return gval(gnode(t, i));
  185.         }
  186.         break;
  187.     }

  189.     return niltv;
  190. }

  192. ‌const ktap_val_t *kp_tab_getstr(ktap_tab_t *t, const ktap_str_t *ts)
  193. {
  194.     int i;

  196.     for (i = 0; i <= t->hmask; i++) {
  197.         ktap_val_t *v = gkey(gnode(t, i));
  198.         if (is_string(v) && (ts == rawtsvalue(v)))
  199.             return gval(gnode(t, i));
  200.     }

  202.     return niltv;
  203. }

  205. ‌void kp_tab_setvalue(ktap_tab_t *t, const ktap_val_t *key, ktap_val_t *val)
  206. {
  207.     const ktap_val_t *v = kp_tab_get(t, key);

  209.     if (v != niltv) {
  210.         set_obj((ktap_val_t *)v, val);
  211.     } else {
  212.         if (t->freetop == t->node) {
  213.             int size = (t->hmask + 1) * sizeof(ktap_node_t);
  214.             t->node = realloc(t->node, size * 2);
  215.             memset(t->node + t->hmask + 1, 0, size);
  216.             t->freetop = t->node + (t->hmask + 1) * 2;
  217.             t->hmask = (t->hmask + 1) * 2 - 1;
  218.         }

  220.         ktap_node_t *n = --t->freetop;
  221.         set_obj(gkey(n), key);
  222.         set_obj(gval(n), val);
  223.     }
  224. }

  226. ‌ktap_val_t *kp_tab_set(ktap_tab_t *t, const ktap_val_t *key)
  227. {
  228.     const ktap_val_t *v = kp_tab_get(t, key);

  230.     if (v != niltv) {
  231.         return (ktap_val_t *)v;
  232.     } else {
  233.         if (t->freetop == t->node) {
  234.             int size = (t->hmask + 1) * sizeof(ktap_node_t);
  235.             t->node = realloc(t->node, size * 2);
  236.             memset(t->node + t->hmask + 1, 0, size);
  237.             t->freetop = t->node + (t->hmask + 1) * 2;
  238.             t->hmask = (t->hmask + 1) * 2 - 1;
  239.         }

  241.         ktap_node_t *n = --t->freetop;
  242.         set_obj(gkey(n), key);
  243.         set_nil(gval(n));
  244.         return gval(n);
  245.     }
  246. }


  249. ‌ktap_tab_t *kp_tab_new(void)
  250. {
  251.     int hsize, i;

  253.     ktap_tab_t *t = malloc(sizeof(ktap_tab_t));
  254.     t->gct = ~KTAP_TTAB;
  255.     hsize = 1024;
  256.     t->hmask = hsize - 1;
  257.     t->node = (ktap_node_t *)malloc(hsize * sizeof(ktap_node_t));
  258.     t->freetop = &t->node[hsize];
  259.     t->asize = 0;

  261.     for (i = 0; i <= t->hmask; i++) {
  262.         set_nil(&t->node[i].val);
  263.         set_nil(&t->node[i].key);
  264.     }
  265.     return t;
  266. }

  268. /* simple interned string array, use hash table in future  */
  269. ‌static ktap_str_t **strtab;
  270. ‌static int strtab_size = 1000; /* initial size */
  271. ‌static int strtab_nr;

  273. ‌void kp_str_resize(void)
  274. {
  275.     int size = strtab_size * sizeof(ktap_str_t *);

  277.     strtab = malloc(size);
  278.     if (!strtab) {
  279.         fprintf(stderr, "cannot allocate stringtable\n");
  280.         exit(-1);
  281.     }

  283.     memset(strtab, 0, size);
  284.     strtab_nr = 0;
  285. }

  287. ‌static ktap_str_t *stringtable_search(const char *str, int len)
  288. {
  289.     int i;

  291.     for (i = 0; i < strtab_nr; i++) {
  292.         ktap_str_t *s = strtab[i];
  293.         if ((len == s->len) && !memcmp(str, getstr(s), len))
  294.             return s;
  295.     }

  297.     return NULL;
  298. }

  300. ‌static void stringtable_insert(ktap_str_t *ts)
  301. {
  302.     strtab[strtab_nr++] = ts;

  304.     if (strtab_nr == strtab_size) {
  305.         int size = strtab_size * sizeof(ktap_str_t *);
  306.         strtab = realloc(strtab, size * 2);
  307.         memset(strtab + strtab_size, 0, size);
  308.         strtab_size *= 2;
  309.     }
  310. }

  312. ‌static ktap_str_t *createstrobj(const char *str, size_t l)
  313. {
  314.     ktap_str_t *ts;
  315.     size_t totalsize;  /* total size of TString object */

  317.     totalsize = sizeof(ktap_str_t) + ((l + 1) * sizeof(char));
  318.     ts = (ktap_str_t *)malloc(totalsize);
  319.     ts->gct = ~KTAP_TSTR;
  320.     ts->len = l;
  321.     ts->reserved = 0;
  322.     ts->extra = 0;
  323.     memcpy(ts + 1, str, l * sizeof(char));
  324.     ((char *)(ts + 1))[l] = '\0';  /* ending 0 */
  325.     return ts;
  326. }

  328. ‌ktap_str_t *kp_str_new(const char *str, size_t l)
  329. {
  330.     ktap_str_t *ts = stringtable_search(str, l);

  332.     if (ts)
  333.         return ts;

  335.     ts = createstrobj(str, l);
  336.     stringtable_insert(ts);
  337.     return ts;
  338. }

  340. ‌ktap_str_t *kp_str_newz(const char *str)
  341. {
  342.     return kp_str_new(str, strlen(str));
  343. }

  345. /*
  346. * todo: memory leak here
  347. */
  348. ‌char *kp_sprintf(const char *fmt, ...)
  349. {
  350.     char *msg = malloc(128);

  352.     va_list argp;
  353.     va_start(argp, fmt);
  354.     vsprintf(msg, fmt, argp);
  355.     va_end(argp);
  356.     return msg;
  357. }

  359. ‌const char *kp_sprintfv(const char *fmt, va_list argp)
  360. {
  361.     char *msg = malloc(128);

  363.     vsprintf(msg, fmt, argp);
  364.     return msg;
  365. }

  367. ‌int kp_obj_equal(const ktap_val_t *t1, const ktap_val_t *t2)
  368. {
  369.     switch (itype(t1)) {
  370.     case KTAP_TNIL:
  371.         return 1;
  372.     case KTAP_TNUM:
  373.         return nvalue(t1) == nvalue(t2);
  374.     case KTAP_TTRUE:
  375.     case KTAP_TFALSE:
  376.         return itype(t1) == itype(t2);
  377.     case KTAP_TLIGHTUD:
  378.         return pvalue(t1) == pvalue(t2);
  379.     case KTAP_TFUNC:
  380.         return fvalue(t1) == fvalue(t2);
  381.     case KTAP_TSTR:
  382.         return rawtsvalue(t1) == rawtsvalue(t2);
  383.     default:
  384.         return gcvalue(t1) == gcvalue(t2);
  385.     }

  387.     return 0;
  388. }

  390. /*
  391. * strglobmatch is copyed from perf(linux/tools/perf/util/string.c)
  392. */

  394. /* Character class matching */
  395. ‌static bool __match_charclass(const char *pat, char c, const char **npat)
  396. {
  397.     bool complement = false, ret = true;

  399.     if (*pat == '!') {
  400.         complement = true;
  401.         pat++;
  402.     }
  403.     if (*pat++ == c)    /* First character is special */
  404.         goto end;

  406.     while (*pat && *pat != ']') {    /* Matching */
  407.         if (*pat == '-' && *(pat + 1) != ']') {    /* Range */
  408.             if (*(pat - 1) <= c && c <= *(pat + 1))
  409.                 goto end;
  410.             if (*(pat - 1) > *(pat + 1))
  411.                 goto error;
  412.             pat += 2;
  413.         } else if (*pat++ == c)
  414.             goto end;
  415.     }
  416.     if (!*pat)
  417.         goto error;
  418.     ret = false;

  420. end:
  421.     while (*pat && *pat != ']')    /* Searching closing */
  422.         pat++;
  423.     if (!*pat)
  424.         goto error;
  425.     *npat = pat + 1;
  426.     return complement ? !ret : ret;

  428. error:
  429.     return false;
  430. }

  432. /* Glob/lazy pattern matching */
  433. ‌static bool __match_glob(const char *str, const char *pat, bool ignore_space)
  434. {
  435.     while (*str && *pat && *pat != '*') {
  436.         if (ignore_space) {
  437.             /* Ignore spaces for lazy matching */
  438.             if (isspace(*str)) {
  439.                 str++;
  440.                 continue;
  441.             }
  442.             if (isspace(*pat)) {
  443.                 pat++;
  444.                 continue;
  445.             }
  446.         }
  447.         if (*pat == '?') {    /* Matches any single character */
  448.             str++;
  449.             pat++;
  450.             continue;
  451.         } else if (*pat == '[')    /* Character classes/Ranges */
  452.             if (__match_charclass(pat + 1, *str, &pat)) {
  453.                 str++;
  454.                 continue;
  455.             } else
  456.                 return false;
  457.         else if (*pat == '\\') /* Escaped char match as normal char */
  458.             pat++;
  459.         if (*str++ != *pat++)
  460.             return false;
  461.     }
  462.     /* Check wild card */
  463.     if (*pat == '*') {
  464.         while (*pat == '*')
  465.             pat++;
  466.         if (!*pat)    /* Tail wild card matches all */
  467.             return true;
  468.         while (*str)
  469.             if (__match_glob(str++, pat, ignore_space))
  470.                 return true;
  471.     }
  472.     return !*str && !*pat;
  473. }

  475. /**
  476. * strglobmatch - glob expression pattern matching
  477. * @str: the target string to match
  478. * @pat: the pattern string to match
  479. *
  480. * This returns true if the @str matches @pat. @pat can includes wildcards
  481. * ('*','?') and character classes ([CHARS], complementation and ranges are
  482. * also supported). Also, this supports escape character ('\') to use special
  483. * characters as normal character.
  484. *
  485. * Note: if @pat syntax is broken, this always returns false.
  486. */
  487. ‌bool strglobmatch(const char *str, const char *pat)
  488. {
  489.     return __match_glob(str, pat, false);
  490. }

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

  494. ‌#define KALLSYMS_PATH "/proc/kallsyms"
  495. /*
  496. * read kernel symbol from /proc/kallsyms
  497. */
  498. ‌int kallsyms_parse(void *arg,
  499.            int(*process_symbol)(void *arg, const char *name,
  500.            char type, unsigned long start))
  501. {
  502.     FILE *file;
  503.     char *line = NULL;
  504.     int ret = 0;
  505.     int found = 0;

  507.     file = fopen(KALLSYMS_PATH, "r");
  508.     if (file == NULL)
  509.         handle_error("open " KALLSYMS_PATH " failed");

  511.     while (!feof(file)) {
  512.         char *symbol_addr, *symbol_name;
  513.         char symbol_type;
  514.         unsigned long start;
  515.         int line_len;
  516.         size_t n;

  518.         line_len = getline(&line, &n, file);
  519.         if (line_len < 0 || !line)
  520.             break;

  522.         line[--line_len] = '\0'; /* \n */

  524.         symbol_addr = strtok(line, " \t");
  525.         start = strtoul(symbol_addr, NULL, 16);

  527.         symbol_type = *strtok(NULL, " \t");
  528.         symbol_name = strtok(NULL, " \t");

  530.         ret = process_symbol(arg, symbol_name, symbol_type, start);
  531.         if (!ret)
  532.             found = 1;
  533.     }

  535.     free(line);
  536.     fclose(file);

  538.     return found;
  539. }

  541. ‌struct ksym_addr_t {
  542.     const char *name;
  543.     unsigned long addr;
  544. };

  546. ‌static int symbol_cmp(void *arg, const char *name, char type,
  547.               unsigned long start)
  548. {
  549.     struct ksym_addr_t *base = arg;

  551.     if (strcmp(base->name, name) == 0) {
  552.         base->addr = start;
  553.         return 1;
  554.     }

  556.     return 0;
  557. }

  559. ‌unsigned long find_kernel_symbol(const char *symbol)
  560. {
  561.     int ret;
  562.     struct ksym_addr_t arg = {
  563.         .name = symbol,
  564.         .addr = 0
  565.     };

  567.     ret = kallsyms_parse(&arg, symbol_cmp);
  568.     if (ret < 0 || arg.addr == 0) {
  569.         fprintf(stderr, "cannot read kernel symbol \"%s\" in %s\n",
  570.             symbol, KALLSYMS_PATH);
  571.         exit(EXIT_FAILURE);
  572.     }

  574.     return arg.addr;
  575. }


  578. ‌#define AVAILABLE_EVENTS_PATH "/sys/kernel/debug/tracing/available_events"

  580. ‌void list_available_events(const char *match)
  581. {
  582.     FILE *file;
  583.     char *line = NULL;

  585.     file = fopen(AVAILABLE_EVENTS_PATH, "r");
  586.     if (file == NULL)
  587.         handle_error("open " AVAILABLE_EVENTS_PATH " failed");

  589.     while (!feof(file)) {
  590.         int line_len;
  591.         size_t n;

  593.         line_len = getline(&line, &n, file);
  594.         if (line_len < 0 || !line)
  595.             break;

  597.         if (!match || strglobmatch(line, match))
  598.             printf("%s", line);
  599.     }

  601.     free(line);
  602.     fclose(file);
  603. }

  605. ‌void process_available_tracepoints(const char *sys, const char *event,
  606.                    int (*process)(const char *sys,
  607.                           const char *event))
  608. {
  609.     char *line = NULL;
  610.     FILE *file;
  611.     char str[128] = {0};

  613.     /* add '\n' into tail */
  614.     snprintf(str, 64, "%s:%s\n", sys, event);

  616.     file = fopen(AVAILABLE_EVENTS_PATH, "r");
  617.     if (file == NULL)
  618.         handle_error("open " AVAILABLE_EVENTS_PATH " failed");

  620.     while (!feof(file)) {
  621.         int line_len;
  622.         size_t n;

  624.         line_len = getline(&line, &n, file);
  625.         if (line_len < 0 || !line)
  626.             break;

  628.         if (strglobmatch(line, str)) {
  629.             char match_sys[64] = {0};
  630.             char match_event[64] = {0};
  631.             char *sep;

  633.             sep = strchr(line, ':');
  634.             memcpy(match_sys, line, sep - line);
  635.             memcpy(match_event, sep + 1,
  636.                         line_len - (sep - line) - 2);

  638.             if (process(match_sys, match_event))
  639.                 break;
  640.         }
  641.     }

  643.     free(line);
  644.     fclose(file);
  645. }

One Level Up Top Level