One Level Up Top Level

runtime/lib_base.c - ktap

Global variables defined

Functions defined

Macros defined

Source code

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

  25. #include <linux/version.h>
  26. #include <linux/hardirq.h>
  27. #include <linux/module.h>
  28. #include <linux/kallsyms.h>
  29. #include <linux/sched.h>
  30. #include <linux/uaccess.h>
  31. #include <linux/utsname.h>
  32. #include <linux/time.h>
  33. #include <linux/clocksource.h>
  34. #include <linux/ring_buffer.h>
  35. #include <linux/stacktrace.h>
  36. #include <linux/cred.h>
  37. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
  38. #include <linux/uidgid.h>
  39. #endif
  40. #include "../include/ktap_types.h"
  41. #include "ktap.h"
  42. #include "kp_obj.h"
  43. #include "kp_str.h"
  44. #include "kp_tab.h"
  45. #include "kp_transport.h"
  46. #include "kp_events.h"
  47. #include "kp_vm.h"

  49. ‌static int kplib_print(ktap_state_t *ks)
  50. {
  51.     int i;
  52.     int n = kp_arg_nr(ks);

  54.     for (i = 1; i <= n; i++) {
  55.         ktap_val_t *arg = kp_arg(ks, i);
  56.         if (i > 1)
  57.             kp_puts(ks, "\t");
  58.         kp_obj_show(ks, arg);
  59.     }

  61.     kp_puts(ks, "\n");
  62.     return 0;
  63. }

  65. /* don't engage with intern string in printf, use buffer directly */
  66. ‌static int kplib_printf(ktap_state_t *ks)
  67. {
  68.     struct trace_seq *seq;

  70.     preempt_disable_notrace();

  72.     seq = kp_this_cpu_print_buffer(ks);
  73.     trace_seq_init(seq);

  75.     if (kp_str_fmt(ks, seq))
  76.         goto out;

  78.     seq->buffer[seq->len] = '\0';
  79.     kp_transport_write(ks, seq->buffer, seq->len + 1);

  81. out:
  82.     preempt_enable_notrace();
  83.     return 0;
  84. }

  86. ‌#define HISTOGRAM_DEFAULT_TOP_NUM    20

  88. ‌static int kplib_print_hist(ktap_state_t *ks)
  89. {
  90.     int n ;

  92.     kp_arg_check(ks, 1, KTAP_TTAB);
  93.     n = kp_arg_checkoptnumber(ks, 2, HISTOGRAM_DEFAULT_TOP_NUM);

  95.     n = min(n, 1000);
  96.     n = max(n, HISTOGRAM_DEFAULT_TOP_NUM);

  98.     kp_tab_print_hist(ks, hvalue(kp_arg(ks, 1)), n);

  100.     return 0;
  101. }

  103. ‌static int kplib_pairs(ktap_state_t *ks)
  104. {
  105.     kp_arg_check(ks, 1, KTAP_TTAB);

  107.     set_cfunc(ks->top++, (ktap_cfunction)kp_tab_next);
  108.     set_table(ks->top++, hvalue(kp_arg(ks, 1)));
  109.     set_nil(ks->top++);
  110.     return 3;
  111. }

  113. ‌static int kplib_len(ktap_state_t *ks)
  114. {
  115.     int len = kp_obj_len(ks, kp_arg(ks, 1));

  117.     if (len < 0)
  118.         return -1;

  120.     set_number(ks->top, len);
  121.     incr_top(ks);
  122.     return 1;
  123. }

  125. ‌static int kplib_delete(ktap_state_t *ks)
  126. {
  127.     kp_arg_check(ks, 1, KTAP_TTAB);
  128.     kp_tab_clear(hvalue(kp_arg(ks, 1)));
  129.     return 0;
  130. }

  132. #ifdef CONFIG_STACKTRACE
  133. ‌static int kplib_stack(ktap_state_t *ks)
  134. {
  135.     uint16_t skip, depth = 10;

  137.     depth = kp_arg_checkoptnumber(ks, 1, 10); /* default as 10 */
  138.     depth = min_t(uint16_t, depth, KP_MAX_STACK_DEPTH);
  139.     skip = kp_arg_checkoptnumber(ks, 2, 10); /* default as 10 */

  141.     set_kstack(ks->top, depth, skip);
  142.     incr_top(ks);
  143.     return 1;
  144. }
  145. #else
  146. ‌static int kplib_stack(ktap_state_t *ks)
  147. {
  148.     kp_error(ks, "Please enable CONFIG_STACKTRACE before call stack()\n");
  149.     return -1;
  150. }
  151. #endif


  154. extern unsigned long long ns2usecs(cycle_t nsec);
  155. ‌static int kplib_print_trace_clock(ktap_state_t *ks)
  156. {
  157.     unsigned long long t;
  158.     unsigned long secs, usec_rem;
  159.     u64 timestamp;

  161.     /* use ring buffer's timestamp */
  162.     timestamp = ring_buffer_time_stamp(G(ks)->buffer, smp_processor_id());

  164.     t = ns2usecs(timestamp);
  165.     usec_rem = do_div(t, USEC_PER_SEC);
  166.     secs = (unsigned long)t;

  168.     kp_printf(ks, "%5lu.%06lu\n", secs, usec_rem);
  169.     return 0;
  170. }

  172. ‌static int kplib_num_cpus(ktap_state_t *ks)
  173. {
  174.     set_number(ks->top, num_online_cpus());
  175.     incr_top(ks);
  176.     return 1;
  177. }

  179. /* TODO: intern string firstly */
  180. ‌static int kplib_arch(ktap_state_t *ks)
  181. {
  182.     ktap_str_t *ts = kp_str_newz(ks, utsname()->machine);
  183.     if (unlikely(!ts))
  184.         return -1;

  186.     set_string(ks->top, ts);
  187.     incr_top(ks);
  188.     return 1;
  189. }

  191. /* TODO: intern string firstly */
  192. ‌static int kplib_kernel_v(ktap_state_t *ks)
  193. {
  194.     ktap_str_t *ts = kp_str_newz(ks, utsname()->release);
  195.     if (unlikely(!ts))
  196.         return -1;

  198.     set_string(ks->top, ts);
  199.     incr_top(ks);
  200.     return 1;
  201. }

  203. ‌static int kplib_kernel_string(ktap_state_t *ks)
  204. {
  205.     unsigned long addr = kp_arg_checknumber(ks, 1);
  206.     char str[256] = {0};
  207.     ktap_str_t *ts;
  208.     char *ret;

  210.     ret = strncpy((void *)str, (const void *)addr, 256);
  211.     (void) &ret;  /* Silence compiler warning. */
  212.     str[255] = '\0';

  214.     ts = kp_str_newz(ks, str);
  215.     if (unlikely(!ts))
  216.         return -1;

  218.     set_string(ks->top, ts);
  219.     incr_top(ks);
  220.     return 1;
  221. }

  223. ‌static int kplib_user_string(ktap_state_t *ks)
  224. {
  225.     unsigned long addr = kp_arg_checknumber(ks, 1);
  226.     char str[256] = {0};
  227.     ktap_str_t *ts;
  228.     int ret;

  230.     pagefault_disable();
  231.     ret = __copy_from_user_inatomic((void *)str, (const void *)addr, 256);
  232.     (void) &ret;  /* Silence compiler warning. */
  233.     pagefault_enable();
  234.     str[255] = '\0';

  236.     ts = kp_str_newz(ks, str);
  237.     if (unlikely(!ts))
  238.         return -1;

  240.     set_string(ks->top, ts);
  241.     incr_top(ks);
  242.     return 1;
  243. }

  245. ‌static int kplib_stringof(ktap_state_t *ks)
  246. {
  247.     ktap_val_t *v = kp_arg(ks, 1);
  248.     const ktap_str_t *ts = NULL;

  250.     if (itype(v) == KTAP_TEVENTSTR) {
  251.         ts = kp_event_stringify(ks);
  252.     } else if (itype(v) == KTAP_TKIP) {
  253.         char str[KSYM_SYMBOL_LEN];

  255.         SPRINT_SYMBOL(str, nvalue(v));
  256.         ts = kp_str_newz(ks, str);
  257.     }

  259.     if (unlikely(!ts))
  260.         return -1;

  262.     set_string(ks->top++, ts);
  263.     return 1;
  264. }

  266. ‌static int kplib_ipof(ktap_state_t *ks)
  267. {
  268.     unsigned long addr = kp_arg_checknumber(ks, 1);

  270.     set_ip(ks->top++, addr);
  271.     return 1;
  272. }

  274. ‌static int kplib_gettimeofday_ns(ktap_state_t *ks)
  275. {
  276.     set_number(ks->top, gettimeofday_ns());
  277.     incr_top(ks);

  279.     return 1;
  280. }

  282. ‌static int kplib_gettimeofday_us(ktap_state_t *ks)
  283. {
  284.     set_number(ks->top, gettimeofday_ns() / NSEC_PER_USEC);
  285.     incr_top(ks);

  287.     return 1;
  288. }

  290. ‌static int kplib_gettimeofday_ms(ktap_state_t *ks)
  291. {
  292.     set_number(ks->top, gettimeofday_ns() / NSEC_PER_MSEC);
  293.     incr_top(ks);

  295.     return 1;
  296. }

  298. ‌static int kplib_gettimeofday_s(ktap_state_t *ks)
  299. {
  300.     set_number(ks->top, gettimeofday_ns() / NSEC_PER_SEC);
  301.     incr_top(ks);

  303.     return 1;
  304. }

  306. /*
  307. * use gdb to get field offset of struct task_struct, for example:
  308. *
  309. * gdb vmlinux
  310. * (gdb)p &(((struct task_struct *)0).prio)
  311. */
  312. ‌static int kplib_curr_taskinfo(ktap_state_t *ks)
  313. {
  314.     int offset = kp_arg_checknumber(ks, 1);
  315.     int fetch_bytes  = kp_arg_checkoptnumber(ks, 2, 4); /* fetch 4 bytes */

  317.     if (offset >= sizeof(struct task_struct)) {
  318.         set_nil(ks->top++);
  319.         kp_error(ks, "access out of bound value of task_struct\n");
  320.         return 1;
  321.     }

  323. ‌#define RET_VALUE ((unsigned long)current + offset)

  325.     switch (fetch_bytes) {
  326.     case 4:
  327.         set_number(ks->top, *(unsigned int *)RET_VALUE);
  328.         break;
  329.     case 8:
  330.         set_number(ks->top, *(unsigned long *)RET_VALUE);
  331.         break;
  332.     default:
  333.         kp_error(ks, "unsupported fetch bytes in curr_task_info\n");
  334.         set_nil(ks->top);
  335.         break;
  336.     }

  338. ‌#undef RET_VALUE

  340.     incr_top(ks);
  341.     return 1;
  342. }

  344. /*
  345. * This built-in function mainly purpose scripts/schedule/schedtimes.kp
  346. */
  347. ‌static int kplib_in_iowait(ktap_state_t *ks)
  348. {
  349.     set_number(ks->top, current->in_iowait);
  350.     incr_top(ks);

  352.     return 1;
  353. }

  355. ‌static int kplib_in_interrupt(ktap_state_t *ks)
  356. {
  357.     int ret = in_interrupt();

  359.     set_number(ks->top, ret);
  360.     incr_top(ks);
  361.     return 1;
  362. }

  364. ‌static int kplib_exit(ktap_state_t *ks)
  365. {
  366.     kp_vm_try_to_exit(ks);

  368.     /* do not execute bytecode any more in this thread */
  369.     return -1;
  370. }

  372. ‌static const ktap_libfunc_t base_lib_funcs[] = {
  373.     {"print", kplib_print},
  374.     {"printf", kplib_printf},
  375.     {"print_hist", kplib_print_hist},

  377.     {"pairs", kplib_pairs},
  378.     {"len", kplib_len},
  379.     {"delete", kplib_delete},

  381.     {"stack", kplib_stack},
  382.     {"print_trace_clock", kplib_print_trace_clock},

  384.     {"num_cpus", kplib_num_cpus},
  385.     {"arch", kplib_arch},
  386.     {"kernel_v", kplib_kernel_v},
  387.     {"kernel_string", kplib_kernel_string},
  388.     {"user_string", kplib_user_string},
  389.     {"stringof", kplib_stringof},
  390.     {"ipof", kplib_ipof},

  392.     {"gettimeofday_ns", kplib_gettimeofday_ns},
  393.     {"gettimeofday_us", kplib_gettimeofday_us},
  394.     {"gettimeofday_ms", kplib_gettimeofday_ms},
  395.     {"gettimeofday_s", kplib_gettimeofday_s},

  397.     {"curr_taskinfo", kplib_curr_taskinfo},

  399.     {"in_iowait", kplib_in_iowait},
  400.     {"in_interrupt", kplib_in_interrupt},

  402.     {"exit", kplib_exit},
  403.     {NULL}
  404. };

  406. ‌int kp_lib_init_base(ktap_state_t *ks)
  407. {
  408.     return kp_vm_register_lib(ks, NULL, base_lib_funcs);
  409. }

One Level Up Top Level