One Level Up Top Level

runtime/ktap.h - ktap

Data types defined

Functions defined

Macros defined

Source code

  1. #ifndef __KTAP_H__
  2. ‌#define __KTAP_H__

  4. #include <linux/version.h>
  5. #include <linux/hardirq.h>
  6. #include <linux/trace_seq.h>

  8. #ifndef raw_cpu_ptr
  9. ‌#define raw_cpu_ptr __this_cpu_ptr
  10. #endif

  12. /* for built-in library C function register */
  13. ‌typedef struct ktap_libfunc {
  14.         const char *name; /* function name */
  15.         ktap_cfunction func; /* function pointer */
  16. ‌} ktap_libfunc_t;

  18. long gettimeofday_ns(void); /* common helper function */
  19. int kp_lib_init_base(ktap_state_t *ks);
  20. int kp_lib_init_kdebug(ktap_state_t *ks);
  21. int kp_lib_init_timer(ktap_state_t *ks);
  22. int kp_lib_init_table(ktap_state_t *ks);
  23. int kp_lib_init_ansi(ktap_state_t *ks);
  24. int kp_lib_init_net(ktap_state_t *ks);
  25. #ifdef CONFIG_KTAP_FFI
  26. int kp_lib_init_ffi(ktap_state_t *ks);
  27. #endif

  29. void kp_exit_timers(ktap_state_t *ks);
  30. void kp_freeupval(ktap_state_t *ks, ktap_upval_t *uv);

  32. extern int (*kp_ftrace_profile_set_filter)(struct perf_event *event,
  33.                        int event_id,
  34.                        const char *filter_str);

  36. extern struct syscall_metadata **syscalls_metadata;

  38. /* get from kernel/trace/trace.h */
  39. ‌static __always_inline int trace_get_context_bit(void)
  40. {
  41.     int bit;

  43.     if (in_interrupt()) {
  44.         if (in_nmi())
  45.             bit = 0;
  46.         else if (in_irq())
  47.             bit = 1;
  48.         else
  49.             bit = 2;
  50.     } else
  51.         bit = 3;

  53.     return bit;
  54. }

  56. ‌static __always_inline int get_recursion_context(ktap_state_t *ks)
  57. {
  58.     int rctx = trace_get_context_bit();
  59.     int *val = raw_cpu_ptr(G(ks)->recursion_context[rctx]);

  61.     if (*val)
  62.         return -1;

  64.     *val = true;
  65.     return rctx;
  66. }

  68. ‌static inline void put_recursion_context(ktap_state_t *ks, int rctx)
  69. {
  70.     int *val = raw_cpu_ptr(G(ks)->recursion_context[rctx]);
  71.     *val = false;
  72. }

  74. ‌static inline void *kp_this_cpu_state(ktap_state_t *ks, int rctx)
  75. {
  76.     return this_cpu_ptr(G(ks)->percpu_state[rctx]);
  77. }

  79. ‌static inline void *kp_this_cpu_print_buffer(ktap_state_t *ks)
  80. {
  81.     return this_cpu_ptr(G(ks)->percpu_print_buffer[trace_get_context_bit()]);
  82. }

  84. ‌static inline void *kp_this_cpu_temp_buffer(ktap_state_t *ks)
  85. {
  86.     return this_cpu_ptr(G(ks)->percpu_temp_buffer[trace_get_context_bit()]);
  87. }

  89. ‌#define kp_verbose_printf(ks, ...) \
  90.     if (G(ks)->parm->verbose)    \
  91.         kp_printf(ks, "[verbose] "__VA_ARGS__);

  93. /* argument operation macro */
  94. ‌#define kp_arg(ks, idx)    ((ks)->func + (idx))
  95. ‌#define kp_arg_nr(ks)    ((int)(ks->top - (ks->func + 1)))

  97. ‌#define kp_arg_check(ks, idx, type)                \
  98.     do {                            \
  99.         if (unlikely(itype(kp_arg(ks, idx)) != type)) {    \
  100.             kp_error(ks, "wrong type of argument %d\n", idx);\
  101.             return -1;                \
  102.         }                        \
  103.     } while (0)

  105. ‌#define kp_arg_checkstring(ks, idx)                \
  106.     ({                            \
  107.         ktap_val_t *o = kp_arg(ks, idx);        \
  108.         if (unlikely(!is_string(o))) {            \
  109.             kp_error(ks, "wrong type of argument %d\n", idx); \
  110.             return -1;                \
  111.         }                        \
  112.         svalue(o);                    \
  113.     })

  115. ‌#define kp_arg_checkfunction(ks, idx)                \
  116.     ({                            \
  117.         ktap_val_t *o = kp_arg(ks, idx);        \
  118.         if (unlikely(!is_function(o))) {            \
  119.             kp_error(ks, "wrong type of argument %d\n", idx); \
  120.             return -1;                \
  121.         }                        \
  122.         clvalue(o);                    \
  123.     })

  125. ‌#define kp_arg_checknumber(ks, idx)                \
  126.     ({                            \
  127.         ktap_val_t *o = kp_arg(ks, idx);        \
  128.         if (unlikely(!is_number(o))) {            \
  129.             kp_error(ks, "wrong type of argument %d\n", idx); \
  130.             return -1;                \
  131.         }                        \
  132.         nvalue(o);                    \
  133.     })

  135. ‌#define kp_arg_checkoptnumber(ks, idx, def)            \
  136.     ({                            \
  137.         ktap_number n;                    \
  138.         if (idx > kp_arg_nr(ks)) {                \
  139.             n = def;                \
  140.         } else {                    \
  141.             ktap_val_t *o = kp_arg(ks, idx);    \
  142.             if (unlikely(!is_number(o))) {        \
  143.                 kp_error(ks, "wrong type of argument %d\n", \
  144.                          idx);        \
  145.                 return -1;            \
  146.             }                    \
  147.             n = nvalue(o);                \
  148.         }                        \
  149.         n;                        \
  150.     })

  152. ‌#define kp_error(ks, args...)            \
  153.     do {                    \
  154.         kp_printf(ks, "error: "args);    \
  155.         kp_vm_try_to_exit(ks);        \
  156.         G(ks)->state = KTAP_ERROR;    \
  157.     } while(0)


  160. /* TODO: this code need to cleanup */
  161. #if LINUX_VERSION_CODE > KERNEL_VERSION(3, 5, 0)
  162. ‌#define SPRINT_SYMBOL    sprint_symbol_no_offset
  163. #else
  164. ‌#define SPRINT_SYMBOL    sprint_symbol
  165. #endif

  167. extern int kp_max_loop_count;

  169. void kp_printf(ktap_state_t *ks, const char *fmt, ...);
  170. void __kp_puts(ktap_state_t *ks, const char *str);
  171. void __kp_bputs(ktap_state_t *ks, const char *str);

  173. ‌#define kp_puts(ks, str) ({                        \
  174.     static const char *trace_printk_fmt                \
  175.         __attribute__((section("__trace_printk_fmt"))) =    \
  176.         __builtin_constant_p(str) ? str : NULL;            \
  177.                                     \
  178.     if (__builtin_constant_p(str))                    \
  179.         __kp_bputs(ks, trace_printk_fmt);        \
  180.     else                                \
  181.         __kp_puts(ks, str);        \
  182. })

  184. ‌#define err2msg(em)     (kp_err_allmsg+(int)(em))
  185. extern const char *kp_err_allmsg;

  187. #endif /* __KTAP_H__ */

One Level Up Top Level