One Level Up Top Level

include/ktap_types.h - ktap

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * ktap types definition.
  3. *
  4. * Copyright (C) 2012-2014 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  5. * Copyright (C) 2005-2014 Mike Pall.
  6. * Copyright (C) 1994-2008 Lua.org, PUC-Rio.
  7. */

  9. #ifndef __KTAP_TYPES_H__
  10. ‌#define __KTAP_TYPES_H__

  12. #ifdef __KERNEL__
  13. #include <linux/perf_event.h>
  14. #else
  15. ‌typedef char u8;
  16. #include <stdlib.h>
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <stdint.h>
  20. ‌typedef int ptrdiff_t;
  21. #endif

  23. #include "../include/ktap_bc.h"

  25. /* Various VM limits. */
  26. ‌#define KP_MAX_MEMPOOL_SIZE    10000    /* Max. mempool size(Kbytes). */
  27. ‌#define KP_MAX_STR    512        /* Max. string length. */
  28. ‌#define KP_MAX_STRNUM    9999        /* Max. string number. */

  30. ‌#define KP_MAX_STRTAB    (1<<26)        /* Max. string table size. */
  31. ‌#define KP_MAX_HBITS    26        /* Max. hash bits. */
  32. ‌#define KP_MAX_ABITS    28        /* Max. bits of array key. */
  33. ‌#define KP_MAX_ASIZE    ((1<<(KP_MAX_ABITS-1))+1)  /* Max. array part size. */
  34. ‌#define KP_MAX_COLOSIZE    16        /* Max. elems for colocated array. */

  36. ‌#define KP_MAX_LINE    1000        /* Max. source code line number. */
  37. ‌#define KP_MAX_XLEVEL    200        /* Max. syntactic nesting level. */
  38. ‌#define KP_MAX_BCINS    (1<<26)        /* Max. # of bytecode instructions. */
  39. ‌#define KP_MAX_SLOTS    250        /* Max. # of slots in a ktap func. */
  40. ‌#define KP_MAX_LOCVAR    200        /* Max. # of local variables. */
  41. ‌#define KP_MAX_UPVAL    60        /* Max. # of upvalues. */

  43. ‌#define KP_MAX_CACHED_CFUNCTION    128    /* Max. cached global cfunction */

  45. ‌#define KP_MAX_STACK_DEPTH    50    /* Max. stack depth */

  47. /*
  48. * The first argument type of kdebug.trace_by_id()
  49. * The value is a userspace memory pointer.
  50. * Maybe embed it into the trunk file in future.
  51. */
  52. ‌typedef struct ktap_eventdesc {
  53.     int nr;  /* the number of events id */
  54.     int *id_arr; /* events id array */
  55.     char *filter;
  56. ‌} ktap_eventdesc_t;


  59. /* ktap option for each script */
  60. ‌typedef struct ktap_option {
  61.     char *trunk; /* __user */
  62.     int trunk_len;
  63.     int argc;
  64.     char **argv; /* __user */
  65.     int verbose;
  66.     int trace_pid;
  67.     int workload;
  68.     int trace_cpu;
  69.     int print_timestamp;
  70.     int quiet;
  71.     int dry_run;
  72. ‌} ktap_option_t;

  74. /*
  75. * Ioctls that can be done on a ktap fd:
  76. * todo: use _IO macro in include/uapi/asm-generic/ioctl.h
  77. */
  78. ‌#define KTAP_CMD_IOC_VERSION        ('$' + 0)
  79. ‌#define KTAP_CMD_IOC_RUN        ('$' + 1)
  80. ‌#define KTAP_CMD_IOC_EXIT        ('$' + 3)

  82. ‌#define KTAP_VERSION_MAJOR       "0"
  83. ‌#define KTAP_VERSION_MINOR       "4"

  85. ‌#define KTAP_VERSION    "ktap " KTAP_VERSION_MAJOR "." KTAP_VERSION_MINOR
  86. ‌#define KTAP_AUTHOR    "Jovi Zhangwei <jovi.zhangwei@gmail.com>"
  87. ‌#define KTAP_COPYRIGHT  KTAP_VERSION "  Copyright (C) 2012-2014, " KTAP_AUTHOR

  89. ‌#define MYINT(s)        (s[0] - '0')
  90. ‌#define VERSION         (MYINT(KTAP_VERSION_MAJOR) * 16 + MYINT(KTAP_VERSION_MINOR))

  92. ‌typedef long ktap_number;
  93. ‌typedef int ktap_instr_t;
  94. ‌typedef union ktap_obj ktap_obj_t;

  96. struct ktap_state;
  97. ‌typedef int (*ktap_cfunction) (struct ktap_state *ks);

  99. /* ktap_val_t is basic value type in ktap stack, for reference all objects */
  100. ‌typedef struct ktap_val {
  101.     union {
  102.         ktap_obj_t *gc;        /* collectable objects, str/tab/... */
  103.         void *p;        /* light userdata */
  104.         ktap_cfunction f;    /* light C functions */
  105.         ktap_number n;        /* numbers */
  106.         struct {
  107.             uint16_t depth;    /* stack depth */
  108.             uint16_t skip;    /* skip stack entries */
  109.         } stack;
  110.     } val;
  111.     union {
  112.         int type;        /* type for above val */
  113.         const unsigned int *pcr;/* Overlaps PC for ktap frames.*/
  114.     };
  115. ‌} ktap_val_t;

  117. ‌typedef ktap_val_t *StkId;

  119. ‌#define GCHeader ktap_obj_t *nextgc; u8 gct;

  121. ‌typedef struct ktap_str {
  122.     GCHeader;
  123.     u8 reserved;  /* Used by lexer for fast lookup of reserved words. */
  124.     u8 extra;
  125.     unsigned int hash;
  126.     int len;  /* number of characters in string */
  127. ‌} ktap_str_t;

  129. ‌typedef struct ktap_upval {
  130.     GCHeader;
  131.     uint8_t closed;    /* Set if closed (i.e. uv->v == &uv->u.value). */
  132.     uint8_t immutable;    /* Immutable value. */
  133.     union {
  134.         ktap_val_t tv; /* If closed: the value itself. */
  135.         struct { /* If open: double linked list, anchored at thread. */
  136.             struct ktap_upval *prev;
  137.             struct ktap_upval *next;
  138.         };
  139.     };
  140.     ktap_val_t *v;  /* Points to stack slot (open) or above (closed). */
  141. ‌} ktap_upval_t;


  144. ‌typedef struct ktap_func {
  145.     GCHeader;
  146.     u8 nupvalues;
  147.     BCIns *pc;
  148.     struct ktap_proto *p;
  149.     struct ktap_upval *upvals[1];  /* list of upvalues */
  150. ‌} ktap_func_t;

  152. ‌typedef struct ktap_proto {
  153.     GCHeader;
  154.     uint8_t numparams;    /* Number of parameters. */
  155.     uint8_t framesize;    /* Fixed frame size. */
  156.     int sizebc;        /* Number of bytecode instructions. */
  157.     ktap_obj_t *gclist;
  158.     void *k;    /* Split constant array (points to the middle). */
  159.     void *uv;    /* Upvalue list. local slot|0x8000 or parent uv idx. */
  160.     int sizekgc;    /* Number of collectable constants. */
  161.     int sizekn;    /* Number of lua_Number constants. */
  162.     int sizept;    /* Total size including colocated arrays. */
  163.     uint8_t sizeuv;    /* Number of upvalues. */
  164.     uint8_t flags;    /* Miscellaneous flags (see below). */

  166.     /* --- The following fields are for debugging/tracebacks only --- */
  167.     ktap_str_t *chunkname;    /* Chunk name this function was defined in. */
  168.     BCLine firstline;    /* First line of the function definition. */
  169.     BCLine numline;    /* Number of lines for the function definition. */
  170.     void *lineinfo;    /* Compressed map from bytecode ins. to source line. */
  171.     void *uvinfo;    /* Upvalue names. */
  172.     void *varinfo;    /* Names and compressed extents of local variables. */
  173. ‌} ktap_proto_t;

  175. /* Flags for prototype. */
  176. ‌#define PROTO_CHILD        0x01    /* Has child prototypes. */
  177. ‌#define PROTO_VARARG        0x02    /* Vararg function. */
  178. ‌#define PROTO_FFI        0x04    /* Uses BC_KCDATA for FFI datatypes. */
  179. ‌#define PROTO_NOJIT        0x08    /* JIT disabled for this function. */
  180. ‌#define PROTO_ILOOP        0x10    /* Patched bytecode with ILOOP etc. */
  181. /* Only used during parsing. */
  182. ‌#define PROTO_HAS_RETURN    0x20    /* Already emitted a return. */
  183. ‌#define PROTO_FIXUP_RETURN    0x40    /* Need to fixup emitted returns. */
  184. /* Top bits used for counting created closures. */
  185. ‌#define PROTO_CLCOUNT        0x20    /* Base of saturating 3 bit counter. */
  186. ‌#define PROTO_CLC_BITS        3
  187. ‌#define PROTO_CLC_POLY        (3*PROTO_CLCOUNT)  /* Polymorphic threshold. */

  189. ‌#define PROTO_UV_LOCAL        0x8000    /* Upvalue for local slot. */
  190. ‌#define PROTO_UV_IMMUTABLE    0x4000    /* Immutable upvalue. */

  192. ‌#define proto_kgc(pt, idx)    (((ktap_obj_t *)(pt)->k)[idx])
  193. ‌#define proto_bc(pt)        ((BCIns *)((char *)(pt) + sizeof(ktap_proto_t)))
  194. ‌#define proto_bcpos(pt, pc)    ((BCPos)((pc) - proto_bc(pt)))
  195. ‌#define proto_uv(pt)        ((uint16_t *)(pt)->uv)

  197. ‌#define proto_chunkname(pt)    ((pt)->chunkname)
  198. ‌#define proto_lineinfo(pt)    ((const void *)(pt)->lineinfo)
  199. ‌#define proto_uvinfo(pt)    ((const uint8_t *)(pt)->uvinfo)
  200. ‌#define proto_varinfo(pt)    ((const uint8_t *)(pt)->varinfo)


  203. ‌typedef struct ktap_node_t {
  204.     ktap_val_t val; /* Value object. Must be first field. */
  205.     ktap_val_t key; /* Key object. */
  206.     struct ktap_node_t *next;  /* hash chain */
  207. ‌} ktap_node_t;

  209. /* ktap_tab */
  210. ‌typedef struct ktap_tab {
  211.     GCHeader;
  212. #ifdef __KERNEL__
  213.     arch_spinlock_t lock;
  214. #endif
  215.     ktap_val_t *array;    /* Array part. */
  216.     ktap_node_t *node;    /* Hash part. */
  217.     ktap_node_t *freetop; /* any free position is before this position */

  219.     uint32_t asize;        /* Size of array part (keys [0, asize-1]). */
  220.     uint32_t hmask;        /* log2 of size of `node' array */

  222.     uint32_t hnum;        /* number of all nodes */

  224.     ktap_obj_t *gclist;
  225. ‌} ktap_tab_t;

  227. #ifdef CONFIG_KTAP_FFI
  228. ‌typedef int csymbol_id;
  229. ‌typedef uint64_t cdata_number;
  230. ‌typedef struct csymbol csymbol;

  232. /* global ffi state maintained in each ktap vm instance */
  233. ‌typedef struct ffi_state {
  234.     ktap_tab_t *ctable;
  235.     int csym_nr;
  236.     csymbol *csym_arr;
  237. ‌} ffi_state;

  239. /* instance of csymbol */
  240. ‌typedef struct ktap_cdata {
  241.     GCHeader;
  242.     csymbol_id id;
  243.     union {
  244.         cdata_number i;
  245.         struct {
  246.             void *addr;
  247.             int nmemb;    /* number of memory block */
  248.         } p;            /* pointer data */
  249.         void *rec;        /* struct member or union data */
  250.     } u;
  251. ‌} ktap_cdata_t;
  252. #endif

  254. ‌typedef struct ktap_stats {
  255.     int mem_allocated;
  256.     int nr_mem_allocate;
  257.     int events_hits;
  258.     int events_missed;
  259. ‌} ktap_stats_t;

  261. ‌#define KTAP_STATS(ks)    this_cpu_ptr(G(ks)->stats)


  264. ‌#define KTAP_RUNNING    0 /* normal running state */
  265. ‌#define KTAP_TRACE_END    1 /* running in trace_end function */
  266. ‌#define KTAP_EXIT    2 /* normal exit, set when call exit() */
  267. ‌#define KTAP_ERROR    3 /* error state, called by kp_error */

  269. ‌typedef struct ktap_global_state {
  270.     void *mempool;        /* string memory pool */
  271.     void *mp_freepos;    /* free position in memory pool */
  272.     int mp_size;        /* memory pool size */
  273. #ifdef __KERNEL__
  274.     arch_spinlock_t mp_lock;/* mempool lock */
  275. #endif

  277.     ktap_str_t **strhash;    /* String hash table (hash chain anchors). */
  278.     int strmask;        /* String hash mask (size of hash table-1). */
  279.     int strnum;        /* Number of strings in hash table. */
  280. #ifdef __KERNEL__
  281.     arch_spinlock_t str_lock; /* string operation lock */
  282. #endif

  284.     ktap_val_t registry;
  285.     ktap_tab_t *gtab;    /* global table contains cfunction and args */
  286.     ktap_obj_t *allgc; /* list of all collectable objects */
  287.     ktap_upval_t uvhead; /* head of list of all open upvalues */

  289.     struct ktap_state *mainthread; /*main state */
  290.     int state; /* status of ktapvm, KTAP_RUNNING, KTAP_TRACE_END, etc */
  291. #ifdef __KERNEL__
  292.     /* reserved global percpu data */
  293.     void __percpu *percpu_state[PERF_NR_CONTEXTS];
  294.     void __percpu *percpu_print_buffer[PERF_NR_CONTEXTS];
  295.     void __percpu *percpu_temp_buffer[PERF_NR_CONTEXTS];

  297.     /* for recursion tracing check */
  298.     int __percpu *recursion_context[PERF_NR_CONTEXTS];

  300.     ktap_option_t *parm; /* ktap options */
  301.     pid_t trace_pid;
  302.     struct task_struct *trace_task;
  303.     cpumask_var_t cpumask;
  304.     struct ring_buffer *buffer;
  305.     struct dentry *trace_pipe_dentry;
  306.     struct task_struct *task;
  307.     int trace_enabled;
  308.     int wait_user; /* flag to indicat waiting user consume content */

  310.     struct list_head timers; /* timer list */
  311.     struct ktap_stats __percpu *stats; /* memory allocation stats */
  312.     struct list_head events_head; /* probe event list */

  314.     ktap_func_t *trace_end_closure; /* trace_end closure */
  315. #ifdef CONFIG_KTAP_FFI
  316.     ffi_state  ffis;
  317. #endif

  319.     /* C function table for fast call */
  320.     int nr_builtin_cfunction;
  321.     ktap_cfunction gfunc_tbl[KP_MAX_CACHED_CFUNCTION];
  322. #endif
  323. ‌} ktap_global_state_t;


  326. ‌typedef struct ktap_state {
  327.     ktap_global_state_t *g;    /* global state */
  328.     int stop;        /* don't enter tracing handler if stop is 1 */
  329.     StkId top;        /* stack top */
  330.     StkId func;        /* execute light C function */
  331.     StkId stack_last;    /* last stack pointer */
  332.     StkId stack;        /* ktap stack, percpu pre-reserved */
  333.     ktap_upval_t *openupval;/* opened upvals list */

  335. #ifdef __KERNEL__
  336.     /* current fired event which allocated on stack */
  337.     struct ktap_event_data *current_event;
  338. #endif
  339. ‌} ktap_state_t;

  341. ‌#define G(ks)   (ks->g)

  343. ‌typedef struct ktap_rawobj {
  344.     GCHeader;
  345.     void *v;
  346. ‌} ktap_rawobj;

  348. /*
  349. * Union of all collectable objects
  350. */
  351. ‌union ktap_obj {
  352.     struct { GCHeader } gch;
  353.     struct ktap_str ts;
  354.     struct ktap_func fn;
  355.     struct ktap_tab h;
  356.     struct ktap_proto pt;
  357.     struct ktap_upval uv;
  358.     struct ktap_state th;  /* thread */
  359.     struct ktap_rawobj rawobj;
  360. #ifdef CONFIG_KTAP_FFI
  361.     struct ktap_cdata cd;
  362. #endif
  363. };

  365. ‌#define gch(o)            (&(o)->gch)

  367. /* macros to convert a ktap_obj_t into a specific value */
  368. ‌#define gco2ts(o)        (&((o)->ts))
  369. ‌#define gco2uv(o)        (&((o)->uv))
  370. ‌#define obj2gco(v)        ((ktap_obj_t *)(v))

  372. /* predefined values in the registry */
  373. ‌#define KTAP_RIDX_GLOBALS    1
  374. ‌#define KTAP_RIDX_LAST        KTAP_RIDX_GLOBALS

  376. /* ktap object types */
  377. ‌#define KTAP_TNIL        (~0u)
  378. ‌#define KTAP_TFALSE        (~1u)
  379. ‌#define KTAP_TTRUE        (~2u)
  380. ‌#define KTAP_TNUM        (~3u)
  381. ‌#define KTAP_TLIGHTUD        (~4u)
  382. ‌#define KTAP_TSTR        (~5u)
  383. ‌#define KTAP_TUPVAL        (~6u)
  384. ‌#define KTAP_TTHREAD        (~7u)
  385. ‌#define KTAP_TPROTO        (~8u)
  386. ‌#define KTAP_TFUNC        (~9u)
  387. ‌#define KTAP_TCFUNC        (~10u)
  388. ‌#define KTAP_TCDATA        (~11u)
  389. ‌#define KTAP_TTAB        (~12u)
  390. ‌#define KTAP_TUDATA        (~13u)

  392. /* Specfic types */
  393. ‌#define KTAP_TEVENTSTR        (~14u) /* argstr */
  394. ‌#define KTAP_TKSTACK        (~15u) /* stack(), not intern to string yet */
  395. ‌#define KTAP_TKIP        (~16u) /* kernel function ip addres */
  396. ‌#define KTAP_TUIP        (~17u) /* userspace function ip addres */

  398. /* This is just the canonical number type used in some places. */
  399. ‌#define KTAP_TNUMX        (~18u)


  402. ‌#define itype(o)        ((o)->type)
  403. ‌#define setitype(o, t)        ((o)->type = (t))

  405. ‌#define val_(o)            ((o)->val)
  406. ‌#define gcvalue(o)        (val_(o).gc)

  408. ‌#define nvalue(o)        (val_(o).n)
  409. ‌#define boolvalue(o)        (KTAP_TFALSE - (o)->type)
  410. ‌#define hvalue(o)        (&val_(o).gc->h)
  411. ‌#define phvalue(o)        (&val_(o).gc->ph)
  412. ‌#define clvalue(o)        (&val_(o).gc->fn)
  413. ‌#define ptvalue(o)        (&val_(o).gc->pt)

  415. ‌#define getstr(ts)        (const char *)((ts) + 1)
  416. ‌#define rawtsvalue(o)        (&val_(o).gc->ts)
  417. ‌#define svalue(o)        getstr(rawtsvalue(o))

  419. ‌#define pvalue(o)        (&val_(o).p)
  420. ‌#define fvalue(o)        (val_(o).f)
  421. #ifdef CONFIG_KTAP_FFI
  422. ‌#define cdvalue(o)        (&val_(o).gc->cd)
  423. #endif

  425. ‌#define is_nil(o)        (itype(o) == KTAP_TNIL)
  426. ‌#define is_false(o)        (itype(o) == KTAP_TFALSE)
  427. ‌#define is_true(o)        (itype(o) == KTAP_TTRUE)
  428. ‌#define is_bool(o)        (is_false(o) || is_true(o))
  429. ‌#define is_string(o)        (itype(o) == KTAP_TSTR)
  430. ‌#define is_number(o)        (itype(o) == KTAP_TNUM)
  431. ‌#define is_table(o)        (itype(o) == KTAP_TTAB)
  432. ‌#define is_proto(o)        (itype(o) == KTAP_TPROTO)
  433. ‌#define is_function(o)        (itype(o) == KTAP_TFUNC)
  434. ‌#define is_cfunc(o)        (itype(o) == KTAP_TCFUNC)
  435. ‌#define is_eventstr(o)        (itype(o) == KTAP_TEVENTSTR)
  436. ‌#define is_kip(o)        (itype(o) == KTAP_TKIP)
  437. ‌#define is_btrace(o)        (itype(o) == KTAP_TBTRACE)
  438. #ifdef CONFIG_KTAP_FFI
  439. ‌#define is_cdata(o)        (itype(o) == KTAP_TCDATA)
  440. #endif


  443. ‌#define set_nil(o)        ((o)->type = KTAP_TNIL)
  444. ‌#define set_bool(o, x)        ((o)->type = KTAP_TFALSE-(uint32_t)(x))

  446. ‌static inline void set_number(ktap_val_t *o, ktap_number n)
  447. {
  448.     setitype(o, KTAP_TNUM);
  449.     o->val.n = n;
  450. }

  452. ‌static inline void set_string(ktap_val_t *o, const ktap_str_t *str)
  453. {
  454.     setitype(o, KTAP_TSTR);
  455.     o->val.gc = (ktap_obj_t *)str;
  456. }

  458. ‌static inline void set_table(ktap_val_t *o, ktap_tab_t *tab)
  459. {
  460.     setitype(o, KTAP_TTAB);
  461.     o->val.gc = (ktap_obj_t *)tab;
  462. }

  464. ‌static inline void set_proto(ktap_val_t *o, ktap_proto_t *pt)
  465. {
  466.     setitype(o, KTAP_TPROTO);
  467.     o->val.gc = (ktap_obj_t *)pt;
  468. }

  470. ‌static inline void set_kstack(ktap_val_t *o, uint16_t depth, uint16_t skip)
  471. {
  472.     setitype(o, KTAP_TKSTACK);
  473.     o->val.stack.depth = depth;
  474.     o->val.stack.skip = skip;
  475. }

  477. ‌static inline void set_func(ktap_val_t *o, ktap_func_t *fn)
  478. {
  479.     setitype(o, KTAP_TFUNC);
  480.     o->val.gc = (ktap_obj_t *)fn;
  481. }

  483. ‌static inline void set_cfunc(ktap_val_t *o, ktap_cfunction fn)
  484. {
  485.     setitype(o, KTAP_TCFUNC);
  486.     o->val.f = fn;
  487. }

  489. ‌static inline void set_eventstr(ktap_val_t *o)
  490. {
  491.     setitype(o, KTAP_TEVENTSTR);
  492. }

  494. ‌static inline void set_ip(ktap_val_t *o, unsigned long addr)
  495. {
  496.     setitype(o, KTAP_TKIP);
  497.     o->val.n = addr;
  498. }


  501. #ifdef CONFIG_KTAP_FFI
  502. ‌#define set_cdata(o, x)        { setitype(o, KTAP_TCDATA); (o)->val.gc = x; }
  503. #endif

  505. ‌#define set_obj(o1, o2)        { *(o1) = *(o2); }

  507. ‌#define incr_top(ks)        {ks->top++;}

  509. /*
  510. * KTAP_QL describes how error messages quote program elements.
  511. * CHANGE it if you want a different appearance.
  512. */
  513. ‌#define KTAP_QL(x)      "'" x "'"
  514. ‌#define KTAP_QS         KTAP_QL("%s")

  516. #endif /* __KTAP_TYPES_H__ */

One Level Up Top Level